@ttsc/unplugin 0.30.4 → 0.31.0

package/lib/core/transform/watch/TtscWatchSelection.d.mts

@@ -0,0 +1,35 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * What a delivery's watch notifications need from the project selection that
+ * routed its file: reported config reads and failed discovery candidates,
+ * handed to the host beside every notification's own inputs
+ * (`selectionInputs`), the filesystem their evidence is read through, and the
+ * selected tsconfig, which spells the project for a notification that has no
+ * generation to spell it.
+ *
+ * @evidence contracts/common.md#principled-implementation The consulted configs preserve routing dependencies independently of the selected project, and the filesystem records which native view supplies their facts.
+ * @evidence contracts/common.md#clear-and-simple-design A readonly delivery context groups routing inputs and their observation capability without copying project-generation state.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The full consulted sequence is represented instead of assuming the selected tsconfig alone explains project routing.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains each field's notification role; spaced member comments and separated tags follow documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation The supplied filesystem owns native observation and the selected config retains adapter spelling, avoiding an implicit global filesystem or case-policy premise.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscWatchSelection only declares a shape; it has no computation at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscWatchSelection only declares a shape; it has no work to reuse at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscWatchSelection only declares a shape; it has no handle or retained
+ *   state at runtime.
+ */
+export interface TtscWatchSelection {
+    /**
+     * Ordered reported routing spellings, including failed discovery predicates;
+     * a listed candidate need not have had readable config contents.
+     */
+    readonly consulted: readonly string[];
+    /** The filesystem the delivery reads through. */
+    readonly filesystem: TtscTransformFilesystemOperations;
+    /** The selected project's tsconfig, as the adapter names it. */
+    readonly tsconfig: string;
+}

package/lib/core/transform/watch/TtscWatchSelection.d.ts

@@ -0,0 +1,35 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * What a delivery's watch notifications need from the project selection that
+ * routed its file: reported config reads and failed discovery candidates,
+ * handed to the host beside every notification's own inputs
+ * (`selectionInputs`), the filesystem their evidence is read through, and the
+ * selected tsconfig, which spells the project for a notification that has no
+ * generation to spell it.
+ *
+ * @evidence contracts/common.md#principled-implementation The consulted configs preserve routing dependencies independently of the selected project, and the filesystem records which native view supplies their facts.
+ * @evidence contracts/common.md#clear-and-simple-design A readonly delivery context groups routing inputs and their observation capability without copying project-generation state.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The full consulted sequence is represented instead of assuming the selected tsconfig alone explains project routing.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains each field's notification role; spaced member comments and separated tags follow documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation The supplied filesystem owns native observation and the selected config retains adapter spelling, avoiding an implicit global filesystem or case-policy premise.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscWatchSelection only declares a shape; it has no computation at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscWatchSelection only declares a shape; it has no work to reuse at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscWatchSelection only declares a shape; it has no handle or retained
+ *   state at runtime.
+ */
+export interface TtscWatchSelection {
+    /**
+     * Ordered reported routing spellings, including failed discovery predicates;
+     * a listed candidate need not have had readable config contents.
+     */
+    readonly consulted: readonly string[];
+    /** The filesystem the delivery reads through. */
+    readonly filesystem: TtscTransformFilesystemOperations;
+    /** The selected project's tsconfig, as the adapter names it. */
+    readonly tsconfig: string;
+}

package/lib/core/transform/watch/captureWatchInputBaseline.d.cts

@@ -0,0 +1,28 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+import type { TtscWatchInputBaseline } from "./TtscWatchInputBaseline.cjs";
+/**
+ * Capture a main-process baseline comparable with generation-owned evidence.
+ * Two equal broad observations are required; an observed mismatch or exception
+ * declines the capture. Equality does not establish an atomic snapshot or rule
+ * out a transient change between reads.
+ *
+ * @param options.tree Whether the path was recorded as a plugin source
+ *   directory, whose state the baseline then carries (samchon/ttsc#1487).
+ * @param options.accessibleEntries Whether compiler listing names are needed by
+ *   a recorded predicate. Unrequested listings are not enumerated.
+ * @param options.nativePredicates Native version-one codec kinds requested by
+ *   recorded inputs. Raw native listings are independent of compiler listings.
+ * @evidence contracts/common.md#principled-implementation Two independently captured codec facts must agree before a baseline is returned; equality detects observed changes but cannot establish absence of intervening unobserved changes.
+ * @evidence contracts/common.md#clear-and-simple-design The singleton delegates to the batch owner, which assembles codec facts and owns independent observations and failure handling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unavailable reads retain their explicit codec markers and predicates; a mismatch or escaping exception declines capture without supplying expected state or retrying until a desired answer appears.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain capture rejection, equality limitations and optional subtree cost, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Stat, hash and identity use supplied native operations. Plugin-tree capture uses the shared native build-state owner, so an injected view must describe that same source tree.
+ * @evidence contracts/performance.md#efficient-algorithms Two fixed broad captures each read B bytes once for both codecs; native identity and metadata retain their path-resolution costs. Optional plugin-tree observation scans its selected population and bytes, and listings sort E UTF-8 names with encoding and prefix-comparison costs. Unrequested trees and listings are not scanned, and fresh identity contexts avoid reusing the first capture's metadata.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Independent current observations are the purpose of capture; the caller owns subsequent baseline reuse and its validity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Hash buffers and identity contexts are call-local; this capture retains no cache, native handle or task.
+ */
+export declare function captureWatchInputBaseline(file: string, filesystem?: TtscTransformFilesystemOperations, options?: {
+    tree?: boolean;
+    accessibleEntries?: boolean;
+    nativePredicates?: readonly (keyof NonNullable<TtscWatchInputBaseline["nativePredicates"]>)[];
+}): TtscWatchInputBaseline | undefined;

