ttsc 0.30.3 → 0.31.0

package/lib/launcher/internal/watch/projectInputMembershipInvalidatesProgram.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Return whether a project-input population transition can reshape a Program.
+ *
+ * JSON is data to a ProjectRule but may simultaneously be a `resolveJsonModule`
+ * source. TypeScript and JavaScript paths can likewise overlap a project-input
+ * declaration. Their creation or deletion therefore requires a cold Program
+ * inside the existing resident process. A filename-less event cannot identify
+ * the changed member and is conservatively invalidating whenever the population
+ * moved.
+ *
+ * @evidence contracts/common.md#principled-implementation Added or removed emittable members and package.json content changes can alter compiler resolution; unlocalized population movement conservatively invalidates the resident Program.
+ * @evidence contracts/common.md#clear-and-simple-design Package selection changes, equal membership and changed compiler-capable members are separate ordered decisions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The predicate inspects both populations instead of guessing the changed member from one named event.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain overlapping JSON/source populations and unnamed-event invalidation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native basename and extension APIs interpret paths; already canonical membership keys retain their producer's actual identity policy.
+ * @evidence contracts/performance.md#efficient-algorithms A content-change check can inspect C supplied changed-input spellings before map equality scans up to P borrowed entries. If membership differs and the event is named, removed/added checks can visit P previous and N next entries with short-circuiting. Indexed keys, value comparison, native basename/extname and lowercasing add uncapped spelling costs; no population array is reconstructed beyond an optional one-element fallback.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This predicate classifies supplied snapshots without coordinating compilation reuse itself.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Both populations are borrowed and no historical state or native resource is retained.
+ */
+export declare function projectInputMembershipInvalidatesProgram(input: {
+    changed?: string;
+    changedInputs?: readonly string[];
+    contentChanged?: boolean;
+    next: ReadonlyMap<string, string>;
+    previous: ReadonlyMap<string, string>;
+}): boolean;

