@ttsc/unplugin 0.30.3 → 0.31.0

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

@@ -0,0 +1,31 @@
+/**
+ * One project-walk hash set together with its completeness proof.
+ *
+ * @evidence contracts/common.md#principled-implementation The completeness flag carries the rejection evidence for partial admitted-file observations; consumers must check it. Slash-encoded identity keys are root-relative when contained and full addresses otherwise, describing the admitted walk rather than all compiler dependencies.
+ * @evidence contracts/common.md#clear-and-simple-design The container separates observation completeness from collected hashes without introducing another snapshot owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An unreadable input cannot disappear into an apparently complete successful snapshot merely because other file hashes were available.
+ * @evidence contracts/common.md#meaningful-documentation The native field comments identify the rejection requirement and hash-key encoding rather than restating their TypeScript types.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Hash keys carry native file identities encoded in the compiler's slash
+ *   protocol, root-relative when contained and full addresses otherwise.
+ *   The snapshot producer and supplied identity context own native root, link
+ *   and case interpretation; the container preserves their comparison boundary.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscProjectInputHashSnapshot only declares a shape; it has no computation
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscProjectInputHashSnapshot only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscProjectInputHashSnapshot only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscProjectInputHashSnapshot {
+    /**
+     * Whether every attempted directory and file was observed coherently;
+     * cache-key hosts must reject an incomplete set.
+     */
+    complete: boolean;
+    /** SHA-256 of admitted regular-file reads, keyed by slash-encoded identity. */
+    hashes: Record<string, string>;
+}

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

@@ -0,0 +1,31 @@
+/**
+ * One project-walk hash set together with its completeness proof.
+ *
+ * @evidence contracts/common.md#principled-implementation The completeness flag carries the rejection evidence for partial admitted-file observations; consumers must check it. Slash-encoded identity keys are root-relative when contained and full addresses otherwise, describing the admitted walk rather than all compiler dependencies.
+ * @evidence contracts/common.md#clear-and-simple-design The container separates observation completeness from collected hashes without introducing another snapshot owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An unreadable input cannot disappear into an apparently complete successful snapshot merely because other file hashes were available.
+ * @evidence contracts/common.md#meaningful-documentation The native field comments identify the rejection requirement and hash-key encoding rather than restating their TypeScript types.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Hash keys carry native file identities encoded in the compiler's slash
+ *   protocol, root-relative when contained and full addresses otherwise.
+ *   The snapshot producer and supplied identity context own native root, link
+ *   and case interpretation; the container preserves their comparison boundary.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscProjectInputHashSnapshot only declares a shape; it has no computation
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscProjectInputHashSnapshot only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscProjectInputHashSnapshot only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscProjectInputHashSnapshot {
+    /**
+     * Whether every attempted directory and file was observed coherently;
+     * cache-key hosts must reject an incomplete set.
+     */
+    complete: boolean;
+    /** SHA-256 of admitted regular-file reads, keyed by slash-encoded identity. */
+    hashes: Record<string, string>;
+}

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

@@ -0,0 +1,31 @@
+/**
+ * One project-walk hash set together with its completeness proof.
+ *
+ * @evidence contracts/common.md#principled-implementation The completeness flag carries the rejection evidence for partial admitted-file observations; consumers must check it. Slash-encoded identity keys are root-relative when contained and full addresses otherwise, describing the admitted walk rather than all compiler dependencies.
+ * @evidence contracts/common.md#clear-and-simple-design The container separates observation completeness from collected hashes without introducing another snapshot owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An unreadable input cannot disappear into an apparently complete successful snapshot merely because other file hashes were available.
+ * @evidence contracts/common.md#meaningful-documentation The native field comments identify the rejection requirement and hash-key encoding rather than restating their TypeScript types.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Hash keys carry native file identities encoded in the compiler's slash
+ *   protocol, root-relative when contained and full addresses otherwise.
+ *   The snapshot producer and supplied identity context own native root, link
+ *   and case interpretation; the container preserves their comparison boundary.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscProjectInputHashSnapshot only declares a shape; it has no computation
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscProjectInputHashSnapshot only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscProjectInputHashSnapshot only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscProjectInputHashSnapshot {
+    /**
+     * Whether every attempted directory and file was observed coherently;
+     * cache-key hosts must reject an incomplete set.
+     */
+    complete: boolean;
+    /** SHA-256 of admitted regular-file reads, keyed by slash-encoded identity. */
+    hashes: Record<string, string>;
+}

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