package/lib/core/transform/watch/captureWatchInputBaseline.d.mts

@@ -0,0 +1,28 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+import type { TtscWatchInputBaseline } from "./TtscWatchInputBaseline.mjs";
+/**
+ * Capture a main-process baseline comparable with generation-owned evidence.
+ * Two equal broad observations are required; an observed mismatch or exception
+ * declines the capture. Equality does not establish an atomic snapshot or rule
+ * out a transient change between reads.
+ *
+ * @param options.tree Whether the path was recorded as a plugin source
+ *   directory, whose state the baseline then carries (samchon/ttsc#1487).
+ * @param options.accessibleEntries Whether compiler listing names are needed by
+ *   a recorded predicate. Unrequested listings are not enumerated.
+ * @param options.nativePredicates Native version-one codec kinds requested by
+ *   recorded inputs. Raw native listings are independent of compiler listings.
+ * @evidence contracts/common.md#principled-implementation Two independently captured codec facts must agree before a baseline is returned; equality detects observed changes but cannot establish absence of intervening unobserved changes.
+ * @evidence contracts/common.md#clear-and-simple-design The singleton delegates to the batch owner, which assembles codec facts and owns independent observations and failure handling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unavailable reads retain their explicit codec markers and predicates; a mismatch or escaping exception declines capture without supplying expected state or retrying until a desired answer appears.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain capture rejection, equality limitations and optional subtree cost, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Stat, hash and identity use supplied native operations. Plugin-tree capture uses the shared native build-state owner, so an injected view must describe that same source tree.
+ * @evidence contracts/performance.md#efficient-algorithms Two fixed broad captures each read B bytes once for both codecs; native identity and metadata retain their path-resolution costs. Optional plugin-tree observation scans its selected population and bytes, and listings sort E UTF-8 names with encoding and prefix-comparison costs. Unrequested trees and listings are not scanned, and fresh identity contexts avoid reusing the first capture's metadata.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Independent current observations are the purpose of capture; the caller owns subsequent baseline reuse and its validity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Hash buffers and identity contexts are call-local; this capture retains no cache, native handle or task.
+ */
+export declare function captureWatchInputBaseline(file: string, filesystem?: TtscTransformFilesystemOperations, options?: {
+    tree?: boolean;
+    accessibleEntries?: boolean;
+    nativePredicates?: readonly (keyof NonNullable<TtscWatchInputBaseline["nativePredicates"]>)[];
+}): TtscWatchInputBaseline | undefined;

package/lib/core/transform/watch/captureWatchInputBaseline.d.ts

@@ -0,0 +1,28 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+import type { TtscWatchInputBaseline } from "./TtscWatchInputBaseline";
+/**
+ * Capture a main-process baseline comparable with generation-owned evidence.
+ * Two equal broad observations are required; an observed mismatch or exception
+ * declines the capture. Equality does not establish an atomic snapshot or rule
+ * out a transient change between reads.
+ *
+ * @param options.tree Whether the path was recorded as a plugin source
+ *   directory, whose state the baseline then carries (samchon/ttsc#1487).
+ * @param options.accessibleEntries Whether compiler listing names are needed by
+ *   a recorded predicate. Unrequested listings are not enumerated.
+ * @param options.nativePredicates Native version-one codec kinds requested by
+ *   recorded inputs. Raw native listings are independent of compiler listings.
+ * @evidence contracts/common.md#principled-implementation Two independently captured codec facts must agree before a baseline is returned; equality detects observed changes but cannot establish absence of intervening unobserved changes.
+ * @evidence contracts/common.md#clear-and-simple-design The singleton delegates to the batch owner, which assembles codec facts and owns independent observations and failure handling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unavailable reads retain their explicit codec markers and predicates; a mismatch or escaping exception declines capture without supplying expected state or retrying until a desired answer appears.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain capture rejection, equality limitations and optional subtree cost, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Stat, hash and identity use supplied native operations. Plugin-tree capture uses the shared native build-state owner, so an injected view must describe that same source tree.
+ * @evidence contracts/performance.md#efficient-algorithms Two fixed broad captures each read B bytes once for both codecs; native identity and metadata retain their path-resolution costs. Optional plugin-tree observation scans its selected population and bytes, and listings sort E UTF-8 names with encoding and prefix-comparison costs. Unrequested trees and listings are not scanned, and fresh identity contexts avoid reusing the first capture's metadata.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Independent current observations are the purpose of capture; the caller owns subsequent baseline reuse and its validity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Hash buffers and identity contexts are call-local; this capture retains no cache, native handle or task.
+ */
+export declare function captureWatchInputBaseline(file: string, filesystem?: TtscTransformFilesystemOperations, options?: {
+    tree?: boolean;
+    accessibleEntries?: boolean;
+    nativePredicates?: readonly (keyof NonNullable<TtscWatchInputBaseline["nativePredicates"]>)[];
+}): TtscWatchInputBaseline | undefined;