package/lib/launcher/internal/watch/projectInputMembershipInvalidatesProgram.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectInputMembershipInvalidatesProgram = projectInputMembershipInvalidatesProgram;
+const node_path_1 = __importDefault(require("node:path"));
+const ProjectInputWatchRules_1 = require("./ProjectInputWatchRules");
+const WatchPaths_1 = require("./WatchPaths");
+/**
+ * Return whether a project-input population transition can reshape a Program.
+ *
+ * JSON is data to a ProjectRule but may simultaneously be a `resolveJsonModule`
+ * source. TypeScript and JavaScript paths can likewise overlap a project-input
+ * declaration. Their creation or deletion therefore requires a cold Program
+ * inside the existing resident process. A filename-less event cannot identify
+ * the changed member and is conservatively invalidating whenever the population
+ * moved.
+ *
+ * @evidence contracts/common.md#principled-implementation Added or removed emittable members and package.json content changes can alter compiler resolution; unlocalized population movement conservatively invalidates the resident Program.
+ * @evidence contracts/common.md#clear-and-simple-design Package selection changes, equal membership and changed compiler-capable members are separate ordered decisions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The predicate inspects both populations instead of guessing the changed member from one named event.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain overlapping JSON/source populations and unnamed-event invalidation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native basename and extension APIs interpret paths; already canonical membership keys retain their producer's actual identity policy.
+ * @evidence contracts/performance.md#efficient-algorithms A content-change check can inspect C supplied changed-input spellings before map equality scans up to P borrowed entries. If membership differs and the event is named, removed/added checks can visit P previous and N next entries with short-circuiting. Indexed keys, value comparison, native basename/extname and lowercasing add uncapped spelling costs; no population array is reconstructed beyond an optional one-element fallback.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This predicate classifies supplied snapshots without coordinating compilation reuse itself.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Both populations are borrowed and no historical state or native resource is retained.
+ */
+function projectInputMembershipInvalidatesProgram(input) {
+    if (input.contentChanged === true &&
+        (input.changedInputs ??
+            (input.changed === undefined ? [] : [input.changed])).some((location) => node_path_1.default.basename(location).toLowerCase() === "package.json")) {
+        return true;
+    }
+    if (WatchPaths_1.WatchPaths.mapsEqual(input.previous, input.next))
+        return false;
+    if (input.changed === undefined)
+        return true;
+    for (const [key, location] of input.previous) {
+        if (input.next.has(key) === false &&
+            ProjectInputWatchRules_1.ProjectInputWatchRules.projectInputPathMayAffectProgram(location)) {
+            return true;
+        }
+    }
+    for (const [key, location] of input.next) {
+        if (input.previous.has(key) === false &&
+            ProjectInputWatchRules_1.ProjectInputWatchRules.projectInputPathMayAffectProgram(location)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=projectInputMembershipInvalidatesProgram.js.map

package/lib/launcher/internal/watch/projectInputMembershipInvalidatesProgram.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectInputMembershipInvalidatesProgram.js","sourceRoot":"","sources":["../../../../src/launcher/internal/watch/projectInputMembershipInvalidatesProgram.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAE7B,qEAAkE;AAClE,6CAA0C;AAE1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,kDAAyD,KAMxD;IACC,IACE,KAAK,CAAC,cAAc,KAAK,IAAI;QAC7B,CACE,KAAK,CAAC,aAAa;YACnB,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CACrD,CAAC,IAAI,CACJ,CAAC,QAAQ,EAAE,EAAE,CAAC,mBAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,KAAK,cAAc,CACvE,EACD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,uBAAU,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IACnE,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAC7C,KAAK,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC7C,IACE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,KAAK;YAC7B,+CAAsB,CAAC,gCAAgC,CAAC,QAAQ,CAAC,EACjE,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,KAAK,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;QACzC,IACE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,KAAK;YACjC,+CAAsB,CAAC,gCAAgC,CAAC,QAAQ,CAAC,EACjE,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/lib/launcher/internal/watch/projectInputReloadEventShouldNotify.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Classify an exact execution-selection input ahead of ordinary project data.
+ *
+ * `changedInputs` carries fingerprint or membership deltas, so a filename-less
+ * event can still select the cold lane. A named exact event selects the cold
+ * lane only after the surrounding change detector admits the event; unchanged
+ * bytes remain quiet before this classifier is observed.
+ *
+ * @evidence contracts/common.md#principled-implementation Exact selection files and immediate resolution-directory entries choose execution reload; a strictly nested declared glob can explain its own ancestor's membership delta without exempting unrelated selection changes.
+ * @evidence contracts/common.md#clear-and-simple-design Exact-file membership, immediate-entry membership and causal explanations have distinct helpers under one classification operation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A data exemption must explain the same directory's observed delta, not cancel every reload because some unrelated data event occurred.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain caller admission, immediate-directory scope and strict glob exemptions with their reasons, following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation One filesystem identity transaction resolves both declared aliases and changed native paths, using actual case and link identity.
+ * @evidence contracts/performance.md#efficient-algorithms Setup resolves F reload files, D reload directories and G literal glob roots into call-local collections. Named events and C deltas scan directory/glob predicates; an unexplained directory delta can additionally scan A supplied causes and G exemptions for matching directory entries. Duplicate declarations remain present. Costs include native identity/ancestor/case queries and path/key text, not only predicate counts; classification itself does not hash file contents and no population/text bound is imposed here.
+ * @evidence contracts/performance.md#reuse-equivalent-work One transaction caches equivalent native identity/case resolutions for every helper in the same decision; a later event starts a fresh transaction so link retargets are observed.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Identity caches and predicate collections are local to one decision, without a resident historical cache or native handle.
+ */
+export declare function projectInputReloadEventShouldNotify(input: {
+    causedBy?: readonly string[];
+    changed?: string;
+    changedInputs: readonly string[];
+    reloadDirectories?: readonly string[];
+    reloadFiles: readonly string[];
+    globs?: readonly string[];
+}): boolean;

package/lib/launcher/internal/watch/projectInputReloadEventShouldNotify.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectInputReloadEventShouldNotify = projectInputReloadEventShouldNotify;
+const node_path_1 = __importDefault(require("node:path"));
+const createProjectInputPathIdentityContext_1 = require("../../../internal/pathIdentity/createProjectInputPathIdentityContext");
+const literalGlobRoot_1 = require("./literalGlobRoot");
+/**
+ * Classify an exact execution-selection input ahead of ordinary project data.
+ *
+ * `changedInputs` carries fingerprint or membership deltas, so a filename-less
+ * event can still select the cold lane. A named exact event selects the cold
+ * lane only after the surrounding change detector admits the event; unchanged
+ * bytes remain quiet before this classifier is observed.
+ *
+ * @evidence contracts/common.md#principled-implementation Exact selection files and immediate resolution-directory entries choose execution reload; a strictly nested declared glob can explain its own ancestor's membership delta without exempting unrelated selection changes.
+ * @evidence contracts/common.md#clear-and-simple-design Exact-file membership, immediate-entry membership and causal explanations have distinct helpers under one classification operation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A data exemption must explain the same directory's observed delta, not cancel every reload because some unrelated data event occurred.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain caller admission, immediate-directory scope and strict glob exemptions with their reasons, following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation One filesystem identity transaction resolves both declared aliases and changed native paths, using actual case and link identity.
+ * @evidence contracts/performance.md#efficient-algorithms Setup resolves F reload files, D reload directories and G literal glob roots into call-local collections. Named events and C deltas scan directory/glob predicates; an unexplained directory delta can additionally scan A supplied causes and G exemptions for matching directory entries. Duplicate declarations remain present. Costs include native identity/ancestor/case queries and path/key text, not only predicate counts; classification itself does not hash file contents and no population/text bound is imposed here.
+ * @evidence contracts/performance.md#reuse-equivalent-work One transaction caches equivalent native identity/case resolutions for every helper in the same decision; a later event starts a fresh transaction so link retargets are observed.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Identity caches and predicate collections are local to one decision, without a resident historical cache or native handle.
+ */
+function projectInputReloadEventShouldNotify(input) {
+    const identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)();
+    const reloadFiles = new Set(input.reloadFiles.map((location) => identities.resolve(location).key));
+    const reloadDirectories = (input.reloadDirectories ?? []).map((location) => identities.resolve(location));
+    // Territory a declared glob is rooted at, judged against the resolution
+    // directory that would otherwise claim it. A project root is published as a
+    // resolution directory because the config lives there, so the directory a
+    // glob is rooted at reads as a new immediate entry the moment it appears --
+    // and appearing is what a declared population does. The data lane already
+    // reports it, with program invalidation when the membership moved, which is
+    // the cold-Program-same-process transition that belongs to data.
+    //
+    // Data can only carve out strictly below a resolution directory. A glob
+    // rooted on that directory, or above it -- `literalGlobRoot` answers with the
+    // volume root when a wildcard follows that resolved root directly -- would
+    // otherwise exempt
+    // everything the directory exists to classify, and the selection lane would
+    // retire in silence. Its role predates any glob drawn around it.
+    //
+    // Only glob roots, either way. A declared file sitting directly in a
+    // resolution directory is still a selection surface: its own bytes are what a
+    // project rule reads to decide, once per execution.
+    const globRoots = (input.globs ?? []).map((glob) => identities.resolve((0, literalGlobRoot_1.literalGlobRoot)(glob)));
+    const exemptedFrom = (directory, location) => globRoots.some((globRoot) => globRoot.key !== directory.key &&
+        identities.isWithin(directory.path, globRoot.path) &&
+        identities.isWithin(globRoot.path, location));
+    // A reload directory is a non-recursive surface: its digest covers its
+    // immediate entries' names, kinds, and link targets, so it moves only when the
+    // directory itself moves or when an entry it holds directly does. Matching the
+    // whole subtree instead makes a resolution ancestor -- the lint config graph
+    // publishes every node_modules level it searched, up to the filesystem root --
+    // read every edit beneath it as a selection change, which restarts the sidecar
+    // on each keystroke and ends warm reuse for any project inside one.
+    const holdsAsImmediateEntry = (location) => {
+        const parent = identities.resolve(node_path_1.default.dirname(location)).key;
+        return reloadDirectories.some((directory) => directory.key === parent && exemptedFrom(directory, location) === false);
+    };
+    const namesDirectory = (location) => {
+        const key = identities.resolve(location).key;
+        return reloadDirectories.some((directory) => directory.key === key);
+    };
+    // A digest delta on the directory itself is the only signal there is when the
+    // entry that appeared is not a declared match, so it cannot simply be dropped
+    // -- but it also cannot say what appeared. The event being classified in the
+    // same pass can: when it names data, the delta it caused is that data's, and
+    // when it names anything else, or nothing at all, the safe reading is that
+    // resolution moved. A missed reselection is a wrong answer; a spare restart is
+    // a slow one.
+    const explains = (directory) => {
+        const causes = input.causedBy ?? (input.changed === undefined ? [] : [input.changed]);
+        // Only an immediate entry can move this directory's digest, so only an
+        // immediate entry can account for the delta. Asking whether the event was
+        // data somewhere else answers a different directory's question, and one
+        // exemption would then cancel every other directory's evidence.
+        return causes.some((location) => {
+            const parent = identities.resolve(node_path_1.default.dirname(location)).key;
+            return parent === directory.key && exemptedFrom(directory, location);
+        });
+    };
+    const isReloadDirectoryEvent = (location) => namesDirectory(location) || holdsAsImmediateEntry(location);
+    const isReloadDirectoryDelta = (location) => {
+        if (holdsAsImmediateEntry(location))
+            return true;
+        const key = identities.resolve(location).key;
+        return reloadDirectories.some((directory) => directory.key === key && explains(directory) === false);
+    };
+    return ((input.changed !== undefined &&
+        (reloadFiles.has(identities.resolve(input.changed).key) ||
+            isReloadDirectoryEvent(input.changed))) ||
+        input.changedInputs.some((location) => reloadFiles.has(identities.resolve(location).key) ||
+            isReloadDirectoryDelta(location)));
+}
+//# sourceMappingURL=projectInputReloadEventShouldNotify.js.map

package/lib/launcher/internal/watch/projectInputReloadEventShouldNotify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectInputReloadEventShouldNotify.js","sourceRoot":"","sources":["../../../../src/launcher/internal/watch/projectInputReloadEventShouldNotify.ts"],"names":[],"mappings":"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"}

package/lib/launcher/internal/watch/projectInputReplacementStrandsWatchers.d.ts

@@ -0,0 +1,37 @@
+import type { ITtscProjectInputSnapshot } from "../../../structures/internal/ITtscProjectInputSnapshot";
+/**
+ * Select a directory attention that requests recursive watcher reinstallation.
+ *
+ * Node 22.15.0's `lib/fs.js` routes recursive watches to
+ * `lib/internal/fs/recursive_watch.js` outside macOS and Windows. That
+ * implementation records paths and skips an already registered path, motivating
+ * this policy's rearm selection on those hosts. The predicate returns false for
+ * macOS and Windows; that selection does not prove native subtree delivery
+ * after replacement or that those backends follow every replaced path.
+ *
+ * On the selected backend, the supplied path must currently stat as a directory
+ * and its parent must anchor at least one declared file, reload file, strict
+ * reload-directory descendant or literal glob root. This is an attention
+ * policy, not detection that an object was replaced. Restricting reinstallation
+ * avoids repeatedly rebuilding a recursive entry population on unrelated
+ * changes. Reload-directory membership alone anchors its parent rather than
+ * itself; another declaration can still anchor that same path. The topology
+ * caller owns retiring and synchronizing watchers before its next snapshot;
+ * this predicate starts or closes no watcher and does not certify the resulting
+ * coverage.
+ *
+ * @param identities Identity transaction; absence creates a native host
+ *   context.
+ * @param platform Backend selection only; paths still use the host's path API
+ *   and the supplied identity context, not this argument's foreign path
+ *   grammar.
+ * @evidence contracts/common.md#principled-implementation The supported selection policy requests rearming only outside macOS/Windows for an existing directory whose parent anchors a declaration; its boolean is not proof of replacement or native event delivery.
+ * @evidence contracts/common.md#clear-and-simple-design A backend capability branch precedes directory and declaration checks, separating rescan admission from handle reinstallation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Node's path-indexed registration supplies the rearm premise; actual directory/declaration observations select attention without test identities or an invented proof that native subtree backends always recover replacements.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain native versus per-directory backends and why indiscriminate reinstalling is costly, following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Platform selection expresses Node's recursive watcher implementation boundary; filesystem identity and containment still come from the actual transaction resolver.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate starts or retains no watcher. A supplied identity context remains caller-owned; the default creates invocation-local observation maps without eviction, released only when their references are discarded.
+ * @evidence contracts/performance.md#efficient-algorithms Default context allocation occurs before the platform return. Selected hosts resolve/stat one changed path and short-circuit over files, reload declarations and glob roots; each containment query can perform delegated identity/path/native work. No declared corpus enumeration or watcher installation occurs in this predicate, and text/declaration/query populations are not capped here.
+ * @evidence contracts/performance.md#reuse-equivalent-work The topology caller supplies one identity transaction across attention and declaration checks, reusing per-key observations within that native state. Standalone default calls create fresh contexts; this predicate neither shares across transactions nor caches replacement verdicts.
+ */
+export declare function projectInputReplacementStrandsWatchers(snapshot: ITtscProjectInputSnapshot, location: string, identities?: import("../../../internal/projectInputPathIdentity").FilesystemPathIdentityContext, platform?: NodeJS.Platform): boolean;

package/lib/launcher/internal/watch/projectInputReplacementStrandsWatchers.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectInputReplacementStrandsWatchers = projectInputReplacementStrandsWatchers;
+const node_path_1 = __importDefault(require("node:path"));
+const createProjectInputPathIdentityContext_1 = require("../../../internal/pathIdentity/createProjectInputPathIdentityContext");
+const ProjectInputWatchRules_1 = require("./ProjectInputWatchRules");
+const WatchPaths_1 = require("./WatchPaths");
+/**
+ * Select a directory attention that requests recursive watcher reinstallation.
+ *
+ * Node 22.15.0's `lib/fs.js` routes recursive watches to
+ * `lib/internal/fs/recursive_watch.js` outside macOS and Windows. That
+ * implementation records paths and skips an already registered path, motivating
+ * this policy's rearm selection on those hosts. The predicate returns false for
+ * macOS and Windows; that selection does not prove native subtree delivery
+ * after replacement or that those backends follow every replaced path.
+ *
+ * On the selected backend, the supplied path must currently stat as a directory
+ * and its parent must anchor at least one declared file, reload file, strict
+ * reload-directory descendant or literal glob root. This is an attention
+ * policy, not detection that an object was replaced. Restricting reinstallation
+ * avoids repeatedly rebuilding a recursive entry population on unrelated
+ * changes. Reload-directory membership alone anchors its parent rather than
+ * itself; another declaration can still anchor that same path. The topology
+ * caller owns retiring and synchronizing watchers before its next snapshot;
+ * this predicate starts or closes no watcher and does not certify the resulting
+ * coverage.
+ *
+ * @param identities Identity transaction; absence creates a native host
+ *   context.
+ * @param platform Backend selection only; paths still use the host's path API
+ *   and the supplied identity context, not this argument's foreign path
+ *   grammar.
+ * @evidence contracts/common.md#principled-implementation The supported selection policy requests rearming only outside macOS/Windows for an existing directory whose parent anchors a declaration; its boolean is not proof of replacement or native event delivery.
+ * @evidence contracts/common.md#clear-and-simple-design A backend capability branch precedes directory and declaration checks, separating rescan admission from handle reinstallation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Node's path-indexed registration supplies the rearm premise; actual directory/declaration observations select attention without test identities or an invented proof that native subtree backends always recover replacements.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain native versus per-directory backends and why indiscriminate reinstalling is costly, following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Platform selection expresses Node's recursive watcher implementation boundary; filesystem identity and containment still come from the actual transaction resolver.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate starts or retains no watcher. A supplied identity context remains caller-owned; the default creates invocation-local observation maps without eviction, released only when their references are discarded.
+ * @evidence contracts/performance.md#efficient-algorithms Default context allocation occurs before the platform return. Selected hosts resolve/stat one changed path and short-circuit over files, reload declarations and glob roots; each containment query can perform delegated identity/path/native work. No declared corpus enumeration or watcher installation occurs in this predicate, and text/declaration/query populations are not capped here.
+ * @evidence contracts/performance.md#reuse-equivalent-work The topology caller supplies one identity transaction across attention and declaration checks, reusing per-key observations within that native state. Standalone default calls create fresh contexts; this predicate neither shares across transactions nor caches replacement verdicts.
+ */
+function projectInputReplacementStrandsWatchers(snapshot, location, identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)(), platform = process.platform) {
+    if (platform === "darwin" || platform === "win32")
+        return false;
+    const changed = node_path_1.default.resolve(location);
+    if (!WatchPaths_1.WatchPaths.isDirectory(changed))
+        return false;
+    return ProjectInputWatchRules_1.ProjectInputWatchRules.projectInputAnchorsDeclaration(snapshot, node_path_1.default.dirname(changed), identities);
+}
+//# sourceMappingURL=projectInputReplacementStrandsWatchers.js.map

package/lib/launcher/internal/watch/projectInputReplacementStrandsWatchers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectInputReplacementStrandsWatchers.js","sourceRoot":"","sources":["../../../../src/launcher/internal/watch/projectInputReplacementStrandsWatchers.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAE7B,gIAA6H;AAE7H,qEAAkE;AAClE,6CAA0C;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,gDACE,QAAmC,EACnC,QAAgB,EAChB,UAAU,GAAG,IAAA,6EAAqC,GAAE,EACpD,QAAQ,GAAoB,OAAO,CAAC,QAAQ;IAE5C,IAAI,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,OAAO;QAAE,OAAO,KAAK,CAAC;IAChE,MAAM,OAAO,GAAG,mBAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACvC,IAAI,CAAC,uBAAU,CAAC,WAAW,CAAC,OAAO,CAAC;QAAE,OAAO,KAAK,CAAC;IACnD,OAAO,+CAAsB,CAAC,8BAA8B,CAC1D,QAAQ,EACR,mBAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EACrB,UAAU,CACX,CAAC;AACJ,CAAC"}

package/lib/launcher/internal/watch/projectInputTopologyMayAffect.d.ts

@@ -0,0 +1,23 @@
+import type { ITtscProjectInputSnapshot } from "../../../structures/internal/ITtscProjectInputSnapshot";
+/**
+ * Decide whether an event that named no declared input can still have moved
+ * one.
+ *
+ * The admitted set narrows which named events lead a watch session to re-read
+ * and re-hash its declared corpus, and both directions cost: too narrow drops
+ * an atomic replacement, too wide re-fingerprints on every entry an install
+ * creates. Exported so that boundary is pinned directly instead of being
+ * inferred from a rebuild that a silent rescan and a skipped rescan produce
+ * identically.
+ *
+ * @evidence contracts/common.md#principled-implementation Declaration ancestry, reload territories and admitted glob trees decide whether an unnamed input may have moved, covering replacement events named after an arriving sibling.
+ * @evidence contracts/common.md#clear-and-simple-design A shared declaration-anchor predicate separates replacement ancestry from reload and glob admission.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Admission follows published declarations rather than hardcoded node_modules exclusion or unconditional whole-project rescanning.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lost replacements and unnecessary corpus scans with their reasons, following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path operations and transaction-owned physical containment qualify event paths and glob roots with actual case semantics.
+ * @evidence contracts/performance.md#efficient-algorithms Up to two anchor checks visit file/reload/glob declarations before reload-directory and G glob branches; each glob can scan P borrowed previous members. Native directory stat and delegated identity/ancestor/case observations plus literal-root/path/key text are additional costs. Short-circuiting can stop earlier; populations/text are uncapped and this predicate does not read or hash corpus contents.
+ * @evidence contracts/performance.md#reuse-equivalent-work The caller can share one identity transaction with event matching and later classification; repeated resolutions within this decision use that transaction's cache.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No watcher, historical event population or resident cache is acquired by this admission predicate.
+ */
+export declare function projectInputTopologyMayAffect(snapshot: ITtscProjectInputSnapshot, location: string, previous: ReadonlyMap<string, string>, identities?: import("../../../internal/projectInputPathIdentity").FilesystemPathIdentityContext): boolean;

package/lib/launcher/internal/watch/projectInputTopologyMayAffect.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectInputTopologyMayAffect = projectInputTopologyMayAffect;
+const node_path_1 = __importDefault(require("node:path"));
+const createProjectInputPathIdentityContext_1 = require("../../../internal/pathIdentity/createProjectInputPathIdentityContext");
+const ProjectInputWatchRules_1 = require("./ProjectInputWatchRules");
+const WatchPaths_1 = require("./WatchPaths");
+const literalGlobRoot_1 = require("./literalGlobRoot");
+/**
+ * Decide whether an event that named no declared input can still have moved
+ * one.
+ *
+ * The admitted set narrows which named events lead a watch session to re-read
+ * and re-hash its declared corpus, and both directions cost: too narrow drops
+ * an atomic replacement, too wide re-fingerprints on every entry an install
+ * creates. Exported so that boundary is pinned directly instead of being
+ * inferred from a rebuild that a silent rescan and a skipped rescan produce
+ * identically.
+ *
+ * @evidence contracts/common.md#principled-implementation Declaration ancestry, reload territories and admitted glob trees decide whether an unnamed input may have moved, covering replacement events named after an arriving sibling.
+ * @evidence contracts/common.md#clear-and-simple-design A shared declaration-anchor predicate separates replacement ancestry from reload and glob admission.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Admission follows published declarations rather than hardcoded node_modules exclusion or unconditional whole-project rescanning.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lost replacements and unnecessary corpus scans with their reasons, following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path operations and transaction-owned physical containment qualify event paths and glob roots with actual case semantics.
+ * @evidence contracts/performance.md#efficient-algorithms Up to two anchor checks visit file/reload/glob declarations before reload-directory and G glob branches; each glob can scan P borrowed previous members. Native directory stat and delegated identity/ancestor/case observations plus literal-root/path/key text are additional costs. Short-circuiting can stop earlier; populations/text are uncapped and this predicate does not read or hash corpus contents.
+ * @evidence contracts/performance.md#reuse-equivalent-work The caller can share one identity transaction with event matching and later classification; repeated resolutions within this decision use that transaction's cache.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No watcher, historical event population or resident cache is acquired by this admission predicate.
+ */
+function projectInputTopologyMayAffect(snapshot, location, previous, identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)()) {
+    const changed = node_path_1.default.resolve(location);
+    const anchors = (directory) => ProjectInputWatchRules_1.ProjectInputWatchRules.projectInputAnchorsDeclaration(snapshot, directory, identities);
+    // An atomic replacement can name an ancestor or arriving sibling rather than
+    // the declared file whose bytes moved. That directory can be one the
+    // declaration does not contain: renaming `docs` away can report the arriving
+    // `docs-old`, not `docs`. So a directory event is admitted from where it
+    // happened rather than from what it contains: its own parent must already lie
+    // on the path to a declared input. A tree no declaration reaches, such as
+    // `node_modules` under an ordinary project, avoids corpus rescanning for each
+    // created entry while still paying this admission predicate cost. A
+    // glob whose literal root covers that tree still admits every directory
+    // beneath it through the branch below, because a directory appearing inside a
+    // glob root can hold matches; the declaration decides that reach, not this
+    // rule.
+    if (WatchPaths_1.WatchPaths.isDirectory(changed) && anchors(node_path_1.default.dirname(changed)))
+        return true;
+    return (anchors(changed) ||
+        (snapshot.reloadDirectories ?? []).some((directory) => identities.isWithin(directory, changed)) ||
+        snapshot.globs.some((glob) => {
+            const root = (0, literalGlobRoot_1.literalGlobRoot)(glob);
+            if (identities.isWithin(changed, root))
+                return true;
+            if (identities.isWithin(root, changed) === false)
+                return false;
+            if (WatchPaths_1.WatchPaths.isDirectory(changed))
+                return true;
+            for (const input of previous.values()) {
+                if (identities.isWithin(changed, input))
+                    return true;
+            }
+            return false;
+        }));
+}
+//# sourceMappingURL=projectInputTopologyMayAffect.js.map