@@ -0,0 +1,31 @@
+/**
+ * One project-walk observation that could not prove a coherent snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation A closed failure-kind union distinguishes metadata, enumeration and read failures while the lexical path names the exact observation that failed.
+ * @evidence contracts/common.md#clear-and-simple-design The value contains only the failed observation's kind and address; retry and generation decisions remain with the consuming proof owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failure kinds are structured observation outcomes rather than inferred message fragments or synthetic missing-file success.
+ * @evidence contracts/common.md#meaningful-documentation Field comments explain the observation categories and specify lexical absolute spelling, preserving the distinction from resolved identity.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The address preserves the walk's absolute native lexical spelling instead
+ *   of replacing it with a comparison key or protocol path. Producer outcomes
+ *   classify failed or changing native metadata, listings and file reads;
+ *   consumers retain those uncertainties without depending on OS error text.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscProjectWalkFailure only declares a shape; it has no computation at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscProjectWalkFailure only declares a shape; it has no work to reuse at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscProjectWalkFailure only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscProjectWalkFailure {
+    /**
+     * How the observation failed: unreadable or changing metadata, a failed
+     * listing, or a file that failed or changed during its read.
+     */
+    kind: "directory-changed-during-walk" | "directory-metadata-unavailable" | "directory-read-failed" | "file-changed-during-read" | "file-read-failed";
+    /** Absolute lexical spelling observed by the walk. */
+    path: string;
+}

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

@@ -0,0 +1,31 @@
+/**
+ * One project-walk observation that could not prove a coherent snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation A closed failure-kind union distinguishes metadata, enumeration and read failures while the lexical path names the exact observation that failed.
+ * @evidence contracts/common.md#clear-and-simple-design The value contains only the failed observation's kind and address; retry and generation decisions remain with the consuming proof owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failure kinds are structured observation outcomes rather than inferred message fragments or synthetic missing-file success.
+ * @evidence contracts/common.md#meaningful-documentation Field comments explain the observation categories and specify lexical absolute spelling, preserving the distinction from resolved identity.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The address preserves the walk's absolute native lexical spelling instead
+ *   of replacing it with a comparison key or protocol path. Producer outcomes
+ *   classify failed or changing native metadata, listings and file reads;
+ *   consumers retain those uncertainties without depending on OS error text.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscProjectWalkFailure only declares a shape; it has no computation at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscProjectWalkFailure only declares a shape; it has no work to reuse at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscProjectWalkFailure only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscProjectWalkFailure {
+    /**
+     * How the observation failed: unreadable or changing metadata, a failed
+     * listing, or a file that failed or changed during its read.
+     */
+    kind: "directory-changed-during-walk" | "directory-metadata-unavailable" | "directory-read-failed" | "file-changed-during-read" | "file-read-failed";
+    /** Absolute lexical spelling observed by the walk. */
+    path: string;
+}

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

@@ -0,0 +1,31 @@
+/**
+ * One project-walk observation that could not prove a coherent snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation A closed failure-kind union distinguishes metadata, enumeration and read failures while the lexical path names the exact observation that failed.
+ * @evidence contracts/common.md#clear-and-simple-design The value contains only the failed observation's kind and address; retry and generation decisions remain with the consuming proof owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failure kinds are structured observation outcomes rather than inferred message fragments or synthetic missing-file success.
+ * @evidence contracts/common.md#meaningful-documentation Field comments explain the observation categories and specify lexical absolute spelling, preserving the distinction from resolved identity.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The address preserves the walk's absolute native lexical spelling instead
+ *   of replacing it with a comparison key or protocol path. Producer outcomes
+ *   classify failed or changing native metadata, listings and file reads;
+ *   consumers retain those uncertainties without depending on OS error text.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscProjectWalkFailure only declares a shape; it has no computation at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscProjectWalkFailure only declares a shape; it has no work to reuse at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscProjectWalkFailure only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscProjectWalkFailure {
+    /**
+     * How the observation failed: unreadable or changing metadata, a failed
+     * listing, or a file that failed or changed during its read.
+     */
+    kind: "directory-changed-during-walk" | "directory-metadata-unavailable" | "directory-read-failed" | "file-changed-during-read" | "file-read-failed";
+    /** Absolute lexical spelling observed by the walk. */
+    path: string;
+}

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

