ttsc 0.30.3 → 0.31.0

package/lib/compiler/internal/build/PassthroughFlags.js.map

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

package/lib/compiler/internal/build/PluginFailureDiagnostics.d.ts

@@ -0,0 +1,48 @@
+import type { TtscBuildResult } from "../../../structures/internal/TtscBuildResult";
+import type { RunBuildOptions } from "./RunBuildOptions";
+/**
+ * Select and merge the independent diagnostic recovery after a plugin failure.
+ * The build engine still owns the native check and report filtering. These
+ * supplied results do not establish how either producer acquired its output.
+ *
+ * @evidence contracts/common.md#principled-implementation Mode exclusions and original failure ownership remain distinct from native execution and report deduplication.
+ * @evidence contracts/common.md#clear-and-simple-design One concern groups the recovery gate and final merge used by the actual build engine.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The namespace supplies no executor or synthetic producer and never turns recovery into a successful plugin build.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes policy inputs from producer execution and acquisition.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This grouping performs no native path, filesystem or process operation.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms Members own policy composition; the namespace selects no algorithm.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This namespace owns no computed-result cache.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This grouping holds no runtime registry, handle or task.
+ */
+export declare namespace PluginFailureDiagnostics {
+    /**
+     * Permit the independent check unless the selected mode omits diagnostics.
+     * Failure admission belongs to the caller; this gate neither changes status
+     * nor classifies a successful producer as failed.
+     *
+     * @evidence contracts/common.md#principled-implementation Exact true format/skip controls and the existing forwarded terminal selector preserve the build engine's recovery exclusions.
+     * @evidence contracts/common.md#clear-and-simple-design One predicate owns the mode gate while the caller retains execution and exception ordering.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Supplied options use the real terminal flag policy, without a fake compiler or test-only execution callback.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states the caller's failure premise and this predicate's diagnostic-mode responsibility.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Supplied option values and forwarded argument semantics are inspected without native paths, filesystem or process calls.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms This gate composes scalar checks and the existing terminal selector; argument interpretation belongs to that selector.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Current supplied options are evaluated directly, without caching or cross-call reuse.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This predicate retains no option population, handle or task.
+     */
+    function shouldCollect(options: RunBuildOptions): boolean;
+    /**
+     * Keep the original failure when no new diagnostic batch remains. Otherwise
+     * seed its unparsed process failure before the recovered reports and retain
+     * its status, even if the independent check returned another status.
+     *
+     * @evidence contracts/common.md#principled-implementation A null filtered batch preserves failure identity; an empty original diagnostic list receives the shared process diagnostic before phase merging, and the original status replaces the merged status.
+     * @evidence contracts/common.md#clear-and-simple-design Seeding, delegated output merge and status restoration form one result adaptation, separate from native execution and filtering.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Reports come from supplied producer results; process seeding exposes the original failure rather than inventing a successful compiler response.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes null-batch identity from seeded merging and states status ownership.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Supplied result records and text are composed without resolving paths or invoking native filesystem/process APIs.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms This adapter delegates record/text/witness merging to appendBuildOutput and message selection to createProcessDiagnostic, without another traversal strategy.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The already filtered batch is consumed once; this adapter owns no producer capture or cross-request cache.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Constructed result records transfer to the caller; this adapter retains no historical population, native handle or task.
+     */
+    function append(failure: TtscBuildResult, fallback: TtscBuildResult | null): TtscBuildResult;
+}