package/lib/launcher/internal/watch/projectInputTopologyMayAffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectInputTopologyMayAffect.js","sourceRoot":"","sources":["../../../../src/launcher/internal/watch/projectInputTopologyMayAffect.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAE7B,gIAA6H;AAE7H,qEAAkE;AAClE,6CAA0C;AAC1C,uDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uCACE,QAAmC,EACnC,QAAgB,EAChB,QAAqC,EACrC,UAAU,GAAG,IAAA,6EAAqC,GAAE;IAEpD,MAAM,OAAO,GAAG,mBAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACvC,MAAM,OAAO,GAAG,CAAC,SAAiB,EAAW,EAAE,CAC7C,+CAAsB,CAAC,8BAA8B,CACnD,QAAQ,EACR,SAAS,EACT,UAAU,CACX,CAAC;IACJ,6EAA6E;IAC7E,qEAAqE;IACrE,6EAA6E;IAC7E,yEAAyE;IACzE,8EAA8E;IAC9E,0EAA0E;IAC1E,8EAA8E;IAC9E,oEAAoE;IACpE,wEAAwE;IACxE,8EAA8E;IAC9E,2EAA2E;IAC3E,QAAQ;IACR,IAAI,uBAAU,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,mBAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACnE,OAAO,IAAI,CAAC;IACd,OAAO,CACL,OAAO,CAAC,OAAO,CAAC;QAChB,CAAC,QAAQ,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CACpD,UAAU,CAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,CACxC;QACD,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;YAC3B,MAAM,IAAI,GAAG,IAAA,iCAAe,EAAC,IAAI,CAAC,CAAC;YACnC,IAAI,UAAU,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;gBAAE,OAAO,IAAI,CAAC;YACpD,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,KAAK;gBAAE,OAAO,KAAK,CAAC;YAC/D,IAAI,uBAAU,CAAC,WAAW,CAAC,OAAO,CAAC;gBAAE,OAAO,IAAI,CAAC;YACjD,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;gBACtC,IAAI,UAAU,CAAC,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;oBAAE,OAAO,IAAI,CAAC;YACvD,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,CACH,CAAC;AACJ,CAAC"}