@@ -0,0 +1,27 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+/**
+ * Hash a list of absolute out-of-walk input paths: content SHA-256 for a
+ * readable file, a stable directory-kind digest for a directory candidate, and
+ * a stable `missing` marker otherwise. Keys use filesystem identity so
+ * equivalent spellings share one entry under the observed case/link policy,
+ * while the first observation retains the original path supplied by the
+ * compiler. The marker is state, not an error — a recorded input disappearing
+ * (or reappearing) must change the comparison exactly like a content edit.
+ * Unavailable content does not prove physical absence. The public core export
+ * supplies a physical-state dictionary; it does not preserve independent
+ * lexical predicates for every alias.
+ *
+ * @evidence contracts/common.md#principled-implementation One native identity context deduplicates addresses for this physical-state dictionary; the first spelling's read determines its value under a stable coherent view. Raw file bytes, observed directory kind and unavailable content remain distinct states, not per-alias predicate proofs.
+ * @evidence contracts/common.md#clear-and-simple-design A single loop delegates state hashing and identity rules to their existing owners, returning only the external snapshot dictionary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations contribute an explicit state marker instead of disappearing into a partial snapshot that falsely matches an earlier generation.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain actual equivalence, first read spelling, unavailable-content state transitions and the public physical-dictionary boundary without inventing a current consumer.
+ * @evidence contracts/portability.md#os-neutral-implementation One context derived from the supplied native view applies actual directory case and link rules; case-sensitive spelling differences remain distinct and original addresses reach reads instead of globally lowercasing Windows paths.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The function transfers a snapshot dictionary to its caller and owns no persistent state, native handle or running task.
+ * @evidence contracts/performance.md#efficient-algorithms One pass over all supplied paths resolves native identities before deduplication. Path/component/uncached ancestor and case observations, total unique readable bytes and failed-read kind probes drive work; result keys grow with unique identities while the call-local context also retains queried aliases and ancestors.
+ * @evidence contracts/performance.md#reuse-equivalent-work Equivalent native spellings share the same observation within this call; the context shares identity lookups, while fresh calls reobserve input state rather than persisting unvalidated content hashes.
+ */
+export declare function collectExternalInputHashes(
+/** Native spellings whose first observation per physical identity is retained. */
+paths: readonly string[], 
+/** Stable coherent native identity, read and kind view for this call. */
+filesystem?: TtscTransformFilesystemOperations): Record<string, string>;

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

@@ -0,0 +1,27 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * Hash a list of absolute out-of-walk input paths: content SHA-256 for a
+ * readable file, a stable directory-kind digest for a directory candidate, and
+ * a stable `missing` marker otherwise. Keys use filesystem identity so
+ * equivalent spellings share one entry under the observed case/link policy,
+ * while the first observation retains the original path supplied by the
+ * compiler. The marker is state, not an error — a recorded input disappearing
+ * (or reappearing) must change the comparison exactly like a content edit.
+ * Unavailable content does not prove physical absence. The public core export
+ * supplies a physical-state dictionary; it does not preserve independent
+ * lexical predicates for every alias.
+ *
+ * @evidence contracts/common.md#principled-implementation One native identity context deduplicates addresses for this physical-state dictionary; the first spelling's read determines its value under a stable coherent view. Raw file bytes, observed directory kind and unavailable content remain distinct states, not per-alias predicate proofs.
+ * @evidence contracts/common.md#clear-and-simple-design A single loop delegates state hashing and identity rules to their existing owners, returning only the external snapshot dictionary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations contribute an explicit state marker instead of disappearing into a partial snapshot that falsely matches an earlier generation.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain actual equivalence, first read spelling, unavailable-content state transitions and the public physical-dictionary boundary without inventing a current consumer.
+ * @evidence contracts/portability.md#os-neutral-implementation One context derived from the supplied native view applies actual directory case and link rules; case-sensitive spelling differences remain distinct and original addresses reach reads instead of globally lowercasing Windows paths.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The function transfers a snapshot dictionary to its caller and owns no persistent state, native handle or running task.
+ * @evidence contracts/performance.md#efficient-algorithms One pass over all supplied paths resolves native identities before deduplication. Path/component/uncached ancestor and case observations, total unique readable bytes and failed-read kind probes drive work; result keys grow with unique identities while the call-local context also retains queried aliases and ancestors.
+ * @evidence contracts/performance.md#reuse-equivalent-work Equivalent native spellings share the same observation within this call; the context shares identity lookups, while fresh calls reobserve input state rather than persisting unvalidated content hashes.
+ */
+export declare function collectExternalInputHashes(
+/** Native spellings whose first observation per physical identity is retained. */
+paths: readonly string[], 
+/** Stable coherent native identity, read and kind view for this call. */
+filesystem?: TtscTransformFilesystemOperations): Record<string, string>;

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