package/lib/compiler/internal/build/PluginFailureDiagnostics.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginFailureDiagnostics = void 0;
+const PassthroughFlags_1 = require("./PassthroughFlags");
+const appendBuildOutput_1 = require("./appendBuildOutput");
+const createProcessDiagnostic_1 = require("./createProcessDiagnostic");
+/**
+ * Select and merge the independent diagnostic recovery after a plugin failure.
+ * The build engine still owns the native check and report filtering. These
+ * supplied results do not establish how either producer acquired its output.
+ *
+ * @evidence contracts/common.md#principled-implementation Mode exclusions and original failure ownership remain distinct from native execution and report deduplication.
+ * @evidence contracts/common.md#clear-and-simple-design One concern groups the recovery gate and final merge used by the actual build engine.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The namespace supplies no executor or synthetic producer and never turns recovery into a successful plugin build.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes policy inputs from producer execution and acquisition.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This grouping performs no native path, filesystem or process operation.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms Members own policy composition; the namespace selects no algorithm.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This namespace owns no computed-result cache.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This grouping holds no runtime registry, handle or task.
+ */
+var PluginFailureDiagnostics;
+(function (PluginFailureDiagnostics) {
+    /**
+     * Permit the independent check unless the selected mode omits diagnostics.
+     * Failure admission belongs to the caller; this gate neither changes status
+     * nor classifies a successful producer as failed.
+     *
+     * @evidence contracts/common.md#principled-implementation Exact true format/skip controls and the existing forwarded terminal selector preserve the build engine's recovery exclusions.
+     * @evidence contracts/common.md#clear-and-simple-design One predicate owns the mode gate while the caller retains execution and exception ordering.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Supplied options use the real terminal flag policy, without a fake compiler or test-only execution callback.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states the caller's failure premise and this predicate's diagnostic-mode responsibility.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Supplied option values and forwarded argument semantics are inspected without native paths, filesystem or process calls.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms This gate composes scalar checks and the existing terminal selector; argument interpretation belongs to that selector.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Current supplied options are evaluated directly, without caching or cross-call reuse.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This predicate retains no option population, handle or task.
+     */
+    function shouldCollect(options) {
+        return !(options.format === true ||
+            options.skipDiagnosticsCheck === true ||
+            PassthroughFlags_1.PassthroughFlags.forwardsTerminalTsgoFlag(options));
+    }
+    PluginFailureDiagnostics.shouldCollect = shouldCollect;
+    /**
+     * Keep the original failure when no new diagnostic batch remains. Otherwise
+     * seed its unparsed process failure before the recovered reports and retain
+     * its status, even if the independent check returned another status.
+     *
+     * @evidence contracts/common.md#principled-implementation A null filtered batch preserves failure identity; an empty original diagnostic list receives the shared process diagnostic before phase merging, and the original status replaces the merged status.
+     * @evidence contracts/common.md#clear-and-simple-design Seeding, delegated output merge and status restoration form one result adaptation, separate from native execution and filtering.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Reports come from supplied producer results; process seeding exposes the original failure rather than inventing a successful compiler response.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes null-batch identity from seeded merging and states status ownership.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Supplied result records and text are composed without resolving paths or invoking native filesystem/process APIs.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms This adapter delegates record/text/witness merging to appendBuildOutput and message selection to createProcessDiagnostic, without another traversal strategy.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The already filtered batch is consumed once; this adapter owns no producer capture or cross-request cache.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Constructed result records transfer to the caller; this adapter retains no historical population, native handle or task.
+     */
+    function append(failure, fallback) {
+        if (fallback === null)
+            return failure;
+        const seeded = failure.diagnostics.length === 0
+            ? { ...failure, diagnostics: [(0, createProcessDiagnostic_1.createProcessDiagnostic)(failure)] }
+            : failure;
+        const status = failure.status;
+        return { ...(0, appendBuildOutput_1.appendBuildOutput)(seeded, fallback), status };
+    }
+    PluginFailureDiagnostics.append = append;
+})(PluginFailureDiagnostics || (exports.PluginFailureDiagnostics = PluginFailureDiagnostics = {}));
+//# sourceMappingURL=PluginFailureDiagnostics.js.map

package/lib/compiler/internal/build/PluginFailureDiagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginFailureDiagnostics.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/PluginFailureDiagnostics.ts"],"names":[],"mappings":";;;AACA,yDAAsD;AAEtD,2DAAwD;AACxD,uEAAoE;AAEpE;;;;;;;;;;;;;GAaG;AACH,IAAiB,wBAAwB,CAiDxC;AAjDD,WAAiB,wBAAwB;IACvC;;;;;;;;;;;;;OAaG;IACH,SAAgB,aAAa,CAAC,OAAwB;QACpD,OAAO,CAAC,CACN,OAAO,CAAC,MAAM,KAAK,IAAI;YACvB,OAAO,CAAC,oBAAoB,KAAK,IAAI;YACrC,mCAAgB,CAAC,wBAAwB,CAAC,OAAO,CAAC,CACnD,CAAC;IACJ,CAAC;IANe,yBAAA,aAAa,gBAM5B,CAAA;IAED;;;;;;;;;;;;;OAaG;IACH,SAAgB,MAAM,CACpB,OAAwB,EACxB,QAAgC;QAEhC,IAAI,QAAQ,KAAK,IAAI;YAAE,OAAO,OAAO,CAAC;QACtC,MAAM,MAAM,GACV,OAAO,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC;YAC9B,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,WAAW,EAAE,CAAC,IAAA,iDAAuB,EAAC,OAAO,CAAC,CAAC,EAAE;YACjE,CAAC,CAAC,OAAO,CAAC;QACd,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC9B,OAAO,EAAE,GAAG,IAAA,qCAAiB,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5D,CAAC;IAXe,yBAAA,MAAM,SAWrB,CAAA;AACH,CAAC,EAjDgB,wBAAwB,aAAxB,wBAAwB,GAAxB,wBAAwB,QAiDxC"}