package/lib/launcher/internal/watch/projectInputWatchDirectories.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Return the selected zero-or-one recursive root for a project-input
+ * declaration.
+ *
+ * The shared selector uses the project's nearest existing ancestry for internal
+ * inputs. External inputs prefer the declared parent's existing ancestry, then
+ * the target's own, excluding strict ancestors of the project but admitting
+ * equal physical identity. An unavailable selected root becomes an empty list.
+ * This adapter neither installs a watch nor proves delivery after replacement;
+ * the topology caller owns observation and reporting of uncovered
+ * declarations.
+ *
+ * @evidence contracts/common.md#principled-implementation The shared selector preserves the internal-root and external strict-ancestor selection policy; an unavailable owner remains an empty result rather than proof of watch coverage.
+ * @evidence contracts/common.md#clear-and-simple-design One delegation converts the optional owner into the caller's zero-or-one root list.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No second fallback broadens an absent safe owner into a system-wide watch.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish current root selection, equal versus strict ancestry and caller-owned native observation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The delegated selector owns native ancestry and actual physical containment instead of caller-side separator or OS-case assumptions.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The adapter returns a caller-owned list of at most one spelling and starts no watcher or retained observer. The selector's default identity maps are invocation-local; their query population is not bounded by this small result.
+ * @evidence contracts/performance.md#efficient-algorithms The zero-or-one list conversion is fixed-width, but its delegated selector performs identity/path work and one internal or two external native ancestor-stat searches, including possible case queries. No descendant corpus is enumerated and declaration path depth/text is not capped here.
+ * @evidence contracts/performance.md#reuse-equivalent-work The delegated selector shares its new context's per-key observations within one selection. Each adapter invocation creates a fresh context, so repeated declarations may repeat native observations; this adapter coordinates no cross-invocation answer reuse or watcher ownership.
+ */
+export declare function projectInputWatchDirectories(target: string, projectRoot: string): string[];