@@ -0,0 +1,27 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * Hash a list of absolute out-of-walk input paths: content SHA-256 for a
+ * readable file, a stable directory-kind digest for a directory candidate, and
+ * a stable `missing` marker otherwise. Keys use filesystem identity so
+ * equivalent spellings share one entry under the observed case/link policy,
+ * while the first observation retains the original path supplied by the
+ * compiler. The marker is state, not an error — a recorded input disappearing
+ * (or reappearing) must change the comparison exactly like a content edit.
+ * Unavailable content does not prove physical absence. The public core export
+ * supplies a physical-state dictionary; it does not preserve independent
+ * lexical predicates for every alias.
+ *
+ * @evidence contracts/common.md#principled-implementation One native identity context deduplicates addresses for this physical-state dictionary; the first spelling's read determines its value under a stable coherent view. Raw file bytes, observed directory kind and unavailable content remain distinct states, not per-alias predicate proofs.
+ * @evidence contracts/common.md#clear-and-simple-design A single loop delegates state hashing and identity rules to their existing owners, returning only the external snapshot dictionary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations contribute an explicit state marker instead of disappearing into a partial snapshot that falsely matches an earlier generation.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain actual equivalence, first read spelling, unavailable-content state transitions and the public physical-dictionary boundary without inventing a current consumer.
+ * @evidence contracts/portability.md#os-neutral-implementation One context derived from the supplied native view applies actual directory case and link rules; case-sensitive spelling differences remain distinct and original addresses reach reads instead of globally lowercasing Windows paths.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The function transfers a snapshot dictionary to its caller and owns no persistent state, native handle or running task.
+ * @evidence contracts/performance.md#efficient-algorithms One pass over all supplied paths resolves native identities before deduplication. Path/component/uncached ancestor and case observations, total unique readable bytes and failed-read kind probes drive work; result keys grow with unique identities while the call-local context also retains queried aliases and ancestors.
+ * @evidence contracts/performance.md#reuse-equivalent-work Equivalent native spellings share the same observation within this call; the context shares identity lookups, while fresh calls reobserve input state rather than persisting unvalidated content hashes.
+ */
+export declare function collectExternalInputHashes(
+/** Native spellings whose first observation per physical identity is retained. */
+paths: readonly string[], 
+/** Stable coherent native identity, read and kind view for this call. */
+filesystem?: TtscTransformFilesystemOperations): Record<string, string>;

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

