ttsc 0.22.0 → 0.23.0

package/lib/launcher/internal/watchTopology.d.ts

@@ -8,6 +8,7 @@ type WatchTopologyOptions = Pick<TtscBuildOptions, "binary" | "emit" | "env" | "
 type WatchTopologyCallbacks = {
     onError(location: string, error: unknown): void;
     onInputChange(change: WatchInputChange): void;
+    onProjectInputWatchUnavailable?(roots: readonly string[]): void;
     onProjectInputWatchRoots?(roots: readonly string[]): void;
     onTopologyChange(): void;
 };
@@ -35,11 +36,14 @@ export declare class WatchTopology {
     private readonly callbacks;
     private analysisOnly;
     private closed;
+    private compilerPostRegistrationMembershipRefresh;
+    private compilerPostRegistrationReconciliationScheduled;
+    private compilerPostRegistrationSkipUnobservedProjectInputWatchRoots;
     private directories;
     private directoryWatchers;
     private extraInputs;
     private extraWatchers;
-    private compilerFileStamps;
+    private compilerFileSnapshots;
     private files;
     private fileWatchers;
     private observedDirectories;
@@ -49,14 +53,35 @@ export declare class WatchTopology {
     private projectInputMatches;
     private projectInputs;
     private declaredProjectInputs;
+    private projectInputRecoveryScheduled;
+    private projectInputPostRegistrationReconciliationScheduled;
     private projectInputRejectedWatchRoots;
+    private projectInputRequiredWatchRoots;
+    private projectInputUnobservedWatchRoots;
     private projectInputWatchRoots;
     private projectInputWatchers;
     private projectInputLinkWatchers;
+    private projectInputCompilerOutputOverlaps;
+    private projectInputCompilerAcknowledgements;
     private reloadFiles;
     constructor(options: WatchTopologyOptions, callbacks: WatchTopologyCallbacks);
     /** Re-resolve compiler inputs and notify only when their membership changed. */
     refresh(notify: boolean): void;
+    private refreshCompilerInputs;
+    /**
+     * Hand one Program-membership transition from the compiler lane to the
+     * overlapping project-input lane.
+     *
+     * Windows can deliver the compiler membership refresh before the recursive
+     * project watcher names the same creation. The rebuild scheduled here already
+     * consumes the current project bytes, so publishing their strong fingerprints
+     * keeps the later parent event from rediscovering the same population delta.
+     * A newly tracked compiler file also remembers that fingerprint until its
+     * first named content delivery; identical bytes are the delayed creation,
+     * while different bytes are a real later edit and remain observable even
+     * inside filesystem timestamp resolution.
+     */
+    private acknowledgeProjectInputCompilerMembership;
     /** Add Go plugin source trees discovered by the real build lane. */
     setExtraInputs(inputs: readonly string[]): void;
     /**
@@ -67,9 +92,19 @@ export declare class WatchTopology {
     /** Close every watcher so SIGINT/SIGTERM can drain the event loop. */
     close(): void;
     private syncFileWatchers;
-    /** Whether a tracked file's bytes differ from the last stamp taken. */
-    private compilerFileMoved;
+    /** Compare a tracked file's content and physical owner with its snapshot. */
+    private compilerFileMovement;
     private syncDirectoryWatchers;
+    /**
+     * Reconcile tracked compiler files after a newly registered watcher returns.
+     *
+     * A file or directory watcher can be returned before its backend is ready to
+     * deliver the first event. The compiler-file stamps were captured before
+     * registration, so one coalesced microtask can recover a change in that
+     * handoff window. A real event updates the same stamp first and makes this
+     * bounded scan a no-op.
+     */
+    private scheduleCompilerPostRegistrationReconciliation;
     /**
      * Narrow a plan's changes to the tracked files that actually moved.
      *
@@ -83,7 +118,7 @@ export declare class WatchTopology {
      * decided from the bytes, which is the question neither of them answered.
      */
     private compilerChangesToReport;
-    private recordCompilerFileStamp;
+    private recordCompilerFileSnapshot;
     private rearmFileWatchers;
     private syncExtraWatchers;
     private syncProjectInputWatchers;
@@ -103,6 +138,44 @@ export declare class WatchTopology {
     /** Drop the watcher that just reported a directory replacement. */
     private retireProjectInputWatcher;
     private retainProjectInputWatchRoot;
+    /**
+     * Retry a failed root on the next reconciliation instead of retiring it for
+     * the session.
+     *
+     * This immediate recovery pass still honors the rejected root so it can
+     * install a safe ancestor where one exists. Only the recovery fixpoint
+     * reports a genuinely uncovered lane; transient gaps between fallback
+     * candidates are not user-visible. The rejection then expires. A later
+     * compiler refresh or an unchanged project-input republication can retry the
+     * original root, while a permanently failing backend costs at most one
+     * attempt per sync.
+     */
+    private scheduleProjectInputWatcherRecovery;
+    /**
+     * Reconcile the snapshot-to-watcher handoff after the caller's current turn.
+     *
+     * A recursive watcher can return before its backend is ready to deliver the
+     * first event. The publication baseline is necessarily captured before that
+     * watcher exists, so an input materialized synchronously after
+     * `setProjectInputs()` would otherwise depend entirely on that startup event.
+     * The ordinary fingerprint update makes this scan and a real backend event
+     * race safely: whichever arrives first records the new population and the
+     * other becomes a no-op.
+     */
+    private scheduleProjectInputPostRegistrationReconciliation;
+    /**
+     * Re-resolve declarations after watcher registration.
+     *
+     * A missing path can become a symlink before the handoff scan. The retained
+     * normalized snapshot still names the pre-link spelling in that case, so a
+     * scan can find the first target file without installing the physical owner
+     * that must observe later target changes.
+     */
+    private refreshPublishedProjectInputIdentities;
+    /** Drop retained owner choices for declarations no longer published. */
+    private pruneProjectInputWatchRoots;
+    /** Report only newly uncovered project-input roots as an observation loss. */
+    private reportUnobservedProjectInputWatchRoots;
     /**
      * One snapshot holding every spelling of every declaration.
      *
@@ -143,7 +216,7 @@ type SynchronizedWatcher = {
     close(): void;
     on(event: "error", listener: (error: Error) => void): unknown;
 };
-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): boolean;
+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;
 export declare function literalGlobRoot(pattern: string): string;
 /**
  * Chooses the one stable recursive watcher root owned by a project-input
@@ -164,7 +237,7 @@ export declare function projectInputWatchDirectories(target: string, projectRoot
  * Removes recursive roots already covered by an ancestor without rewriting the
  * declaration-specific roots retained by WatchTopology.
  */
-export declare function projectInputActiveWatchDirectories(directories: Iterable<string>, identities?: ProjectInputPathIdentityContext): string[];
+export declare function projectInputActiveWatchDirectories(directories: Iterable<string>, identities?: import("../../internal/projectInputPathIdentity").FilesystemPathIdentityContext): string[];
 export declare function projectInputAvailableWatchDirectory(location: string, rejected: ReadonlySet<string>, identities?: ProjectInputPathIdentityContext, projectRoot?: string): string | undefined;
 /**
  * Whether a replacement at this path leaves a recursive watcher bound to the
@@ -186,7 +259,7 @@ export declare function projectInputAvailableWatchDirectory(location: string, re
  * since its fingerprint is a digest of its own immediate entries and nothing
  * below it can reach the declared corpus.
  */
-export declare function projectInputReplacementStrandsWatchers(snapshot: ITtscProjectInputSnapshot, location: string, identities?: ProjectInputPathIdentityContext, platform?: NodeJS.Platform): boolean;
+export declare function projectInputReplacementStrandsWatchers(snapshot: ITtscProjectInputSnapshot, location: string, identities?: import("../../internal/projectInputPathIdentity").FilesystemPathIdentityContext, platform?: NodeJS.Platform): boolean;
 /**
  * Decide whether an event that named no declared input can still have moved
  * one.
@@ -198,7 +271,7 @@ export declare function projectInputReplacementStrandsWatchers(snapshot: ITtscPr
  * inferred from a rebuild that a silent rescan and a skipped rescan produce
  * identically.
  */
-export declare function projectInputTopologyMayAffect(snapshot: ITtscProjectInputSnapshot, location: string, previous: ReadonlyMap<string, string>, identities?: ProjectInputPathIdentityContext): boolean;
+export declare function projectInputTopologyMayAffect(snapshot: ITtscProjectInputSnapshot, location: string, previous: ReadonlyMap<string, string>, identities?: import("../../internal/projectInputPathIdentity").FilesystemPathIdentityContext): boolean;
 export declare function projectInputEventShouldNotify(input: {
     contentChanged: boolean;
     directlyMatched: boolean;
@@ -213,6 +286,7 @@ export declare function projectInputEventShouldNotify(input: {
  * bytes remain quiet before this classifier is observed.
  */
 export declare function projectInputReloadEventShouldNotify(input: {
+    causedBy?: readonly string[];
     changed?: string;
     changedInputs: readonly string[];
     reloadDirectories?: readonly string[];