@ttsc/unplugin 0.31.3 → 0.31.4

package/lib/core/transform/tracker/settleProjectMutationEvents.d.mts

@@ -1,48 +1,42 @@
 import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
 /**
- * Await the cached trackers' drain operations, then recheck their watched
- * directory identities before persistent validation reads their verdicts.
+ * Await the cached trackers' drain operations before persistent validation
+ * reads their verdicts.
  *
  * A synchronous edit returns before its watch event is applied, so without this
  * a delivery could validate against a tracker that has not been told yet. Each
  * tracker uses its supplied native drain or the local two-immediate fallback;
  * that fallback is a scheduling opportunity, not independent native delivery
- * proof. Concurrent sibling deliveries share an in-flight tracker drain. Each
- * tracker with a verifier then checks its watched directories against those it
- * opened on, so a replaced directory withdraws the tracker instead of leaving
- * its silence to stand as proof. The trackers share what they read, so a
- * directory they all watch, the project root above all, costs one metadata call
- * per invocation rather than one per tracker. This map assumes those callbacks
- * share a coherent filesystem view; it is not an atomic snapshot. Drain
- * rejection aborts this verification phase and does not cancel sibling drains.
+ * proof. Concurrent sibling deliveries share an in-flight tracker drain. Drain
+ * rejection aborts the delivery's settlement and does not cancel sibling
+ * drains.
+ *
+ * The watched directories' identities are not checked here but by the
+ * delivery's synchronous admission (`verifyGenerationLocations`), after its
+ * last await, so a directory replaced while the delivery prepared is still
+ * caught and its reading is current when a validator reuses it.
  *
  * @evidence contracts/common.md#principled-implementation
- *   Successful aggregate completion precedes the available directory verifiers.
- *   Missing optional verifiers and backend delivery premises are not supplied
- *   by this adapter; the caller still decides whether silence has authority.
+ *   Successful aggregate completion precedes admission. Missing backend
+ *   delivery premises are not supplied by this adapter; the caller still
+ *   decides whether silence has authority.
  * @evidence contracts/common.md#clear-and-simple-design
- *   One three-tracker list drives both phases; a delivery-local identity map
- *   shares metadata without adding persistent validity state.
+ *   One three-tracker list drives drainage; directory identity belongs to the
+ *   synchronous admission that reads it.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts
- *   A replaced watched directory withdraws authority; the operation does not
- *   patch watcher paths or certify a generation from a timeout alone.
+ *   The operation does not patch watcher paths or certify a generation from a
+ *   timeout alone.
  * @evidence contracts/common.md#meaningful-documentation
- *   Native paragraphs explain event ordering, directory replacement and shared
- *   verification under the documentation skill.
+ *   Native paragraphs explain event ordering and where location verification
+ *   moved, under the documentation skill.
  * @evidence contracts/portability.md#os-neutral-implementation
- *   OS-neutral delivery uses backend-owned drains and filesystem-owned physical
- *   identities; lexical aliases cannot prove a replaced directory unchanged.
+ *   OS-neutral delivery uses backend-owned drains.
  * @evidence contracts/performance.md#efficient-algorithms
- *   Three tracker slots are visited after concurrent drainage. Existing
- *   verifiers scan their retained watched locations, sharing one metadata read
- *   per exact directory spelling; native path traversal, key bytes and bigint
- *   identity formatting plus delegated drain work remain variable costs.
+ *   Three tracker slots are drained concurrently; delegated drain work remains
+ *   a variable cost.
  * @evidence contracts/performance.md#reuse-equivalent-work
- *   In-flight drainage is shared by tracker and identity observations by this
- *   delivery's map; the map is recreated for every delivery, not cached forever.
+ *   In-flight drainage is shared by concurrent sibling deliveries.
  * @evidence contracts/performance.md#bound-retention-and-release-resources
- *   The identity map is local to the post-drain verification call, retaining
- *   queried directory/identity text with no independent population/byte cap.
  *   Pending drains retain the cached tracker references until they settle;
  *   rejection does not cancel siblings and no aggregate deadline is supplied.
  *   Tracker owners still control backend task and watcher closure.

package/lib/core/transform/tracker/settleProjectMutationEvents.d.ts

@@ -1,48 +1,42 @@
 import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
 /**
- * Await the cached trackers' drain operations, then recheck their watched
- * directory identities before persistent validation reads their verdicts.
+ * Await the cached trackers' drain operations before persistent validation
+ * reads their verdicts.
  *
  * A synchronous edit returns before its watch event is applied, so without this
  * a delivery could validate against a tracker that has not been told yet. Each
  * tracker uses its supplied native drain or the local two-immediate fallback;
  * that fallback is a scheduling opportunity, not independent native delivery
- * proof. Concurrent sibling deliveries share an in-flight tracker drain. Each
- * tracker with a verifier then checks its watched directories against those it
- * opened on, so a replaced directory withdraws the tracker instead of leaving
- * its silence to stand as proof. The trackers share what they read, so a
- * directory they all watch, the project root above all, costs one metadata call
- * per invocation rather than one per tracker. This map assumes those callbacks
- * share a coherent filesystem view; it is not an atomic snapshot. Drain
- * rejection aborts this verification phase and does not cancel sibling drains.
+ * proof. Concurrent sibling deliveries share an in-flight tracker drain. Drain
+ * rejection aborts the delivery's settlement and does not cancel sibling
+ * drains.
+ *
+ * The watched directories' identities are not checked here but by the
+ * delivery's synchronous admission (`verifyGenerationLocations`), after its
+ * last await, so a directory replaced while the delivery prepared is still
+ * caught and its reading is current when a validator reuses it.
  *
  * @evidence contracts/common.md#principled-implementation
- *   Successful aggregate completion precedes the available directory verifiers.
- *   Missing optional verifiers and backend delivery premises are not supplied
- *   by this adapter; the caller still decides whether silence has authority.
+ *   Successful aggregate completion precedes admission. Missing backend
+ *   delivery premises are not supplied by this adapter; the caller still
+ *   decides whether silence has authority.
  * @evidence contracts/common.md#clear-and-simple-design
- *   One three-tracker list drives both phases; a delivery-local identity map
- *   shares metadata without adding persistent validity state.
+ *   One three-tracker list drives drainage; directory identity belongs to the
+ *   synchronous admission that reads it.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts
- *   A replaced watched directory withdraws authority; the operation does not
- *   patch watcher paths or certify a generation from a timeout alone.
+ *   The operation does not patch watcher paths or certify a generation from a
+ *   timeout alone.
  * @evidence contracts/common.md#meaningful-documentation
- *   Native paragraphs explain event ordering, directory replacement and shared
- *   verification under the documentation skill.
+ *   Native paragraphs explain event ordering and where location verification
+ *   moved, under the documentation skill.
  * @evidence contracts/portability.md#os-neutral-implementation
- *   OS-neutral delivery uses backend-owned drains and filesystem-owned physical
- *   identities; lexical aliases cannot prove a replaced directory unchanged.
+ *   OS-neutral delivery uses backend-owned drains.
  * @evidence contracts/performance.md#efficient-algorithms
- *   Three tracker slots are visited after concurrent drainage. Existing
- *   verifiers scan their retained watched locations, sharing one metadata read
- *   per exact directory spelling; native path traversal, key bytes and bigint
- *   identity formatting plus delegated drain work remain variable costs.
+ *   Three tracker slots are drained concurrently; delegated drain work remains
+ *   a variable cost.
  * @evidence contracts/performance.md#reuse-equivalent-work
- *   In-flight drainage is shared by tracker and identity observations by this
- *   delivery's map; the map is recreated for every delivery, not cached forever.
+ *   In-flight drainage is shared by concurrent sibling deliveries.
  * @evidence contracts/performance.md#bound-retention-and-release-resources
- *   The identity map is local to the post-drain verification call, retaining
- *   queried directory/identity text with no independent population/byte cap.
  *   Pending drains retain the cached tracker references until they settle;
  *   rejection does not cancel siblings and no aggregate deadline is supplied.
  *   Tracker owners still control backend task and watcher closure.

package/lib/core/transform/tracker/settleProjectMutationEvents.js

@@ -3,65 +3,53 @@
 var settleMutationTrackers = require('./settleMutationTrackers.js');
 
 /**
- * Await the cached trackers' drain operations, then recheck their watched
- * directory identities before persistent validation reads their verdicts.
+ * Await the cached trackers' drain operations before persistent validation
+ * reads their verdicts.
  *
  * A synchronous edit returns before its watch event is applied, so without this
  * a delivery could validate against a tracker that has not been told yet. Each
  * tracker uses its supplied native drain or the local two-immediate fallback;
  * that fallback is a scheduling opportunity, not independent native delivery
- * proof. Concurrent sibling deliveries share an in-flight tracker drain. Each
- * tracker with a verifier then checks its watched directories against those it
- * opened on, so a replaced directory withdraws the tracker instead of leaving
- * its silence to stand as proof. The trackers share what they read, so a
- * directory they all watch, the project root above all, costs one metadata call
- * per invocation rather than one per tracker. This map assumes those callbacks
- * share a coherent filesystem view; it is not an atomic snapshot. Drain
- * rejection aborts this verification phase and does not cancel sibling drains.
+ * proof. Concurrent sibling deliveries share an in-flight tracker drain. Drain
+ * rejection aborts the delivery's settlement and does not cancel sibling
+ * drains.
+ *
+ * The watched directories' identities are not checked here but by the
+ * delivery's synchronous admission (`verifyGenerationLocations`), after its
+ * last await, so a directory replaced while the delivery prepared is still
+ * caught and its reading is current when a validator reuses it.
  *
  * @evidence contracts/common.md#principled-implementation
- *   Successful aggregate completion precedes the available directory verifiers.
- *   Missing optional verifiers and backend delivery premises are not supplied
- *   by this adapter; the caller still decides whether silence has authority.
+ *   Successful aggregate completion precedes admission. Missing backend
+ *   delivery premises are not supplied by this adapter; the caller still
+ *   decides whether silence has authority.
  * @evidence contracts/common.md#clear-and-simple-design
- *   One three-tracker list drives both phases; a delivery-local identity map
- *   shares metadata without adding persistent validity state.
+ *   One three-tracker list drives drainage; directory identity belongs to the
+ *   synchronous admission that reads it.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts
- *   A replaced watched directory withdraws authority; the operation does not
- *   patch watcher paths or certify a generation from a timeout alone.
+ *   The operation does not patch watcher paths or certify a generation from a
+ *   timeout alone.
  * @evidence contracts/common.md#meaningful-documentation
- *   Native paragraphs explain event ordering, directory replacement and shared
- *   verification under the documentation skill.
+ *   Native paragraphs explain event ordering and where location verification
+ *   moved, under the documentation skill.
  * @evidence contracts/portability.md#os-neutral-implementation
- *   OS-neutral delivery uses backend-owned drains and filesystem-owned physical
- *   identities; lexical aliases cannot prove a replaced directory unchanged.
+ *   OS-neutral delivery uses backend-owned drains.
  * @evidence contracts/performance.md#efficient-algorithms
- *   Three tracker slots are visited after concurrent drainage. Existing
- *   verifiers scan their retained watched locations, sharing one metadata read
- *   per exact directory spelling; native path traversal, key bytes and bigint
- *   identity formatting plus delegated drain work remain variable costs.
+ *   Three tracker slots are drained concurrently; delegated drain work remains
+ *   a variable cost.
  * @evidence contracts/performance.md#reuse-equivalent-work
- *   In-flight drainage is shared by tracker and identity observations by this
- *   delivery's map; the map is recreated for every delivery, not cached forever.
+ *   In-flight drainage is shared by concurrent sibling deliveries.
  * @evidence contracts/performance.md#bound-retention-and-release-resources
- *   The identity map is local to the post-drain verification call, retaining
- *   queried directory/identity text with no independent population/byte cap.
  *   Pending drains retain the cached tracker references until they settle;
  *   rejection does not cancel siblings and no aggregate deadline is supplied.
  *   Tracker owners still control backend task and watcher closure.
  */
 async function settleProjectMutationEvents(cached) {
-    const trackers = [
+    await settleMutationTrackers.settleMutationTrackers([
         cached.projectMutationTracker,
         cached.hostInputMutationTracker,
         cached.candidateMutationTracker,
-    ];
-    await settleMutationTrackers.settleMutationTrackers(trackers);
-    // A watch that now observes a replaced directory has nothing left to say
-    // about the new one, so it gives up its authority before anything reads it.
-    const seen = new Map();
-    for (const tracker of trackers)
-        tracker?.verifyLocations?.(seen);
+    ]);
 }
 
 exports.settleProjectMutationEvents = settleProjectMutationEvents;