@@ -0,0 +1,49 @@
+'use strict';
+
+var DEFAULT_FILESYSTEM_OPERATIONS = require('../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.js');
+var createHostPathIdentityContext = require('../filesystem/createHostPathIdentityContext.js');
+var pathIdentityKey = require('../filesystem/pathIdentityKey.js');
+var hostInputStateHash = require('../inputs/hostInputStateHash.js');
+var MISSING_INPUT_STATE = require('../validation/MISSING_INPUT_STATE.js');
+
+/**
+ * Hash a list of absolute out-of-walk input paths: content SHA-256 for a
+ * readable file, a stable directory-kind digest for a directory candidate, and
+ * a stable `missing` marker otherwise. Keys use filesystem identity so
+ * equivalent spellings share one entry under the observed case/link policy,
+ * while the first observation retains the original path supplied by the
+ * compiler. The marker is state, not an error — a recorded input disappearing
+ * (or reappearing) must change the comparison exactly like a content edit.
+ * Unavailable content does not prove physical absence. The public core export
+ * supplies a physical-state dictionary; it does not preserve independent
+ * lexical predicates for every alias.
+ *
+ * @evidence contracts/common.md#principled-implementation One native identity context deduplicates addresses for this physical-state dictionary; the first spelling's read determines its value under a stable coherent view. Raw file bytes, observed directory kind and unavailable content remain distinct states, not per-alias predicate proofs.
+ * @evidence contracts/common.md#clear-and-simple-design A single loop delegates state hashing and identity rules to their existing owners, returning only the external snapshot dictionary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations contribute an explicit state marker instead of disappearing into a partial snapshot that falsely matches an earlier generation.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain actual equivalence, first read spelling, unavailable-content state transitions and the public physical-dictionary boundary without inventing a current consumer.
+ * @evidence contracts/portability.md#os-neutral-implementation One context derived from the supplied native view applies actual directory case and link rules; case-sensitive spelling differences remain distinct and original addresses reach reads instead of globally lowercasing Windows paths.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The function transfers a snapshot dictionary to its caller and owns no persistent state, native handle or running task.
+ * @evidence contracts/performance.md#efficient-algorithms One pass over all supplied paths resolves native identities before deduplication. Path/component/uncached ancestor and case observations, total unique readable bytes and failed-read kind probes drive work; result keys grow with unique identities while the call-local context also retains queried aliases and ancestors.
+ * @evidence contracts/performance.md#reuse-equivalent-work Equivalent native spellings share the same observation within this call; the context shares identity lookups, while fresh calls reobserve input state rather than persisting unvalidated content hashes.
+ */
+function collectExternalInputHashes(
+/** Native spellings whose first observation per physical identity is retained. */
+paths, 
+/** Stable coherent native identity, read and kind view for this call. */
+filesystem = DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS) {
+    const hashes = {};
+    const identities = createHostPathIdentityContext.createHostPathIdentityContext(filesystem);
+    for (const file of paths) {
+        const identity = pathIdentityKey.pathIdentityKey(file, identities);
+        if (identity in hashes) {
+            continue;
+        }
+        hashes[identity] =
+            hostInputStateHash.hostInputStateHash(file, filesystem) ?? MISSING_INPUT_STATE.MISSING_INPUT_STATE;
+    }
+    return hashes;
+}
+
+exports.collectExternalInputHashes = collectExternalInputHashes;
+//# sourceMappingURL=collectExternalInputHashes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectExternalInputHashes.js","sources":["../../../../src/core/transform/project/collectExternalInputHashes.ts"],"sourcesContent":[null],"names":["DEFAULT_FILESYSTEM_OPERATIONS","createHostPathIdentityContext","pathIdentityKey","hostInputStateHash","MISSING_INPUT_STATE"],"mappings":";;;;;;;;AAOA;;;;;;;;;;;;;;;;;;;;AAoBG;SACa,0BAA0B;AACxC;AACA,KAAwB;AACxB;AACA,UAAA,GAAgDA,2DAA6B,EAAA;IAE7E,MAAM,MAAM,GAA2B,EAAE;AACzC,IAAA,MAAM,UAAU,GAAGC,2DAA6B,CAAC,UAAU,CAAC;AAC5D,IAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;QACxB,MAAM,QAAQ,GAAGC,+BAAe,CAAC,IAAI,EAAE,UAAU,CAAC;AAClD,QAAA,IAAI,QAAQ,IAAI,MAAM,EAAE;YACtB;QACF;QACA,MAAM,CAAC,QAAQ,CAAC;AACd,YAAAC,qCAAkB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAIC,uCAAmB;IAC/D;AACA,IAAA,OAAO,MAAM;AACf;;;;"}

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