package/lib/launcher/internal/watch/projectInputWatchDirectories.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectInputWatchDirectories = projectInputWatchDirectories;
+const ProjectInputWatchRules_1 = require("./ProjectInputWatchRules");
+/**
+ * Return the selected zero-or-one recursive root for a project-input
+ * declaration.
+ *
+ * The shared selector uses the project's nearest existing ancestry for internal
+ * inputs. External inputs prefer the declared parent's existing ancestry, then
+ * the target's own, excluding strict ancestors of the project but admitting
+ * equal physical identity. An unavailable selected root becomes an empty list.
+ * This adapter neither installs a watch nor proves delivery after replacement;
+ * the topology caller owns observation and reporting of uncovered
+ * declarations.
+ *
+ * @evidence contracts/common.md#principled-implementation The shared selector preserves the internal-root and external strict-ancestor selection policy; an unavailable owner remains an empty result rather than proof of watch coverage.
+ * @evidence contracts/common.md#clear-and-simple-design One delegation converts the optional owner into the caller's zero-or-one root list.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No second fallback broadens an absent safe owner into a system-wide watch.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish current root selection, equal versus strict ancestry and caller-owned native observation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The delegated selector owns native ancestry and actual physical containment instead of caller-side separator or OS-case assumptions.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The adapter returns a caller-owned list of at most one spelling and starts no watcher or retained observer. The selector's default identity maps are invocation-local; their query population is not bounded by this small result.
+ * @evidence contracts/performance.md#efficient-algorithms The zero-or-one list conversion is fixed-width, but its delegated selector performs identity/path work and one internal or two external native ancestor-stat searches, including possible case queries. No descendant corpus is enumerated and declaration path depth/text is not capped here.
+ * @evidence contracts/performance.md#reuse-equivalent-work The delegated selector shares its new context's per-key observations within one selection. Each adapter invocation creates a fresh context, so repeated declarations may repeat native observations; this adapter coordinates no cross-invocation answer reuse or watcher ownership.
+ */
+function projectInputWatchDirectories(target, projectRoot) {
+    const root = ProjectInputWatchRules_1.ProjectInputWatchRules.projectInputRecursiveWatchRoot(target, projectRoot);
+    return root === undefined ? [] : [root];
+}
+//# sourceMappingURL=projectInputWatchDirectories.js.map