package/lib/core/transform/watch/captureWatchInputBaseline.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var DEFAULT_FILESYSTEM_OPERATIONS = require('../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.js');
+var captureWatchInputBaselines = require('./captureWatchInputBaselines.js');
+
+/**
+ * Capture a main-process baseline comparable with generation-owned evidence.
+ * Two equal broad observations are required; an observed mismatch or exception
+ * declines the capture. Equality does not establish an atomic snapshot or rule
+ * out a transient change between reads.
+ *
+ * @param options.tree Whether the path was recorded as a plugin source
+ *   directory, whose state the baseline then carries (samchon/ttsc#1487).
+ * @param options.accessibleEntries Whether compiler listing names are needed by
+ *   a recorded predicate. Unrequested listings are not enumerated.
+ * @param options.nativePredicates Native version-one codec kinds requested by
+ *   recorded inputs. Raw native listings are independent of compiler listings.
+ * @evidence contracts/common.md#principled-implementation Two independently captured codec facts must agree before a baseline is returned; equality detects observed changes but cannot establish absence of intervening unobserved changes.
+ * @evidence contracts/common.md#clear-and-simple-design The singleton delegates to the batch owner, which assembles codec facts and owns independent observations and failure handling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unavailable reads retain their explicit codec markers and predicates; a mismatch or escaping exception declines capture without supplying expected state or retrying until a desired answer appears.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain capture rejection, equality limitations and optional subtree cost, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Stat, hash and identity use supplied native operations. Plugin-tree capture uses the shared native build-state owner, so an injected view must describe that same source tree.
+ * @evidence contracts/performance.md#efficient-algorithms Two fixed broad captures each read B bytes once for both codecs; native identity and metadata retain their path-resolution costs. Optional plugin-tree observation scans its selected population and bytes, and listings sort E UTF-8 names with encoding and prefix-comparison costs. Unrequested trees and listings are not scanned, and fresh identity contexts avoid reusing the first capture's metadata.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Independent current observations are the purpose of capture; the caller owns subsequent baseline reuse and its validity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Hash buffers and identity contexts are call-local; this capture retains no cache, native handle or task.
+ */
+function captureWatchInputBaseline(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS, options = {}) {
+    return captureWatchInputBaselines.captureWatchInputBaselines([file], filesystem, options).get(file);
+}
+
+exports.captureWatchInputBaseline = captureWatchInputBaseline;
+//# sourceMappingURL=captureWatchInputBaseline.js.map

package/lib/core/transform/watch/captureWatchInputBaseline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"captureWatchInputBaseline.js","sources":["../../../../src/core/transform/watch/captureWatchInputBaseline.ts"],"sourcesContent":[null],"names":["DEFAULT_FILESYSTEM_OPERATIONS","captureWatchInputBaselines"],"mappings":";;;;;AAKA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,yBAAyB,CACvC,IAAY,EACZ,UAAA,GAAgDA,2DAA6B,EAC7E,OAAA,GAMI,EAAE,EAAA;AAEN,IAAA,OAAOC,qDAA0B,CAAC,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;AAC1E;;;;"}

package/lib/core/transform/watch/captureWatchInputBaseline.mjs