@@ -0,0 +1,47 @@
+import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+import { createHostPathIdentityContext } from '../filesystem/createHostPathIdentityContext.mjs';
+import { pathIdentityKey } from '../filesystem/pathIdentityKey.mjs';
+import { hostInputStateHash } from '../inputs/hostInputStateHash.mjs';
+import { MISSING_INPUT_STATE } from '../validation/MISSING_INPUT_STATE.mjs';
+
+/**
+ * Hash a list of absolute out-of-walk input paths: content SHA-256 for a
+ * readable file, a stable directory-kind digest for a directory candidate, and
+ * a stable `missing` marker otherwise. Keys use filesystem identity so
+ * equivalent spellings share one entry under the observed case/link policy,
+ * while the first observation retains the original path supplied by the
+ * compiler. The marker is state, not an error — a recorded input disappearing
+ * (or reappearing) must change the comparison exactly like a content edit.
+ * Unavailable content does not prove physical absence. The public core export
+ * supplies a physical-state dictionary; it does not preserve independent
+ * lexical predicates for every alias.
+ *
+ * @evidence contracts/common.md#principled-implementation One native identity context deduplicates addresses for this physical-state dictionary; the first spelling's read determines its value under a stable coherent view. Raw file bytes, observed directory kind and unavailable content remain distinct states, not per-alias predicate proofs.
+ * @evidence contracts/common.md#clear-and-simple-design A single loop delegates state hashing and identity rules to their existing owners, returning only the external snapshot dictionary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations contribute an explicit state marker instead of disappearing into a partial snapshot that falsely matches an earlier generation.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain actual equivalence, first read spelling, unavailable-content state transitions and the public physical-dictionary boundary without inventing a current consumer.
+ * @evidence contracts/portability.md#os-neutral-implementation One context derived from the supplied native view applies actual directory case and link rules; case-sensitive spelling differences remain distinct and original addresses reach reads instead of globally lowercasing Windows paths.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The function transfers a snapshot dictionary to its caller and owns no persistent state, native handle or running task.
+ * @evidence contracts/performance.md#efficient-algorithms One pass over all supplied paths resolves native identities before deduplication. Path/component/uncached ancestor and case observations, total unique readable bytes and failed-read kind probes drive work; result keys grow with unique identities while the call-local context also retains queried aliases and ancestors.
+ * @evidence contracts/performance.md#reuse-equivalent-work Equivalent native spellings share the same observation within this call; the context shares identity lookups, while fresh calls reobserve input state rather than persisting unvalidated content hashes.
+ */
+function collectExternalInputHashes(
+/** Native spellings whose first observation per physical identity is retained. */
+paths, 
+/** Stable coherent native identity, read and kind view for this call. */
+filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+    const hashes = {};
+    const identities = createHostPathIdentityContext(filesystem);
+    for (const file of paths) {
+        const identity = pathIdentityKey(file, identities);
+        if (identity in hashes) {
+            continue;
+        }
+        hashes[identity] =
+            hostInputStateHash(file, filesystem) ?? MISSING_INPUT_STATE;
+    }
+    return hashes;
+}
+
+export { collectExternalInputHashes };
+//# sourceMappingURL=collectExternalInputHashes.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectExternalInputHashes.mjs","sources":["../../../../src/core/transform/project/collectExternalInputHashes.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAOA;;;;;;;;;;;;;;;;;;;;AAoBG;SACa,0BAA0B;AACxC;AACA,KAAwB;AACxB;AACA,UAAA,GAAgD,6BAA6B,EAAA;IAE7E,MAAM,MAAM,GAA2B,EAAE;AACzC,IAAA,MAAM,UAAU,GAAG,6BAA6B,CAAC,UAAU,CAAC;AAC5D,IAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;QACxB,MAAM,QAAQ,GAAG,eAAe,CAAC,IAAI,EAAE,UAAU,CAAC;AAClD,QAAA,IAAI,QAAQ,IAAI,MAAM,EAAE;YACtB;QACF;QACA,MAAM,CAAC,QAAQ,CAAC;AACd,YAAA,kBAAkB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,mBAAmB;IAC/D;AACA,IAAA,OAAO,MAAM;AACf;;;;"}

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