package/lib/launcher/internal/watch/projectInputWatchDirectories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectInputWatchDirectories.js","sourceRoot":"","sources":["../../../../src/launcher/internal/watch/projectInputWatchDirectories.ts"],"names":[],"mappings":";;;AAAA,qEAAkE;AAElE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCACE,MAAc,EACd,WAAmB;IAEnB,MAAM,IAAI,GAAG,+CAAsB,CAAC,8BAA8B,CAChE,MAAM,EACN,WAAW,CACZ,CAAC;IACF,OAAO,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAC1C,CAAC"}

package/lib/launcher/internal/watch/reloadInputsForFailedTopologyRefresh.d.ts

@@ -0,0 +1,22 @@
+import type { ProjectInputPathIdentityContext } from "../../../internal/pathIdentity/ProjectInputPathIdentityContext";
+/**
+ * Declared reload inputs selected after a topology refresh failed: members
+ * conservatively matching the supplied change and members whose native
+ * existence check is false. An unrelated triggering path is not added. The
+ * topology owner consumes these paths to request recovery; this selector
+ * installs no watcher and does not prove future event delivery.
+ *
+ * The supplied identity transaction shares native case observations with the
+ * failed reconciliation; omitting it starts fresh observations for this pass.
+ *
+ * @evidence contracts/common.md#principled-implementation A changed declared reload member and declarations not admitted by the native existence check remain recovery candidates without inventing an unrelated reload input or proving native absence.
+ * @evidence contracts/common.md#clear-and-simple-design One keyed collection deduplicates selected recovery paths before deterministic sorting.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failure does not fabricate a healthy compiler population or drop missing selection inputs.
+ * @evidence contracts/common.md#meaningful-documentation Native prose specifies the recovery population and recreation purpose following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native paths and existence queries preserve host grammar; measured component keys retain sensitive and unknown names, while conservative event matching can retry an unproven case alias without merging stored reload members.
+ * @evidence contracts/performance.md#efficient-algorithms N declared members each resolve path spelling and delegated lexical keys; conditional event matching can add identity/case/ancestor queries before an optional native existence check. R selected paths require indexed deduplication and comparison sorting, including text lengths. Native query populations/text and N/R are uncapped here; no descendant corpus is scanned.
+ * @evidence contracts/performance.md#reuse-equivalent-work One supplied or invocation-local transaction shares repeated native case observations across recovery keys and event matching; later recovery work obtains fresh native state.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The source iterable and transaction are borrowed; the returned local recovery population acquires no watcher or retained historical cache.
+ */
+export declare function reloadInputsForFailedTopologyRefresh(reloadFiles: Iterable<string>, changed?: string, identities?: ProjectInputPathIdentityContext): string[];