@@ -0,0 +1,30 @@
+import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+import { captureWatchInputBaselines } from './captureWatchInputBaselines.mjs';
+
+/**
+ * Capture a main-process baseline comparable with generation-owned evidence.
+ * Two equal broad observations are required; an observed mismatch or exception
+ * declines the capture. Equality does not establish an atomic snapshot or rule
+ * out a transient change between reads.
+ *
+ * @param options.tree Whether the path was recorded as a plugin source
+ *   directory, whose state the baseline then carries (samchon/ttsc#1487).
+ * @param options.accessibleEntries Whether compiler listing names are needed by
+ *   a recorded predicate. Unrequested listings are not enumerated.
+ * @param options.nativePredicates Native version-one codec kinds requested by
+ *   recorded inputs. Raw native listings are independent of compiler listings.
+ * @evidence contracts/common.md#principled-implementation Two independently captured codec facts must agree before a baseline is returned; equality detects observed changes but cannot establish absence of intervening unobserved changes.
+ * @evidence contracts/common.md#clear-and-simple-design The singleton delegates to the batch owner, which assembles codec facts and owns independent observations and failure handling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unavailable reads retain their explicit codec markers and predicates; a mismatch or escaping exception declines capture without supplying expected state or retrying until a desired answer appears.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain capture rejection, equality limitations and optional subtree cost, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Stat, hash and identity use supplied native operations. Plugin-tree capture uses the shared native build-state owner, so an injected view must describe that same source tree.
+ * @evidence contracts/performance.md#efficient-algorithms Two fixed broad captures each read B bytes once for both codecs; native identity and metadata retain their path-resolution costs. Optional plugin-tree observation scans its selected population and bytes, and listings sort E UTF-8 names with encoding and prefix-comparison costs. Unrequested trees and listings are not scanned, and fresh identity contexts avoid reusing the first capture's metadata.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Independent current observations are the purpose of capture; the caller owns subsequent baseline reuse and its validity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Hash buffers and identity contexts are call-local; this capture retains no cache, native handle or task.
+ */
+function captureWatchInputBaseline(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, options = {}) {
+    return captureWatchInputBaselines([file], filesystem, options).get(file);
+}
+
+export { captureWatchInputBaseline };
+//# sourceMappingURL=captureWatchInputBaseline.mjs.map

package/lib/core/transform/watch/captureWatchInputBaseline.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"captureWatchInputBaseline.mjs","sources":["../../../../src/core/transform/watch/captureWatchInputBaseline.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,yBAAyB,CACvC,IAAY,EACZ,UAAA,GAAgD,6BAA6B,EAC7E,OAAA,GAMI,EAAE,EAAA;AAEN,IAAA,OAAO,0BAA0B,CAAC,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;AAC1E;;;;"}

package/lib/core/transform/watch/captureWatchInputBaselines.d.cts

@@ -0,0 +1,31 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+import type { TtscWatchInputBaseline } from "./TtscWatchInputBaseline.cjs";
+/**
+ * Capture a batch through two independently fresh native observation phases. A
+ * phase shares path/case observations only within this synchronous batch; the
+ * second phase has a new identity context and rereads every input. Nothing
+ * survives this call. Changed captures or escaping exceptions decline that
+ * input alone. Matching endpoints still cannot certify an atomic snapshot or
+ * exclude ABA.
+ *
+ * One current byte read supplies raw-host and compiler-text hashes in each
+ * phase. Failed reads retain native kind fallbacks; optional tree and listing
+ * observations keep their original owners and are captured in both phases.
+ * Requested native codecs share that phase's raw byte read and separately
+ * observe their own entry/listing/physical-target facts. Unsupported or failed
+ * native observations decline that path; equality still cannot exclude ABA.
+ *
+ * @evidence contracts/common.md#principled-implementation Each returned input has equal before/after facts from independent identity contexts and actual reads. Sharing directory resolution within a phase never supplies the second phase or a later batch; failed captures remain undefined independently of siblings.
+ * @evidence contracts/common.md#clear-and-simple-design Two phase maps surround one per-path fact collector, sharing the existing decoder, native predicates and optional tree/listing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No lifetime or historical identity memo enters this API. Both phases run for every selected spelling and compare complete facts, including identity and realpath; equality does not invent atomicity or exclude unobserved changes.
+ * @evidence contracts/common.md#meaningful-documentation Native prose defines phase ownership, shared byte provenance, rejection and the remaining temporal limitation.
+ * @evidence contracts/portability.md#os-neutral-implementation The coherent supplied filesystem provides native case, path, read, kind and listing capabilities. Each phase re-establishes aliases and case policy; no platform label supplies authority, and raw host bytes remain distinct from compiler-decoded text.
+ * @evidence contracts/performance.md#efficient-algorithms Two passes visit N unique spellings and read each path at most once per phase, sharing directory/case resolution within that phase. Native ancestor/path work, total bytes B, optional listing/tree populations and digest serialization remain costs; two maps retain O(N) baseline facts rather than historical generations.
+ * @evidence contracts/performance.md#reuse-equivalent-work Phase-local identity contexts reuse the same native namespace observation for related paths, and one actual byte observation supplies its two codecs. A new context and new reads are mandatory in the second phase and every later invocation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returned baselines are caller-owned; both identity contexts and phase maps are synchronous call-local values with no timer, watcher or retained cache.
+ */
+export declare function captureWatchInputBaselines(files: Iterable<string>, filesystem?: TtscTransformFilesystemOperations, options?: {
+    tree?: boolean;
+    accessibleEntries?: boolean;
+    nativePredicates?: readonly (keyof NonNullable<TtscWatchInputBaseline["nativePredicates"]>)[];
+}): Map<string, TtscWatchInputBaseline | undefined>;