package/lib/core/transform/tracker/settleProjectMutationEvents.js.map

@@ -1 +1 @@
-{"version":3,"file":"settleProjectMutationEvents.js","sources":["../../../../src/core/transform/tracker/settleProjectMutationEvents.ts"],"sourcesContent":[null],"names":["settleMutationTrackers"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CG;AACI,eAAe,2BAA2B,CAC/C,MAAkC,EAAA;AAElC,IAAA,MAAM,QAAQ,GAAG;AACf,QAAA,MAAM,CAAC,sBAAsB;AAC7B,QAAA,MAAM,CAAC,wBAAwB;AAC/B,QAAA,MAAM,CAAC,wBAAwB;KAChC;AACD,IAAA,MAAMA,6CAAsB,CAAC,QAAQ,CAAC;;;AAGtC,IAAA,MAAM,IAAI,GAAG,IAAI,GAAG,EAA8B;IAClD,KAAK,MAAM,OAAO,IAAI,QAAQ;AAAE,QAAA,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;AAClE;;;;"}
+{"version":3,"file":"settleProjectMutationEvents.js","sources":["../../../../src/core/transform/tracker/settleProjectMutationEvents.ts"],"sourcesContent":[null],"names":["settleMutationTrackers"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCG;AACI,eAAe,2BAA2B,CAC/C,MAAkC,EAAA;AAElC,IAAA,MAAMA,6CAAsB,CAAC;AAC3B,QAAA,MAAM,CAAC,sBAAsB;AAC7B,QAAA,MAAM,CAAC,wBAAwB;AAC/B,QAAA,MAAM,CAAC,wBAAwB;AAChC,KAAA,CAAC;AACJ;;;;"}

package/lib/core/transform/tracker/settleProjectMutationEvents.mjs

@@ -1,65 +1,53 @@
 import { settleMutationTrackers } from './settleMutationTrackers.mjs';
 
 /**
- * Await the cached trackers' drain operations, then recheck their watched
- * directory identities before persistent validation reads their verdicts.
+ * Await the cached trackers' drain operations before persistent validation
+ * reads their verdicts.
  *
  * A synchronous edit returns before its watch event is applied, so without this
  * a delivery could validate against a tracker that has not been told yet. Each
  * tracker uses its supplied native drain or the local two-immediate fallback;
  * that fallback is a scheduling opportunity, not independent native delivery
- * proof. Concurrent sibling deliveries share an in-flight tracker drain. Each
- * tracker with a verifier then checks its watched directories against those it
- * opened on, so a replaced directory withdraws the tracker instead of leaving
- * its silence to stand as proof. The trackers share what they read, so a
- * directory they all watch, the project root above all, costs one metadata call
- * per invocation rather than one per tracker. This map assumes those callbacks
- * share a coherent filesystem view; it is not an atomic snapshot. Drain
- * rejection aborts this verification phase and does not cancel sibling drains.
+ * proof. Concurrent sibling deliveries share an in-flight tracker drain. Drain
+ * rejection aborts the delivery's settlement and does not cancel sibling
+ * drains.
+ *
+ * The watched directories' identities are not checked here but by the
+ * delivery's synchronous admission (`verifyGenerationLocations`), after its
+ * last await, so a directory replaced while the delivery prepared is still
+ * caught and its reading is current when a validator reuses it.
  *
  * @evidence contracts/common.md#principled-implementation
- *   Successful aggregate completion precedes the available directory verifiers.
- *   Missing optional verifiers and backend delivery premises are not supplied
- *   by this adapter; the caller still decides whether silence has authority.
+ *   Successful aggregate completion precedes admission. Missing backend
+ *   delivery premises are not supplied by this adapter; the caller still
+ *   decides whether silence has authority.
  * @evidence contracts/common.md#clear-and-simple-design
- *   One three-tracker list drives both phases; a delivery-local identity map
- *   shares metadata without adding persistent validity state.
+ *   One three-tracker list drives drainage; directory identity belongs to the
+ *   synchronous admission that reads it.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts
- *   A replaced watched directory withdraws authority; the operation does not
- *   patch watcher paths or certify a generation from a timeout alone.
+ *   The operation does not patch watcher paths or certify a generation from a
+ *   timeout alone.
  * @evidence contracts/common.md#meaningful-documentation
- *   Native paragraphs explain event ordering, directory replacement and shared
- *   verification under the documentation skill.
+ *   Native paragraphs explain event ordering and where location verification
+ *   moved, under the documentation skill.
  * @evidence contracts/portability.md#os-neutral-implementation
- *   OS-neutral delivery uses backend-owned drains and filesystem-owned physical
- *   identities; lexical aliases cannot prove a replaced directory unchanged.
+ *   OS-neutral delivery uses backend-owned drains.
  * @evidence contracts/performance.md#efficient-algorithms
- *   Three tracker slots are visited after concurrent drainage. Existing
- *   verifiers scan their retained watched locations, sharing one metadata read
- *   per exact directory spelling; native path traversal, key bytes and bigint
- *   identity formatting plus delegated drain work remain variable costs.
+ *   Three tracker slots are drained concurrently; delegated drain work remains
+ *   a variable cost.
  * @evidence contracts/performance.md#reuse-equivalent-work
- *   In-flight drainage is shared by tracker and identity observations by this
- *   delivery's map; the map is recreated for every delivery, not cached forever.
+ *   In-flight drainage is shared by concurrent sibling deliveries.
  * @evidence contracts/performance.md#bound-retention-and-release-resources
- *   The identity map is local to the post-drain verification call, retaining
- *   queried directory/identity text with no independent population/byte cap.
  *   Pending drains retain the cached tracker references until they settle;
  *   rejection does not cancel siblings and no aggregate deadline is supplied.
  *   Tracker owners still control backend task and watcher closure.
  */
 async function settleProjectMutationEvents(cached) {
-    const trackers = [
+    await settleMutationTrackers([
         cached.projectMutationTracker,
         cached.hostInputMutationTracker,
         cached.candidateMutationTracker,
-    ];
-    await settleMutationTrackers(trackers);
-    // A watch that now observes a replaced directory has nothing left to say
-    // about the new one, so it gives up its authority before anything reads it.
-    const seen = new Map();
-    for (const tracker of trackers)
-        tracker?.verifyLocations?.(seen);
+    ]);
 }
 
 export { settleProjectMutationEvents };

package/lib/core/transform/tracker/settleProjectMutationEvents.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"settleProjectMutationEvents.mjs","sources":["../../../../src/core/transform/tracker/settleProjectMutationEvents.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CG;AACI,eAAe,2BAA2B,CAC/C,MAAkC,EAAA;AAElC,IAAA,MAAM,QAAQ,GAAG;AACf,QAAA,MAAM,CAAC,sBAAsB;AAC7B,QAAA,MAAM,CAAC,wBAAwB;AAC/B,QAAA,MAAM,CAAC,wBAAwB;KAChC;AACD,IAAA,MAAM,sBAAsB,CAAC,QAAQ,CAAC;;;AAGtC,IAAA,MAAM,IAAI,GAAG,IAAI,GAAG,EAA8B;IAClD,KAAK,MAAM,OAAO,IAAI,QAAQ;AAAE,QAAA,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;AAClE;;;;"}
+{"version":3,"file":"settleProjectMutationEvents.mjs","sources":["../../../../src/core/transform/tracker/settleProjectMutationEvents.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCG;AACI,eAAe,2BAA2B,CAC/C,MAAkC,EAAA;AAElC,IAAA,MAAM,sBAAsB,CAAC;AAC3B,QAAA,MAAM,CAAC,sBAAsB;AAC7B,QAAA,MAAM,CAAC,wBAAwB;AAC/B,QAAA,MAAM,CAAC,wBAAwB;AAChC,KAAA,CAAC;AACJ;;;;"}

package/lib/core/transform/tracker/verifyGenerationLocations.d.cts

@@ -0,0 +1,41 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+/**
+ * Recheck every watched directory's identity against the one its tracker opened
+ * on, returning what the check read.
+ *
+ * A watch that now observes a replaced directory has nothing left to say about
+ * the new one, so its tracker gives up its authority before anything reads it.
+ * The trackers share what they read, so a directory they all watch, the project
+ * root above all, costs one metadata call per delivery rather than one per
+ * tracker. The returned readings belong to the synchronous admission that ran
+ * the check: a validator in it that must know whether one of these directories
+ * is still a directory reads the answer here instead of stating it again
+ * (samchon/ttsc#1735). The map assumes the callbacks share a coherent
+ * filesystem view; it is not an atomic snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   Each verifier compares followed device and file ids with the opened ones,
+ *   and a mismatch or unreadable location withdraws its tracker.
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   One three-tracker list drives every verifier through one delivery-local
+ *   identity map, which is also the result.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   A replaced watched directory withdraws authority; lexical spelling never
+ *   proves a directory unchanged.
+ * @evidence contracts/common.md#meaningful-documentation
+ *   Native prose explains withdrawal, sharing and the result's synchronous
+ *   lifetime under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Identities are the filesystem's own physical identities, followed through
+ *   links, with no platform case rule.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Three tracker slots are visited; existing verifiers scan their retained
+ *   watched locations, sharing one metadata read per exact directory spelling.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The map is created for each admission and handed to that admission's
+ *   validators, never retained across deliveries.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The caller's synchronous transaction owns the map, which retains queried
+ *   directory and identity text only until that transaction ends.
+ */
+export declare function verifyGenerationLocations(cached: TtscCachedProjectTransform): Map<string, string | undefined>;

package/lib/core/transform/tracker/verifyGenerationLocations.d.mts

@@ -0,0 +1,41 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+/**
+ * Recheck every watched directory's identity against the one its tracker opened
+ * on, returning what the check read.
+ *
+ * A watch that now observes a replaced directory has nothing left to say about
+ * the new one, so its tracker gives up its authority before anything reads it.
+ * The trackers share what they read, so a directory they all watch, the project
+ * root above all, costs one metadata call per delivery rather than one per
+ * tracker. The returned readings belong to the synchronous admission that ran
+ * the check: a validator in it that must know whether one of these directories
+ * is still a directory reads the answer here instead of stating it again
+ * (samchon/ttsc#1735). The map assumes the callbacks share a coherent
+ * filesystem view; it is not an atomic snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   Each verifier compares followed device and file ids with the opened ones,
+ *   and a mismatch or unreadable location withdraws its tracker.
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   One three-tracker list drives every verifier through one delivery-local
+ *   identity map, which is also the result.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   A replaced watched directory withdraws authority; lexical spelling never
+ *   proves a directory unchanged.
+ * @evidence contracts/common.md#meaningful-documentation
+ *   Native prose explains withdrawal, sharing and the result's synchronous
+ *   lifetime under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Identities are the filesystem's own physical identities, followed through
+ *   links, with no platform case rule.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Three tracker slots are visited; existing verifiers scan their retained
+ *   watched locations, sharing one metadata read per exact directory spelling.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The map is created for each admission and handed to that admission's
+ *   validators, never retained across deliveries.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The caller's synchronous transaction owns the map, which retains queried
+ *   directory and identity text only until that transaction ends.
+ */
+export declare function verifyGenerationLocations(cached: TtscCachedProjectTransform): Map<string, string | undefined>;

package/lib/core/transform/tracker/verifyGenerationLocations.d.ts

@@ -0,0 +1,41 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+/**
+ * Recheck every watched directory's identity against the one its tracker opened
+ * on, returning what the check read.
+ *
+ * A watch that now observes a replaced directory has nothing left to say about
+ * the new one, so its tracker gives up its authority before anything reads it.
+ * The trackers share what they read, so a directory they all watch, the project
+ * root above all, costs one metadata call per delivery rather than one per
+ * tracker. The returned readings belong to the synchronous admission that ran
+ * the check: a validator in it that must know whether one of these directories
+ * is still a directory reads the answer here instead of stating it again
+ * (samchon/ttsc#1735). The map assumes the callbacks share a coherent
+ * filesystem view; it is not an atomic snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   Each verifier compares followed device and file ids with the opened ones,
+ *   and a mismatch or unreadable location withdraws its tracker.
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   One three-tracker list drives every verifier through one delivery-local
+ *   identity map, which is also the result.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   A replaced watched directory withdraws authority; lexical spelling never
+ *   proves a directory unchanged.
+ * @evidence contracts/common.md#meaningful-documentation
+ *   Native prose explains withdrawal, sharing and the result's synchronous
+ *   lifetime under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Identities are the filesystem's own physical identities, followed through
+ *   links, with no platform case rule.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Three tracker slots are visited; existing verifiers scan their retained
+ *   watched locations, sharing one metadata read per exact directory spelling.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The map is created for each admission and handed to that admission's
+ *   validators, never retained across deliveries.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The caller's synchronous transaction owns the map, which retains queried
+ *   directory and identity text only until that transaction ends.
+ */
+export declare function verifyGenerationLocations(cached: TtscCachedProjectTransform): Map<string, string | undefined>;

package/lib/core/transform/tracker/verifyGenerationLocations.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/**
+ * Recheck every watched directory's identity against the one its tracker opened
+ * on, returning what the check read.
+ *
+ * A watch that now observes a replaced directory has nothing left to say about
+ * the new one, so its tracker gives up its authority before anything reads it.
+ * The trackers share what they read, so a directory they all watch, the project
+ * root above all, costs one metadata call per delivery rather than one per
+ * tracker. The returned readings belong to the synchronous admission that ran
+ * the check: a validator in it that must know whether one of these directories
+ * is still a directory reads the answer here instead of stating it again
+ * (samchon/ttsc#1735). The map assumes the callbacks share a coherent
+ * filesystem view; it is not an atomic snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   Each verifier compares followed device and file ids with the opened ones,
+ *   and a mismatch or unreadable location withdraws its tracker.
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   One three-tracker list drives every verifier through one delivery-local
+ *   identity map, which is also the result.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   A replaced watched directory withdraws authority; lexical spelling never
+ *   proves a directory unchanged.
+ * @evidence contracts/common.md#meaningful-documentation
+ *   Native prose explains withdrawal, sharing and the result's synchronous
+ *   lifetime under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Identities are the filesystem's own physical identities, followed through
+ *   links, with no platform case rule.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Three tracker slots are visited; existing verifiers scan their retained
+ *   watched locations, sharing one metadata read per exact directory spelling.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The map is created for each admission and handed to that admission's
+ *   validators, never retained across deliveries.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The caller's synchronous transaction owns the map, which retains queried
+ *   directory and identity text only until that transaction ends.
+ */
+function verifyGenerationLocations(cached) {
+    const seen = new Map();
+    for (const tracker of [
+        cached.projectMutationTracker,
+        cached.hostInputMutationTracker,
+        cached.candidateMutationTracker,
+    ])
+        tracker?.verifyLocations?.(seen);
+    return seen;
+}
+
+exports.verifyGenerationLocations = verifyGenerationLocations;
+//# sourceMappingURL=verifyGenerationLocations.js.map

package/lib/core/transform/tracker/verifyGenerationLocations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyGenerationLocations.js","sources":["../../../../src/core/transform/tracker/verifyGenerationLocations.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;AACG,SAAU,yBAAyB,CACvC,MAAkC,EAAA;AAElC,IAAA,MAAM,IAAI,GAAG,IAAI,GAAG,EAA8B;IAClD,KAAK,MAAM,OAAO,IAAI;AACpB,QAAA,MAAM,CAAC,sBAAsB;AAC7B,QAAA,MAAM,CAAC,wBAAwB;AAC/B,QAAA,MAAM,CAAC,wBAAwB;AAChC,KAAA;AACC,QAAA,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;AAClC,IAAA,OAAO,IAAI;AACb;;;;"}

package/lib/core/transform/tracker/verifyGenerationLocations.mjs

@@ -0,0 +1,52 @@
+/**
+ * Recheck every watched directory's identity against the one its tracker opened
+ * on, returning what the check read.
+ *
+ * A watch that now observes a replaced directory has nothing left to say about
+ * the new one, so its tracker gives up its authority before anything reads it.
+ * The trackers share what they read, so a directory they all watch, the project
+ * root above all, costs one metadata call per delivery rather than one per
+ * tracker. The returned readings belong to the synchronous admission that ran
+ * the check: a validator in it that must know whether one of these directories
+ * is still a directory reads the answer here instead of stating it again
+ * (samchon/ttsc#1735). The map assumes the callbacks share a coherent
+ * filesystem view; it is not an atomic snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   Each verifier compares followed device and file ids with the opened ones,
+ *   and a mismatch or unreadable location withdraws its tracker.
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   One three-tracker list drives every verifier through one delivery-local
+ *   identity map, which is also the result.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   A replaced watched directory withdraws authority; lexical spelling never
+ *   proves a directory unchanged.
+ * @evidence contracts/common.md#meaningful-documentation
+ *   Native prose explains withdrawal, sharing and the result's synchronous
+ *   lifetime under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Identities are the filesystem's own physical identities, followed through
+ *   links, with no platform case rule.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Three tracker slots are visited; existing verifiers scan their retained
+ *   watched locations, sharing one metadata read per exact directory spelling.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The map is created for each admission and handed to that admission's
+ *   validators, never retained across deliveries.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The caller's synchronous transaction owns the map, which retains queried
+ *   directory and identity text only until that transaction ends.
+ */
+function verifyGenerationLocations(cached) {
+    const seen = new Map();
+    for (const tracker of [
+        cached.projectMutationTracker,
+        cached.hostInputMutationTracker,
+        cached.candidateMutationTracker,
+    ])
+        tracker?.verifyLocations?.(seen);
+    return seen;
+}
+
+export { verifyGenerationLocations };
+//# sourceMappingURL=verifyGenerationLocations.mjs.map

package/lib/core/transform/tracker/verifyGenerationLocations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyGenerationLocations.mjs","sources":["../../../../src/core/transform/tracker/verifyGenerationLocations.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;AACG,SAAU,yBAAyB,CACvC,MAAkC,EAAA;AAElC,IAAA,MAAM,IAAI,GAAG,IAAI,GAAG,EAA8B;IAClD,KAAK,MAAM,OAAO,IAAI;AACpB,QAAA,MAAM,CAAC,sBAAsB;AAC7B,QAAA,MAAM,CAAC,wBAAwB;AAC/B,QAAA,MAAM,CAAC,wBAAwB;AAChC,KAAA;AACC,QAAA,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;AAClC,IAAA,OAAO,IAAI;AACb;;;;"}

package/lib/core/transform/utils/isZombieProcess.d.cts

@@ -0,0 +1,26 @@
+/**
+ * Whether process `pid` has exited and only waits for its parent to collect its
+ * status.
+ *
+ * Signal zero still reaches such a zombie, so a liveness probe built on it
+ * alone counts the process alive. A parent that never collects, such as a
+ * container's PID 1 that is not an init or a subreaper that collects only when
+ * its own command ends, keeps the zombie indefinitely, and the locks and
+ * directories it owned would never be reclaimed. Only Linux exposes the state,
+ * through `/proc`; elsewhere, and whenever it cannot be read, this answers
+ * `false` so the caller's existing probe decides. A leader whose own thread
+ * exited also reads as a zombie while its other threads run, so the zombie must
+ * be the process's last thread. A zombie keeps its id until collected, so this
+ * never names a live process.
+ *
+ * @param pid A positive process id that signal zero just found.
+ * @evidence contracts/common.md#principled-implementation The kernel's own process status, zombie or dead with no other thread, establishes the exit; any unreadable or other status leaves the caller's signal-zero answer standing.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate serves the shared-compile lock, session-owner and watch-probe owners alike.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No PID list, timeout or error-to-exited fallback substitutes for the kernel status.
+ * @evidence contracts/common.md#meaningful-documentation The paragraph explains why signal zero misses a zombie, which parents leave one behind, why a zombie leader with running threads is not one and why its id cannot name a live process.
+ * @evidence contracts/portability.md#os-neutral-implementation Only Linux exposes zombies through /proc; other platforms keep their probe's answer.
+ * @evidence contracts/performance.md#efficient-algorithms One small /proc read on Linux, nothing elsewhere.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Process state is a current observation and is never cached.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The read retains no handle; the status text becomes reclaimable on return.
+ */
+export declare function isZombieProcess(pid: number): boolean;