package/lib/compiler/internal/build/ResidentCheckEntryPlan.d.ts

@@ -0,0 +1,38 @@
+import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
+/**
+ * How one configured check-stage plugin entry runs during a watch cycle.
+ *
+ * Produced by {@link planResidentCheckEntries}. Entries with the same `key`
+ * share one resident sidecar; an entry without a key runs as an ordinary
+ * one-shot check every cycle.
+ *
+ * @evidence contracts/common.md#principled-implementation Separate entryIndex and optional process key represent configured delivery identity versus capability-dependent sidecar identity.
+ * @evidence contracts/common.md#clear-and-simple-design The record carries command selection, configured position and plugin metadata together without owning the scheduler or process.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An absent capability is represented by an absent key, not an invented resident identity or patched plugin metadata.
+ * @evidence contracts/common.md#meaningful-documentation Native member comments explain argv, duplicate positions and the undefined key; documented members are separated by blank lines.
+ * @evidence contracts/portability.md#os-neutral-implementation The record preserves native executable selection separately from argv and environment-carried compiler flags; consumers own native spawning and filesystem identity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+ */
+export type ResidentCheckEntryPlan = {
+    /**
+     * Full argv of the entry's one-shot check command. The resident consumer
+     * substitutes `check-serve` for the first argument when it starts a sidecar.
+     */
+    args: string[];
+    /**
+     * Position of the entry among the configured check-stage plugins. Two entries
+     * that share a resident process are still reported in configuration order,
+     * and pending watch changes are buffered per entry by this index.
+     */
+    entryIndex: number;
+    /**
+     * Resident process identity: binary, plugin name, argv, and the forwarded
+     * compiler flags. `undefined` when the plugin does not declare the
+     * `residentCheck` capability.
+     */
+    key: string | undefined;
+    /** The configured plugin this entry runs. */
+    plugin: ITtscLoadedNativePlugin;
+};

package/lib/compiler/internal/build/ResidentCheckEntryPlan.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ResidentCheckEntryPlan.js.map

package/lib/compiler/internal/build/ResidentCheckEntryPlan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResidentCheckEntryPlan.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/ResidentCheckEntryPlan.ts"],"names":[],"mappings":""}

package/lib/compiler/internal/build/ResidentCheckWatchChange.d.ts

@@ -0,0 +1,30 @@
+/**
+ * What changed on disk since the previous watch cycle, as the watch launcher
+ * classified it for {@link ResidentCheckWatchSession.run}.
+ *
+ * The fields distinguish effect scope. `reload` resets selected execution and
+ * sidecars; `invalidate` keeps that selection but requests a cold Program.
+ * Known source paths can update a warm Program incrementally. A declared
+ * external path outside that Program remains data-only; an unknown undeclared
+ * path invalidates the Program. An empty change requests another check without
+ * reporting an edit; it does not certify unchanged files.
+ *
+ * @evidence contracts/common.md#principled-implementation Reload, invalidation and incremental path lists encode different watch effects; optional fields permit a check request that reports no edit without certifying current filesystem equality.
+ * @evidence contracts/common.md#clear-and-simple-design One change record exposes the coordinator's effect hierarchy without embedding sidecar lifecycle or compiler implementation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The representation names actual watch actions and declared input classes rather than consumer-specific sentinel paths.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains effect precedence and empty changes; each documented member has its own separated comment.
+ * @evidence contracts/portability.md#os-neutral-implementation Changed and external paths are native filesystem inputs normalized against the selected execution's project root by the wire adapter; the type does not imply case equivalence from an OS name.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+ */
+export type ResidentCheckWatchChange = {
+    /** Re-resolve project, plugin, contributor, and Program topology. */
+    reload?: boolean;
+    /** Retain the sidecar and execution selection but cold-load its Program. */
+    invalidate?: boolean;
+    /** Local compiler or data paths changed since the prior cycle. */
+    changed?: readonly string[];
+    /** Subset of changed paths declared by ProjectRules as external inputs. */
+    external?: readonly string[];
+};

package/lib/compiler/internal/build/ResidentCheckWatchChange.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ResidentCheckWatchChange.js.map

package/lib/compiler/internal/build/ResidentCheckWatchChange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResidentCheckWatchChange.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/ResidentCheckWatchChange.ts"],"names":[],"mappings":""}