package/lib/core/transform/watch/captureWatchInputBaselines.d.mts

@@ -0,0 +1,31 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+import type { TtscWatchInputBaseline } from "./TtscWatchInputBaseline.mjs";
+/**
+ * Capture a batch through two independently fresh native observation phases. A
+ * phase shares path/case observations only within this synchronous batch; the
+ * second phase has a new identity context and rereads every input. Nothing
+ * survives this call. Changed captures or escaping exceptions decline that
+ * input alone. Matching endpoints still cannot certify an atomic snapshot or
+ * exclude ABA.
+ *
+ * One current byte read supplies raw-host and compiler-text hashes in each
+ * phase. Failed reads retain native kind fallbacks; optional tree and listing
+ * observations keep their original owners and are captured in both phases.
+ * Requested native codecs share that phase's raw byte read and separately
+ * observe their own entry/listing/physical-target facts. Unsupported or failed
+ * native observations decline that path; equality still cannot exclude ABA.
+ *
+ * @evidence contracts/common.md#principled-implementation Each returned input has equal before/after facts from independent identity contexts and actual reads. Sharing directory resolution within a phase never supplies the second phase or a later batch; failed captures remain undefined independently of siblings.
+ * @evidence contracts/common.md#clear-and-simple-design Two phase maps surround one per-path fact collector, sharing the existing decoder, native predicates and optional tree/listing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No lifetime or historical identity memo enters this API. Both phases run for every selected spelling and compare complete facts, including identity and realpath; equality does not invent atomicity or exclude unobserved changes.
+ * @evidence contracts/common.md#meaningful-documentation Native prose defines phase ownership, shared byte provenance, rejection and the remaining temporal limitation.
+ * @evidence contracts/portability.md#os-neutral-implementation The coherent supplied filesystem provides native case, path, read, kind and listing capabilities. Each phase re-establishes aliases and case policy; no platform label supplies authority, and raw host bytes remain distinct from compiler-decoded text.
+ * @evidence contracts/performance.md#efficient-algorithms Two passes visit N unique spellings and read each path at most once per phase, sharing directory/case resolution within that phase. Native ancestor/path work, total bytes B, optional listing/tree populations and digest serialization remain costs; two maps retain O(N) baseline facts rather than historical generations.
+ * @evidence contracts/performance.md#reuse-equivalent-work Phase-local identity contexts reuse the same native namespace observation for related paths, and one actual byte observation supplies its two codecs. A new context and new reads are mandatory in the second phase and every later invocation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returned baselines are caller-owned; both identity contexts and phase maps are synchronous call-local values with no timer, watcher or retained cache.
+ */
+export declare function captureWatchInputBaselines(files: Iterable<string>, filesystem?: TtscTransformFilesystemOperations, options?: {
+    tree?: boolean;
+    accessibleEntries?: boolean;
+    nativePredicates?: readonly (keyof NonNullable<TtscWatchInputBaseline["nativePredicates"]>)[];
+}): Map<string, TtscWatchInputBaseline | undefined>;

package/lib/core/transform/watch/captureWatchInputBaselines.d.ts

@@ -0,0 +1,31 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+import type { TtscWatchInputBaseline } from "./TtscWatchInputBaseline";
+/**
+ * Capture a batch through two independently fresh native observation phases. A
+ * phase shares path/case observations only within this synchronous batch; the
+ * second phase has a new identity context and rereads every input. Nothing
+ * survives this call. Changed captures or escaping exceptions decline that
+ * input alone. Matching endpoints still cannot certify an atomic snapshot or
+ * exclude ABA.
+ *
+ * One current byte read supplies raw-host and compiler-text hashes in each
+ * phase. Failed reads retain native kind fallbacks; optional tree and listing
+ * observations keep their original owners and are captured in both phases.
+ * Requested native codecs share that phase's raw byte read and separately
+ * observe their own entry/listing/physical-target facts. Unsupported or failed
+ * native observations decline that path; equality still cannot exclude ABA.
+ *
+ * @evidence contracts/common.md#principled-implementation Each returned input has equal before/after facts from independent identity contexts and actual reads. Sharing directory resolution within a phase never supplies the second phase or a later batch; failed captures remain undefined independently of siblings.
+ * @evidence contracts/common.md#clear-and-simple-design Two phase maps surround one per-path fact collector, sharing the existing decoder, native predicates and optional tree/listing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No lifetime or historical identity memo enters this API. Both phases run for every selected spelling and compare complete facts, including identity and realpath; equality does not invent atomicity or exclude unobserved changes.
+ * @evidence contracts/common.md#meaningful-documentation Native prose defines phase ownership, shared byte provenance, rejection and the remaining temporal limitation.
+ * @evidence contracts/portability.md#os-neutral-implementation The coherent supplied filesystem provides native case, path, read, kind and listing capabilities. Each phase re-establishes aliases and case policy; no platform label supplies authority, and raw host bytes remain distinct from compiler-decoded text.
+ * @evidence contracts/performance.md#efficient-algorithms Two passes visit N unique spellings and read each path at most once per phase, sharing directory/case resolution within that phase. Native ancestor/path work, total bytes B, optional listing/tree populations and digest serialization remain costs; two maps retain O(N) baseline facts rather than historical generations.
+ * @evidence contracts/performance.md#reuse-equivalent-work Phase-local identity contexts reuse the same native namespace observation for related paths, and one actual byte observation supplies its two codecs. A new context and new reads are mandatory in the second phase and every later invocation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returned baselines are caller-owned; both identity contexts and phase maps are synchronous call-local values with no timer, watcher or retained cache.
+ */
+export declare function captureWatchInputBaselines(files: Iterable<string>, filesystem?: TtscTransformFilesystemOperations, options?: {
+    tree?: boolean;
+    accessibleEntries?: boolean;
+    nativePredicates?: readonly (keyof NonNullable<TtscWatchInputBaseline["nativePredicates"]>)[];
+}): Map<string, TtscWatchInputBaseline | undefined>;