package/lib/launcher/internal/watch/reloadInputsForFailedTopologyRefresh.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reloadInputsForFailedTopologyRefresh = reloadInputsForFailedTopologyRefresh;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const createProjectInputPathIdentityContext_1 = require("../../../internal/pathIdentity/createProjectInputPathIdentityContext");
+const WatchPaths_1 = require("./WatchPaths");
+/**
+ * Declared reload inputs selected after a topology refresh failed: members
+ * conservatively matching the supplied change and members whose native
+ * existence check is false. An unrelated triggering path is not added. The
+ * topology owner consumes these paths to request recovery; this selector
+ * installs no watcher and does not prove future event delivery.
+ *
+ * The supplied identity transaction shares native case observations with the
+ * failed reconciliation; omitting it starts fresh observations for this pass.
+ *
+ * @evidence contracts/common.md#principled-implementation A changed declared reload member and declarations not admitted by the native existence check remain recovery candidates without inventing an unrelated reload input or proving native absence.
+ * @evidence contracts/common.md#clear-and-simple-design One keyed collection deduplicates selected recovery paths before deterministic sorting.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failure does not fabricate a healthy compiler population or drop missing selection inputs.
+ * @evidence contracts/common.md#meaningful-documentation Native prose specifies the recovery population and recreation purpose following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native paths and existence queries preserve host grammar; measured component keys retain sensitive and unknown names, while conservative event matching can retry an unproven case alias without merging stored reload members.
+ * @evidence contracts/performance.md#efficient-algorithms N declared members each resolve path spelling and delegated lexical keys; conditional event matching can add identity/case/ancestor queries before an optional native existence check. R selected paths require indexed deduplication and comparison sorting, including text lengths. Native query populations/text and N/R are uncapped here; no descendant corpus is scanned.
+ * @evidence contracts/performance.md#reuse-equivalent-work One supplied or invocation-local transaction shares repeated native case observations across recovery keys and event matching; later recovery work obtains fresh native state.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The source iterable and transaction are borrowed; the returned local recovery population acquires no watcher or retained historical cache.
+ */
+function reloadInputsForFailedTopologyRefresh(reloadFiles, changed, identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)({
+    throwOnRealpathError: false,
+})) {
+    const reloads = new Map();
+    for (const location of reloadFiles) {
+        const resolved = node_path_1.default.resolve(location);
+        const key = WatchPaths_1.WatchPaths.pathKey(resolved, identities);
+        if ((changed !== undefined && identities.lexicalMatches(changed, resolved)) ||
+            node_fs_1.default.existsSync(resolved) === false) {
+            reloads.set(key, resolved);
+        }
+    }
+    return [...reloads.values()].sort();
+}
+//# sourceMappingURL=reloadInputsForFailedTopologyRefresh.js.map