package/lib/compiler/internal/build/ResidentCheckWatchSession.d.ts

@@ -0,0 +1,113 @@
+import type { TtscBuildResult } from "../../../structures/internal/TtscBuildResult";
+import type { ResidentCheckWatchChange } from "./ResidentCheckWatchChange";
+import type { RunBuildOptions } from "./RunBuildOptions";
+/**
+ * Analysis-only watch coordinator.
+ *
+ * The selected project and compatible check-stage processes stay resident
+ * across ordinary source/data edits. A config, root-set, contributor, or plugin
+ * topology transition calls for a full reset before the next cycle. Emit and
+ * transform lanes can pass through the coordinator, but compatibility checks
+ * keep them on the established one-shot path without starting sidecars.
+ *
+ * The watch launcher must serialize cycles and use reload when invocation
+ * selection or startup environment changes. A session does not independently
+ * compare every option/environment field before reusing its cached context.
+ * `TTSC_WATCH_DEBUG_INPUTS` reports why selection is reset and the active
+ * sidecar count being retired, and distinguishes a failed resident transport.
+ *
+ * @evidence contracts/common.md#principled-implementation Stable invocation selection and serialized cycles let compatible analysis-only checks retain their Program; explicit reload and observed input-topology changes reset selection before another cycle.
+ * @evidence contracts/common.md#clear-and-simple-design The session owns selected execution, dependency snapshot, process identities and per-entry delivery buffers while shared BuildExecution owns one-shot phase and failure policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Capability-aware residency has an actual transport-failure one-shot path, not a successful-result substitution; configuration positions remain distinct even when processes share a key.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state supported lanes, reset causes and the caller's serialization/stable-invocation premise; run and dispose document lifecycle effects.
+ * @evidence contracts/portability.md#os-neutral-implementation Native filesystem checks and cache touch helpers use selected binary paths; child creation delegates native executable/argv/environment handling to ResidentCheckProcess and BuildExecution.
+ * @evidence contracts/performance.md#efficient-algorithms Per-cycle command planning, key serialization and buffer unions process configured checks and pending path text; sorting/comparison bytes, native cache observations, subscribed input discovery and delegated checks add work. Snapshot comparison visits normalized strings and accumulated output can repeatedly copy earlier phase text.
+ * @evidence contracts/performance.md#reuse-equivalent-work Process keys include binary/name/argv/compiler payload, while stable invocation context and reload guard the remaining startup inputs; current input snapshots and change requests determine warm Program updates.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Reset clears active maps, execution and snapshots while retiring children and join promises remain separately retained. Unknown joins remain retained rejection and prevent replacement; delegated termination is not descendant settlement. Stable options bound active process keys by configured checks, but pending unique paths and repeated disposal promise chains have no independent historical ceiling.
+ */
+export declare class ResidentCheckWatchSession {
+    private execution;
+    /** Undelivered changes keyed by configured check position, not process key. */
+    private readonly pendingChanges;
+    /** Latest normalized dependency population, plus declared watch aliases. */
+    private projectInputs;
+    /** Sidecars acquired for the stable invocation; reset releases every key. */
+    private readonly processes;
+    private readonly retiringProcesses;
+    private retirement;
+    private closed;
+    private generation;
+    /**
+     * Run one serialized watch cycle through the shared build/check policies.
+     * Options identifying the invocation and startup environment must remain
+     * stable until reload; callers must not run overlapping cycles.
+     *
+     * The first cycle, and any cycle after `change.reload`, resolves the project
+     * and plugins and starts resident check processes for compatible entries.
+     * Later cycles reuse them and forward `change` as an incremental request. A
+     * resident process that fails is retired and its entry falls back to the
+     * one-shot check for that cycle.
+     *
+     * @evidence contracts/common.md#principled-implementation Compatible no-emit check-only selection uses the same diagnostic/failure policy as one-shot execution; reload, missing binaries and changed normalized dependency topology cold-resolve the next execution.
+     * @evidence contracts/common.md#clear-and-simple-design The cycle separates setup/reuse, topology refresh, ordered checks and final diagnostics/timing, delegating each phase to its owning shared operation.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed resident transport retires that process and uses the established real check command; the fallback neither drops forwarded compiler options nor converts a nonzero check into success.
+     * @evidence contracts/common.md#meaningful-documentation Native paragraphs document serialization, stable startup inputs, reload and failed-sidecar behavior instead of claiming arbitrary option changes are handled automatically.
+     * @evidence contracts/portability.md#os-neutral-implementation Native binary existence and cache freshness use filesystem helpers; all commands preserve selected cwd and use native process/environment abstractions without shell interpolation.
+     * @evidence contracts/performance.md#efficient-algorithms Warm cycles avoid project/plugin re-resolution until a missing binary or changed subscribed topology resets selection. Native existence/cache touches, optional onProjectInputs discovery, command/key construction, per-entry unions/sorts, delegated host work and output normalization/merging retain their actual entry/text/byte costs.
+     * @evidence contracts/performance.md#reuse-equivalent-work Selected context and capability-supported sidecars survive only stable invocation cycles; change requests update Programs, reload/topology transitions reset them, and effectful configured entries remain separately scheduled.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The session retains active sidecars and per-entry pending changes; transport failure retires its process and awaits actual close before fallback. Reset clears active state but not unknown retiring ownership or its rejection. Unconsumed path sets have no finite bound while an earlier entry repeatedly fails; child close does not certify descendants.
+     */
+    run(options: RunBuildOptions, change?: ResidentCheckWatchChange): Promise<TtscBuildResult>;
+    /**
+     * Request termination of every retained sidecar and discard session state.
+     * This initiates retirement synchronously; a later run awaits actual child
+     * close before selecting a fresh session. Use close for terminal, awaitable
+     * release. Child termination and queued-request rejection belong to the
+     * process owner.
+     *
+     * @evidence contracts/common.md#principled-implementation Reset visits each owned process before clearing its map and discards pending changes, dependency snapshot and selected execution together.
+     * @evidence contracts/common.md#clear-and-simple-design Disposal uses the same reset boundary as topology transitions, keeping resource and cached-selection release in one place.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Release calls the supported child disposal API rather than replacing process methods or marking still-owned resources as successful check results.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes synchronous initiation, joined reuse and terminal close.
+     * @evidence contracts/portability.md#os-neutral-implementation Platform-specific child termination is delegated to ResidentCheckProcess; this coordinator does not assume a POSIX signal guarantees process-tree exit on every OS.
+     * @evidence contracts/performance.md#efficient-algorithms Reset deduplicates active and retiring children, traverses that population and collects previous/current promise outcomes; delegated disposal can reject queued child requests. Maps clear without a separate path-by-path pending-request scan, while debug serialization and callbacks add their own costs.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Disposal invalidates shared execution ownership rather than establishing reusable computation.
+     *
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Every retained process receives retirement before map ownership is cleared; known failed exits can be replaced only after actual close, while unknown joins reject. Buffers and selected state release immediately and the generation rejects late work.
+     */
+    dispose(): void;
+    /**
+     * Terminally close this session and await every retained or retiring child.
+     * Unlike dispose, later runs are rejected and cannot start a fallback.
+     *
+     * @evidence contracts/common.md#principled-implementation Terminal admission closes before owned processes are retired, and completion awaits their actual child-close outcomes.
+     * @evidence contracts/common.md#clear-and-simple-design The same reset boundary owns reusable disposal and terminal closure, with a separate admission flag for their different public contracts.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Closing forbids subsequent process acquisition or fallback and retains failed or unknown retirement as rejection.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes terminal closure from the compatible reusable dispose operation.
+     * @evidence contracts/portability.md#os-neutral-implementation Native EOF and close validation belong to each process owner; the session joins outcomes without assuming POSIX signal behavior on Windows.
+     * @evidence contracts/performance.md#efficient-algorithms Terminal reset deduplicates active and retiring children and observes their joins alongside the previous retirement promise. Outcome/failure collection and delegated queued-request disposal contribute work; unknown joins can reject at the child owner's event-loop deadline rather than becoming successful closes.
+     * @evidence contracts/performance.md#reuse-equivalent-work Repeated terminal closes share the retirement promise, while subsequent computation is forbidden by terminal admission.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Closing releases maps and selected state immediately but retains join promises until every actual child outcome settles; failed or unknown ownership remains rejection.
+     */
+    close(): Promise<void>;
+    private assertOpen;
+    private resetForRun;
+    /** Release selection immediately and join its children before replacement. */
+    private reset;
+    private trackRetirement;
+    /** Capture discoveries only when the caller actually subscribes to them. */
+    private captureProjectInputs;
+    /**
+     * Refresh normalized Program topology while always publishing declared alias
+     * updates to the watcher, even when physical dependency identity is
+     * unchanged.
+     */
+    private refreshProjectInputTopology;
+    /**
+     * Deliver changes in configured order, retaining later entries' undelivered
+     * requests after an earlier failure. Process sharing never shares away a
+     * configured check invocation.
+     */
+    private runCheckPlugins;
+}