package/lib/core/transform/watch/captureWatchInputBaselines.js

@@ -0,0 +1,119 @@
+'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 compilerAccessibleEntries = require('../inputs/compilerAccessibleEntries.js');
+var compilerInputRealpathObservation = require('../inputs/compilerInputRealpathObservation.js');
+var compilerInputTextHash = require('../inputs/compilerInputTextHash.js');
+var compilerStatKind = require('../inputs/compilerStatKind.js');
+var nativeInputPredicateState = require('../inputs/nativeInputPredicateState.js');
+var pluginSourceState = require('../inputs/pluginSourceState.js');
+var hashText = require('../utils/hashText.js');
+var stableStringify = require('../utils/stableStringify.js');
+var MISSING_INPUT_STATE = require('../validation/MISSING_INPUT_STATE.js');
+
+/**
+ * Capture a batch through two independently fresh native observation phases. A
+ * phase shares path/case observations only within this synchronous batch; the
+ * second phase has a new identity context and rereads every input. Nothing
+ * survives this call. Changed captures or escaping exceptions decline that
+ * input alone. Matching endpoints still cannot certify an atomic snapshot or
+ * exclude ABA.
+ *
+ * One current byte read supplies raw-host and compiler-text hashes in each
+ * phase. Failed reads retain native kind fallbacks; optional tree and listing
+ * observations keep their original owners and are captured in both phases.
+ * Requested native codecs share that phase's raw byte read and separately
+ * observe their own entry/listing/physical-target facts. Unsupported or failed
+ * native observations decline that path; equality still cannot exclude ABA.
+ *
+ * @evidence contracts/common.md#principled-implementation Each returned input has equal before/after facts from independent identity contexts and actual reads. Sharing directory resolution within a phase never supplies the second phase or a later batch; failed captures remain undefined independently of siblings.
+ * @evidence contracts/common.md#clear-and-simple-design Two phase maps surround one per-path fact collector, sharing the existing decoder, native predicates and optional tree/listing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No lifetime or historical identity memo enters this API. Both phases run for every selected spelling and compare complete facts, including identity and realpath; equality does not invent atomicity or exclude unobserved changes.
+ * @evidence contracts/common.md#meaningful-documentation Native prose defines phase ownership, shared byte provenance, rejection and the remaining temporal limitation.
+ * @evidence contracts/portability.md#os-neutral-implementation The coherent supplied filesystem provides native case, path, read, kind and listing capabilities. Each phase re-establishes aliases and case policy; no platform label supplies authority, and raw host bytes remain distinct from compiler-decoded text.
+ * @evidence contracts/performance.md#efficient-algorithms Two passes visit N unique spellings and read each path at most once per phase, sharing directory/case resolution within that phase. Native ancestor/path work, total bytes B, optional listing/tree populations and digest serialization remain costs; two maps retain O(N) baseline facts rather than historical generations.
+ * @evidence contracts/performance.md#reuse-equivalent-work Phase-local identity contexts reuse the same native namespace observation for related paths, and one actual byte observation supplies its two codecs. A new context and new reads are mandatory in the second phase and every later invocation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returned baselines are caller-owned; both identity contexts and phase maps are synchronous call-local values with no timer, watcher or retained cache.
+ */
+function captureWatchInputBaselines(files, filesystem = DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS, options = {}) {
+    const selected = [...new Set(files)];
+    const observe = () => {
+        const identities = createHostPathIdentityContext.createHostPathIdentityContext(filesystem);
+        return new Map(selected.map((file) => {
+            try {
+                return [
+                    file,
+                    capture(file, filesystem, identities, options),
+                ];
+            }
+            catch {
+                return [file, undefined];
+            }
+        }));
+    };
+    const before = observe();
+    const after = observe();
+    for (const file of selected) {
+        if (before.get(file) === undefined ||
+            stableStringify.stableStringify(before.get(file)) !== stableStringify.stableStringify(after.get(file)))
+            after.set(file, undefined);
+    }
+    return after;
+}
+/** Capture one path's codec facts from this phase's fresh namespace view. */
+function capture(file, filesystem, identities, options) {
+    const stat = compilerStatKind.compilerStatKind(file, filesystem);
+    let bytes;
+    let readError;
+    try {
+        bytes = filesystem.readFile(file);
+    }
+    catch (error) {
+        readError = error;
+        // Failed reads keep their explicit codec fallbacks.
+    }
+    const graphReadHash = stat === "directory" || bytes === undefined
+        ? null
+        : compilerInputTextHash.compilerInputTextHash(bytes);
+    const directoryHash = hashText.hashText("ttsc:host-input:directory\0");
+    const hostHash = bytes === undefined
+        ? compilerStatKind.compilerStatKind(file, filesystem) === "directory"
+            ? directoryHash
+            : MISSING_INPUT_STATE.MISSING_INPUT_STATE
+        : hashText.hashText(bytes);
+    const nativePredicates = {};
+    for (const kind of new Set(options.nativePredicates ?? [])) {
+        const observed = nativeInputPredicateState.nativeInputPredicateState(file, kind, filesystem, {
+            readFile() {
+                if (bytes === undefined)
+                    throw readError;
+                return bytes;
+            },
+        });
+        if (observed === undefined) {
+            throw new Error("Unable to observe a requested native input predicate.");
+        }
+        nativePredicates[kind] = observed;
+    }
+    return {
+        ...(Object.keys(nativePredicates).length === 0 ? {} : { nativePredicates }),
+        ...(options.accessibleEntries === true
+            ? { accessibleEntries: compilerAccessibleEntries.compilerAccessibleEntries(file, filesystem) }
+            : {}),
+        directoryExists: stat === "directory",
+        fileExists: stat === "file",
+        graphHash: graphReadHash ??
+            (stat === "directory" ? directoryHash : MISSING_INPUT_STATE.MISSING_INPUT_STATE),
+        graphReadHash,
+        hostHash,
+        identity: pathIdentityKey.pathIdentityKey(file, identities),
+        realpath: compilerInputRealpathObservation.compilerInputRealpathObservation(file, filesystem),
+        stat,
+        ...(options.tree === true ? { tree: pluginSourceState.pluginSourceState(file) } : {}),
+    };
+}
+
+exports.captureWatchInputBaselines = captureWatchInputBaselines;
+//# sourceMappingURL=captureWatchInputBaselines.js.map