package/lib/launcher/internal/watch/reloadInputsForFailedTopologyRefresh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reloadInputsForFailedTopologyRefresh.js","sourceRoot":"","sources":["../../../../src/launcher/internal/watch/reloadInputsForFailedTopologyRefresh.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AACzB,0DAA6B;AAG7B,gIAA6H;AAC7H,6CAA0C;AAE1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8CACE,WAA6B,EAC7B,OAAgB,EAChB,UAAU,GAAoC,IAAA,6EAAqC,EACjF;IACE,oBAAoB,EAAE,KAAK;CAC5B,CACF;IAED,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC1C,KAAK,MAAM,QAAQ,IAAI,WAAW,EAAE,CAAC;QACnC,MAAM,QAAQ,GAAG,mBAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACxC,MAAM,GAAG,GAAG,uBAAU,CAAC,OAAO,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QACrD,IACE,CAAC,OAAO,KAAK,SAAS,IAAI,UAAU,CAAC,cAAc,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YACvE,iBAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,KAAK,EACjC,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IACD,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;AACtC,CAAC"}

package/lib/launcher/internal/watch/syncWatchers.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Reconcile the live watchers with the desired set, transactionally.
+ *
+ * Missing watchers are created first. Only when every desired watcher exists
+ * are the ones no longer desired closed, so a failed or interrupted creation
+ * retains the previously live watcher map. This ordering alone does not prove
+ * native coverage during backend failure. A watcher that later errors removes
+ * itself and reports through `onError`.
+ *
+ * @returns `false` when a creation failed or `shouldContinue` stopped the pass.
+ * @evidence contracts/common.md#principled-implementation New coverage is admitted before obsolete watchers are retired, so a failed creation leaves the previously live observation set intact.
+ * @evidence contracts/common.md#clear-and-simple-design Creation and retirement are two explicit passes; one captured watcher identity qualifies later error removal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed creation is reported instead of replacing the missing watcher with a fake success or discarding old coverage.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain transaction order, late failure and interruption following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native watcher construction is injected through one supported boundary while the shared reconciler preserves its error and close semantics.
+ * @evidence contracts/performance.md#efficient-algorithms One desired-map pass and, if complete, one live-map pass inspect D desired and L live entries. Indexed key text, shouldContinue, create, error subscription and close callbacks contribute their own costs, including delegated native observation/lifecycle work. Partial creation stops retirement; D/L and key text are uncapped here.
+ * @evidence contracts/performance.md#reuse-equivalent-work A still-live watcher under the same desired key is reused; changed desired membership creates replacement coverage before retiring old keys.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The caller owns the live map and handles. Obsolete and failed watchers receive close attempts, while partial creation retains old entries until later reconciliation or shutdown. Backend close/callback failures can propagate; map ownership does not certify native release or uninterrupted event coverage.
+ */
+export declare function syncWatchers<T extends SynchronizedWatcher>(watchers: Map<string, T>, desired: ReadonlyMap<string, string>, create: (location: string, key: string) => T, onError: (location: string, error: unknown) => void, shouldContinue?: () => boolean): boolean;
+type SynchronizedWatcher = {
+    close(): void;
+    on(event: "error", listener: (error: Error) => void): unknown;
+};
+export {};