@@ -0,0 +1,29 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.cjs";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+import type { TtscProjectInputHashSnapshot } from "./TtscProjectInputHashSnapshot.cjs";
+/**
+ * Hash admitted regular files and retain whether every attempted directory and
+ * selected file was observed coherently. Cache-key hosts must reject an
+ * incomplete set; this walk does not replace separate out-of-walk input proof.
+ *
+ * @evidence contracts/common.md#principled-implementation File-read and directory-enumeration completeness are jointly required before the hashes represent a reusable snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design The wrapper projects the detailed snapshot into the hash-plus-completeness shape needed by cache-key consumers rather than implementing another walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A readable subset cannot count as a complete program when enumeration or attribution failed.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explicitly requires cache-key hosts to reject incomplete observations, distinguishing this API from the hash-only convenience wrapper.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The selected root, membership policy, observing operations and native
+ *   identity context pass unchanged to the snapshot producer. Omitted context
+ *   uses host defaults; projection does not invent case/alias/backend policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Projection is fixed work after the required walk: directory enumeration,
+ *   admitted file reads/hashes and native identity/metadata observations scale
+ *   with selected entries, path text and content bytes. The producer's full
+ *   snapshot/witness storage is allocated even though this API returns two
+ *   fields; delegation does not make that computation constant.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function collectProjectInputHashSnapshot(projectRoot: string, identities?: FilesystemPathIdentityContext, filesystem?: TtscTransformFilesystemOperations, policy?: ITtscProjectMembershipPolicy): TtscProjectInputHashSnapshot;

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

@@ -0,0 +1,29 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.mjs";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+import type { TtscProjectInputHashSnapshot } from "./TtscProjectInputHashSnapshot.mjs";
+/**
+ * Hash admitted regular files and retain whether every attempted directory and
+ * selected file was observed coherently. Cache-key hosts must reject an
+ * incomplete set; this walk does not replace separate out-of-walk input proof.
+ *
+ * @evidence contracts/common.md#principled-implementation File-read and directory-enumeration completeness are jointly required before the hashes represent a reusable snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design The wrapper projects the detailed snapshot into the hash-plus-completeness shape needed by cache-key consumers rather than implementing another walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A readable subset cannot count as a complete program when enumeration or attribution failed.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explicitly requires cache-key hosts to reject incomplete observations, distinguishing this API from the hash-only convenience wrapper.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The selected root, membership policy, observing operations and native
+ *   identity context pass unchanged to the snapshot producer. Omitted context
+ *   uses host defaults; projection does not invent case/alias/backend policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Projection is fixed work after the required walk: directory enumeration,
+ *   admitted file reads/hashes and native identity/metadata observations scale
+ *   with selected entries, path text and content bytes. The producer's full
+ *   snapshot/witness storage is allocated even though this API returns two
+ *   fields; delegation does not make that computation constant.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function collectProjectInputHashSnapshot(projectRoot: string, identities?: FilesystemPathIdentityContext, filesystem?: TtscTransformFilesystemOperations, policy?: ITtscProjectMembershipPolicy): TtscProjectInputHashSnapshot;

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

@@ -0,0 +1,29 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+import type { TtscProjectInputHashSnapshot } from "./TtscProjectInputHashSnapshot";
+/**
+ * Hash admitted regular files and retain whether every attempted directory and
+ * selected file was observed coherently. Cache-key hosts must reject an
+ * incomplete set; this walk does not replace separate out-of-walk input proof.
+ *
+ * @evidence contracts/common.md#principled-implementation File-read and directory-enumeration completeness are jointly required before the hashes represent a reusable snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design The wrapper projects the detailed snapshot into the hash-plus-completeness shape needed by cache-key consumers rather than implementing another walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A readable subset cannot count as a complete program when enumeration or attribution failed.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explicitly requires cache-key hosts to reject incomplete observations, distinguishing this API from the hash-only convenience wrapper.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The selected root, membership policy, observing operations and native
+ *   identity context pass unchanged to the snapshot producer. Omitted context
+ *   uses host defaults; projection does not invent case/alias/backend policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Projection is fixed work after the required walk: directory enumeration,
+ *   admitted file reads/hashes and native identity/metadata observations scale
+ *   with selected entries, path text and content bytes. The producer's full
+ *   snapshot/witness storage is allocated even though this API returns two
+ *   fields; delegation does not make that computation constant.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function collectProjectInputHashSnapshot(projectRoot: string, identities?: FilesystemPathIdentityContext, filesystem?: TtscTransformFilesystemOperations, policy?: ITtscProjectMembershipPolicy): TtscProjectInputHashSnapshot;

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

@@ -0,0 +1,42 @@
+'use strict';
+
+var DEFAULT_FILESYSTEM_OPERATIONS = require('../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.js');
+var createHostPathIdentityContext = require('../filesystem/createHostPathIdentityContext.js');
+var collectProjectInputSnapshot = require('./collectProjectInputSnapshot.js');
+
+/**
+ * Hash admitted regular files and retain whether every attempted directory and
+ * selected file was observed coherently. Cache-key hosts must reject an
+ * incomplete set; this walk does not replace separate out-of-walk input proof.
+ *
+ * @evidence contracts/common.md#principled-implementation File-read and directory-enumeration completeness are jointly required before the hashes represent a reusable snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design The wrapper projects the detailed snapshot into the hash-plus-completeness shape needed by cache-key consumers rather than implementing another walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A readable subset cannot count as a complete program when enumeration or attribution failed.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explicitly requires cache-key hosts to reject incomplete observations, distinguishing this API from the hash-only convenience wrapper.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The selected root, membership policy, observing operations and native
+ *   identity context pass unchanged to the snapshot producer. Omitted context
+ *   uses host defaults; projection does not invent case/alias/backend policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Projection is fixed work after the required walk: directory enumeration,
+ *   admitted file reads/hashes and native identity/metadata observations scale
+ *   with selected entries, path text and content bytes. The producer's full
+ *   snapshot/witness storage is allocated even though this API returns two
+ *   fields; delegation does not make that computation constant.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function collectProjectInputHashSnapshot(projectRoot, identities = createHostPathIdentityContext.createHostPathIdentityContext(), filesystem = DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS, policy) {
+    const snapshot = collectProjectInputSnapshot.collectProjectInputSnapshot(projectRoot, identities, filesystem, undefined, {
+        policy,
+    });
+    return {
+        complete: snapshot.complete && snapshot.directoryComplete,
+        hashes: snapshot.hashes,
+    };
+}
+
+exports.collectProjectInputHashSnapshot = collectProjectInputHashSnapshot;
+//# sourceMappingURL=collectProjectInputHashSnapshot.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectProjectInputHashSnapshot.js","sources":["../../../../src/core/transform/project/collectProjectInputHashSnapshot.ts"],"sourcesContent":[null],"names":["createHostPathIdentityContext","DEFAULT_FILESYSTEM_OPERATIONS","collectProjectInputSnapshot"],"mappings":";;;;;;AASA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG,SAAU,+BAA+B,CAC7C,WAAmB,EACnB,UAAA,GAA4CA,2DAA6B,EAAE,EAC3E,UAAA,GAAgDC,2DAA6B,EAC7E,MAAqC,EAAA;IAErC,MAAM,QAAQ,GAAGC,uDAA2B,CAC1C,WAAW,EACX,UAAU,EACV,UAAU,EACV,SAAS,EACT;QACE,MAAM;AACP,KAAA,CACF;IACD,OAAO;AACL,QAAA,QAAQ,EAAE,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,iBAAiB;QACzD,MAAM,EAAE,QAAQ,CAAC,MAAM;KACxB;AACH;;;;"}

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

@@ -0,0 +1,40 @@
+import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+import { createHostPathIdentityContext } from '../filesystem/createHostPathIdentityContext.mjs';
+import { collectProjectInputSnapshot } from './collectProjectInputSnapshot.mjs';
+
+/**
+ * Hash admitted regular files and retain whether every attempted directory and
+ * selected file was observed coherently. Cache-key hosts must reject an
+ * incomplete set; this walk does not replace separate out-of-walk input proof.
+ *
+ * @evidence contracts/common.md#principled-implementation File-read and directory-enumeration completeness are jointly required before the hashes represent a reusable snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design The wrapper projects the detailed snapshot into the hash-plus-completeness shape needed by cache-key consumers rather than implementing another walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A readable subset cannot count as a complete program when enumeration or attribution failed.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explicitly requires cache-key hosts to reject incomplete observations, distinguishing this API from the hash-only convenience wrapper.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The selected root, membership policy, observing operations and native
+ *   identity context pass unchanged to the snapshot producer. Omitted context
+ *   uses host defaults; projection does not invent case/alias/backend policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Projection is fixed work after the required walk: directory enumeration,
+ *   admitted file reads/hashes and native identity/metadata observations scale
+ *   with selected entries, path text and content bytes. The producer's full
+ *   snapshot/witness storage is allocated even though this API returns two
+ *   fields; delegation does not make that computation constant.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function collectProjectInputHashSnapshot(projectRoot, identities = createHostPathIdentityContext(), filesystem = DEFAULT_FILESYSTEM_OPERATIONS, policy) {
+    const snapshot = collectProjectInputSnapshot(projectRoot, identities, filesystem, undefined, {
+        policy,
+    });
+    return {
+        complete: snapshot.complete && snapshot.directoryComplete,
+        hashes: snapshot.hashes,
+    };
+}
+
+export { collectProjectInputHashSnapshot };
+//# sourceMappingURL=collectProjectInputHashSnapshot.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectProjectInputHashSnapshot.mjs","sources":["../../../../src/core/transform/project/collectProjectInputHashSnapshot.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG,SAAU,+BAA+B,CAC7C,WAAmB,EACnB,UAAA,GAA4C,6BAA6B,EAAE,EAC3E,UAAA,GAAgD,6BAA6B,EAC7E,MAAqC,EAAA;IAErC,MAAM,QAAQ,GAAG,2BAA2B,CAC1C,WAAW,EACX,UAAU,EACV,UAAU,EACV,SAAS,EACT;QACE,MAAM;AACP,KAAA,CACF;IACD,OAAO;AACL,QAAA,QAAQ,EAAE,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,iBAAiB;QACzD,MAAM,EAAE,QAAQ,CAAC,MAAM;KACxB;AACH;;;;"}