package/lib/core/transform/watch/captureWatchInputBaselines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"captureWatchInputBaselines.js","sources":["../../../../src/core/transform/watch/captureWatchInputBaselines.ts"],"sourcesContent":[null],"names":["DEFAULT_FILESYSTEM_OPERATIONS","createHostPathIdentityContext","stableStringify","compilerStatKind","compilerInputTextHash","hashText","MISSING_INPUT_STATE","nativeInputPredicateState","compilerAccessibleEntries","pathIdentityKey","compilerInputRealpathObservation","pluginSourceState"],"mappings":"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"}

package/lib/core/transform/watch/captureWatchInputBaselines.mjs

@@ -0,0 +1,117 @@
+import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+import { createHostPathIdentityContext } from '../filesystem/createHostPathIdentityContext.mjs';
+import { pathIdentityKey } from '../filesystem/pathIdentityKey.mjs';
+import { compilerAccessibleEntries } from '../inputs/compilerAccessibleEntries.mjs';
+import { compilerInputRealpathObservation } from '../inputs/compilerInputRealpathObservation.mjs';
+import { compilerInputTextHash } from '../inputs/compilerInputTextHash.mjs';
+import { compilerStatKind } from '../inputs/compilerStatKind.mjs';
+import { nativeInputPredicateState } from '../inputs/nativeInputPredicateState.mjs';
+import { pluginSourceState } from '../inputs/pluginSourceState.mjs';
+import { hashText } from '../utils/hashText.mjs';
+import { stableStringify } from '../utils/stableStringify.mjs';
+import { MISSING_INPUT_STATE } from '../validation/MISSING_INPUT_STATE.mjs';
+
+/**
+ * Capture a batch through two independently fresh native observation phases. A
+ * phase shares path/case observations only within this synchronous batch; the
+ * second phase has a new identity context and rereads every input. Nothing
+ * survives this call. Changed captures or escaping exceptions decline that
+ * input alone. Matching endpoints still cannot certify an atomic snapshot or
+ * exclude ABA.
+ *
+ * One current byte read supplies raw-host and compiler-text hashes in each
+ * phase. Failed reads retain native kind fallbacks; optional tree and listing
+ * observations keep their original owners and are captured in both phases.
+ * Requested native codecs share that phase's raw byte read and separately
+ * observe their own entry/listing/physical-target facts. Unsupported or failed
+ * native observations decline that path; equality still cannot exclude ABA.
+ *
+ * @evidence contracts/common.md#principled-implementation Each returned input has equal before/after facts from independent identity contexts and actual reads. Sharing directory resolution within a phase never supplies the second phase or a later batch; failed captures remain undefined independently of siblings.
+ * @evidence contracts/common.md#clear-and-simple-design Two phase maps surround one per-path fact collector, sharing the existing decoder, native predicates and optional tree/listing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No lifetime or historical identity memo enters this API. Both phases run for every selected spelling and compare complete facts, including identity and realpath; equality does not invent atomicity or exclude unobserved changes.
+ * @evidence contracts/common.md#meaningful-documentation Native prose defines phase ownership, shared byte provenance, rejection and the remaining temporal limitation.
+ * @evidence contracts/portability.md#os-neutral-implementation The coherent supplied filesystem provides native case, path, read, kind and listing capabilities. Each phase re-establishes aliases and case policy; no platform label supplies authority, and raw host bytes remain distinct from compiler-decoded text.
+ * @evidence contracts/performance.md#efficient-algorithms Two passes visit N unique spellings and read each path at most once per phase, sharing directory/case resolution within that phase. Native ancestor/path work, total bytes B, optional listing/tree populations and digest serialization remain costs; two maps retain O(N) baseline facts rather than historical generations.
+ * @evidence contracts/performance.md#reuse-equivalent-work Phase-local identity contexts reuse the same native namespace observation for related paths, and one actual byte observation supplies its two codecs. A new context and new reads are mandatory in the second phase and every later invocation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returned baselines are caller-owned; both identity contexts and phase maps are synchronous call-local values with no timer, watcher or retained cache.
+ */
+function captureWatchInputBaselines(files, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, options = {}) {
+    const selected = [...new Set(files)];
+    const observe = () => {
+        const identities = createHostPathIdentityContext(filesystem);
+        return new Map(selected.map((file) => {
+            try {
+                return [
+                    file,
+                    capture(file, filesystem, identities, options),
+                ];
+            }
+            catch {
+                return [file, undefined];
+            }
+        }));
+    };
+    const before = observe();
+    const after = observe();
+    for (const file of selected) {
+        if (before.get(file) === undefined ||
+            stableStringify(before.get(file)) !== stableStringify(after.get(file)))
+            after.set(file, undefined);
+    }
+    return after;
+}
+/** Capture one path's codec facts from this phase's fresh namespace view. */
+function capture(file, filesystem, identities, options) {
+    const stat = compilerStatKind(file, filesystem);
+    let bytes;
+    let readError;
+    try {
+        bytes = filesystem.readFile(file);
+    }
+    catch (error) {
+        readError = error;
+        // Failed reads keep their explicit codec fallbacks.
+    }
+    const graphReadHash = stat === "directory" || bytes === undefined
+        ? null
+        : compilerInputTextHash(bytes);
+    const directoryHash = hashText("ttsc:host-input:directory\0");
+    const hostHash = bytes === undefined
+        ? compilerStatKind(file, filesystem) === "directory"
+            ? directoryHash
+            : MISSING_INPUT_STATE
+        : hashText(bytes);
+    const nativePredicates = {};
+    for (const kind of new Set(options.nativePredicates ?? [])) {
+        const observed = nativeInputPredicateState(file, kind, filesystem, {
+            readFile() {
+                if (bytes === undefined)
+                    throw readError;
+                return bytes;
+            },
+        });
+        if (observed === undefined) {
+            throw new Error("Unable to observe a requested native input predicate.");
+        }
+        nativePredicates[kind] = observed;
+    }
+    return {
+        ...(Object.keys(nativePredicates).length === 0 ? {} : { nativePredicates }),
+        ...(options.accessibleEntries === true
+            ? { accessibleEntries: compilerAccessibleEntries(file, filesystem) }
+            : {}),
+        directoryExists: stat === "directory",
+        fileExists: stat === "file",
+        graphHash: graphReadHash ??
+            (stat === "directory" ? directoryHash : MISSING_INPUT_STATE),
+        graphReadHash,
+        hostHash,
+        identity: pathIdentityKey(file, identities),
+        realpath: compilerInputRealpathObservation(file, filesystem),
+        stat,
+        ...(options.tree === true ? { tree: pluginSourceState(file) } : {}),
+    };
+}
+
+export { captureWatchInputBaselines };
+//# sourceMappingURL=captureWatchInputBaselines.mjs.map

package/lib/core/transform/watch/captureWatchInputBaselines.mjs.map

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