ttsc 0.30.4 → 0.31.1

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

@@ -0,0 +1,384 @@
+import fs from "node:fs";
+import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
+import type { ITtscProjectInputSnapshot } from "../../../structures/internal/ITtscProjectInputSnapshot";
+import type { TtscBuildOptions } from "../../../structures/internal/TtscBuildOptions";
+import type { WatchInputChange } from "./WatchInputChange";
+import { watchDirectory } from "./watchDirectory";
+/**
+ * Keeps the launcher watch set aligned with the compiler's current program.
+ *
+ * The default compiler-input reader uses TypeScript-Go's `--listFilesOnly`
+ * output for source and declaration membership. An explicit reader supplies the
+ * same absolute-path membership and failure contract for each resolved project.
+ * Configuration files, project-reference roots, output inference and native
+ * filesystem identity remain this topology's responsibility.
+ * Response frames are observed once per project refresh at its compiler cwd;
+ * that option view serves all project-output queries while the original argv
+ * reaches compiler membership. A second observation rejects response changes
+ * across membership resolution. Response files join the config reload set;
+ * these observations do not pin files or detect a change restored in between.
+ *
+ * `TTSC_WATCH_DEBUG_INPUTS` reports the named event, observed population deltas
+ * and reload decision. These diagnostics reuse the decision's existing inputs;
+ * they perform no extra filesystem observations.
+ *
+ * @evidence contracts/common.md#principled-implementation The compiler-input operation's membership, published rule inputs and actual content fingerprints qualify notifications; its native default obtains the real compiler list. Post-registration reconciliation compares baselines to recover observed handoff changes, not an atomic guarantee against every transient mutation. Explicit operations preserve native defaults without replacing global filesystem or compiler methods. Project-input attribution: Observed member deltas establish attribution; stale selected names cannot override them, while directory names retain supported population causality and unrelated multiple members remain unnamed.
+ * @evidence contracts/common.md#clear-and-simple-design Compiler, plugin and project-input watch populations keep their own baselines and callbacks under one topology owner; small classifiers separate membership, selection and handle replacement. Four distinct operations own directory subscriptions, file subscriptions, immediate reload-directory reads and compiler membership; existing callers need no new argument. Project-input attribution: One private reconciliation separates member deltas from immediate resolution-directory digests before choosing a supported event name or an observed single member.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported native backends and explicit gap/replacement ownership replace foreign watcher patching; failed observation is reported rather than represented as complete coverage. The constructor manufactures no observations and bypasses no input or content proof; supplied operations retain the existing callback and result contracts. Project-input attribution: Native event names do not manufacture a delta; the current and previous physical membership identify already observed names without filename or fixture exceptions.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain membership authority, plugin fingerprinting, publication races, physical registration and public lifecycle operations following the documentation skill. Parameters identify each supplied operation and native default beside the constructor. Project-input attribution: Native paragraphs explain stale attention, directory causality, accompanying resolution digests and unselected immediate entries.
+ * @evidence contracts/portability.md#os-neutral-implementation Native paths use Node APIs and registration uses realpath; compiler/plugin maps preserve lexical aliases and fold only measured insensitive ASCII components. Project inputs use physical identities, while unknown/native Unicode relations remain conservative event candidates rather than identity proof. Registration paths and read options are passed unchanged; compiler-input readers supply absolute membership paths without replacing the topology's native identity policy. Project-input attribution: The supplied filesystem identity transaction establishes selected names and ancestry without an OS-wide case assumption or lexical alias guess.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms Identity-keyed maps separate membership, baselines and handle registries; reconciliation delegates project/config discovery, native compiler listing, filesystem traversal/hashing and backend callbacks, with costs described by its members. Construction retains operation references and empty indexes without a filesystem observation or build. Attribution indexed visits additionally pay path/key text, ancestor and native identity work; shared ancestor keys avoid repeating the same walk within a transaction.
+ * @evidence contracts/performance.md#reuse-equivalent-work Current membership, content baselines and live registrations belong to one topology; reconciliation owners decide their reuse against fresh premises. Supplied operation identities are retained without adding an observation-result cache or assuming changed inputs remain equivalent. Project-input attribution: This classifier borrows one scan's deltas and identity transaction without retaining cross-event answers.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Current and pending maps and live subscriptions remain topology-owned without a population cap; reconciliation attempts obsolete handle retirement. Constructor acquires no handle; directory arrays and attribution deltas are call-local. close invokes supplied close methods but does not await backend closure, and a thrown close can interrupt later map cleanup; retained snapshots remain until the facade is released.
+ */
+export declare class WatchTopology {
+    private readonly options;
+    private readonly callbacks;
+    private readonly openDirectoryWatch;
+    private readonly openFileWatch;
+    private readonly readDirectory;
+    private readonly getCompilerInputs;
+    private analysisOnly;
+    private closed;
+    private compilerPostRegistrationMembershipRefresh;
+    private compilerPostRegistrationReconciliationScheduled;
+    private compilerPostRegistrationSkipUnobservedProjectInputWatchRoots;
+    private directories;
+    private directoryWatchers;
+    private extraInputs;
+    /**
+     * What each plugin input held when last observed, by path key: the digest a
+     * plugin build keys it on (`pluginInputState`). A notification about an input
+     * whose state did not move is not a plugin change.
+     */
+    private pluginInputStates;
+    /**
+     * The plugin inputs notifications named since the last decision, by path key,
+     * each with the locations noted for it (`notePluginNotification`).
+     */
+    private pendingPluginNotifications;
+    private pluginNotificationsScheduled;
+    private extraWatchers;
+    /** The plugin inputs whose directories the last sync already watched. */
+    private watchedExtraInputs;
+    private compilerFileSnapshots;
+    private files;
+    private lexicalIdentities;
+    private fileWatchers;
+    private observedDirectories;
+    private outputFiles;
+    private outputs;
+    private projectInputFingerprints;
+    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 reloadFiles;
+    /**
+     * @param options What to watch.
+     * @param callbacks What to tell about it.
+     * @param openDirectoryWatch The backend every directory watch goes through:
+     *   `watchDirectory`, which chooses the platform's, unless the caller
+     *   observes the watch set through another.
+     * @param openFileWatch File subscriptions use this owned observer; native
+     *   fs.watch by default.
+     * @param readDirectory Immediate reload-directory fingerprints use this
+     *   reader; native readdirSync by default.
+     * @param getCompilerInputs Read each resolved project's absolute compiler
+     *   membership; the default invokes the native compiler. Readers throw
+     *   listing failures and retain ownership of their returned array, which this
+     *   topology does not mutate.
+     */
+    constructor(options: WatchTopologyOptions, callbacks: WatchTopologyCallbacks, openDirectoryWatch?: typeof watchDirectory, openFileWatch?: typeof fs.watch, readDirectory?: typeof fs.readdirSync, getCompilerInputs?: typeof listCompilerInputs);
+    /**
+     * Re-resolve compiler inputs and notify when the resolved topology changes,
+     * including membership, output/configuration or analysis-mode changes. Errors
+     * propagate to the caller; native watcher registration failures are reported
+     * through onError while previous coverage remains live.
+     *
+     * @evidence contracts/common.md#principled-implementation The compiler-input operation defines membership and its native default reads the actual compiler list; new coverage is registered before stale coverage retires, and registration reconciliation compares against pre-registration baselines.
+     * @evidence contracts/common.md#clear-and-simple-design One refresh delegates compiler population resolution, watcher synchronization and notification classification to separate private owners.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Predicted outputs never subtract from compiler-reported inputs; failed registration cannot claim complete replacement coverage.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states notification gating, thrown errors and registration error ownership following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Compiler processes use explicit argv/env; native APIs own path grammar and backend differences. Lexical membership uses measured component case policy, keeping unknown names and symlink aliases distinct instead of folding all Windows paths.
+     * @evidence contracts/performance.md#efficient-algorithms Project/reference configuration discovery, output inference and supplied/native compiler listing precede file/key snapshot passes. Native path/case/ancestor work and newly admitted file hashing add text/byte costs; broad reconciliation stats tracked files and strongly reads metadata/owner movement, while named/gap events request strong reads. Windows directory pruning is pairwise, and extra/project watcher reconciliation adds its own scans and backend callback costs without a file-count or deadline cap.
+     * @evidence contracts/performance.md#reuse-equivalent-work Existing live watchers and unchanged fingerprints are reused by key; one fresh synchronous transaction shares parent case probes across membership, output and directory keys. One current root selection shares response inspection across referenced-project output queries; response observations are checked again after membership and never cached across refreshes. Registration microtasks coalesce gap work while actual compiler membership is refreshed rather than inferred from quiet notifications.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Current snapshots prune removed members and synchronization attempts obsolete handle closure, keeping old coverage after incomplete registration. Current/recovery populations and observations have no size cap; supplied close/error callbacks can throw and close does not await backend completion. State remains owner-held until released.
+     */
+    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.
+     * Compiler files keep their own content fingerprints at admission, so a
+     * delayed named event for the same bytes is quiet on every backend.
+     */
+    private acknowledgeProjectInputCompilerMembership;
+    /**
+     * Add Go plugin source trees discovered by the real build lane. Existing
+     * input fingerprints retain their baseline; new inputs are captured before
+     * the caller builds them, so later notifications can compare that
+     * observation. This does not freeze the source tree or prove every transient
+     * edit was seen.
+     *
+     * @evidence contracts/common.md#principled-implementation Published plugin inputs define the source corpus, and retaining existing pre-build baselines keeps unreported edits visible.
+     * @evidence contracts/common.md#clear-and-simple-design Deduplication, baseline retention and compiler/watch reconciliation remain ordered phases.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The actual plugin source digest applies its owning source-selection and pruning policy; named plugins or fixture output do not replace observed input state.
+     * @evidence contracts/common.md#meaningful-documentation Native prose explains baseline timing and why existing inputs are not restamped following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and canonical backend registration govern source trees; lexical keys preserve declarations and unknown names, folding ASCII only under measured insensitive parents rather than an OS-derived rule.
+     * @evidence contracts/performance.md#efficient-algorithms Input/path keys deduplicate with text and native case/ancestor work; only newly admitted inputs compute initial source digests. Those reads scan the selected pruned corpus, then refresh(false) also pays project/compiler listing, directory traversal and watcher reconciliation; fixed publication count does not bound delegated bytes or backend work.
+     * @evidence contracts/performance.md#reuse-equivalent-work Unchanged ordered input sets return immediately; existing inputs reuse their recorded digest until actual notification processing establishes changed consumed state.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Publications replace input/digest populations and case-observation caches without a population cap; synchronization attempts obsolete watcher closure. Native/supplied closure has its own lifetime and can throw; owner close does not prove every backend has stopped or every retained snapshot byte was released.
+     */
+    setExtraInputs(inputs: readonly string[]): void;
+    /**
+     * Reconcile project-rule dependencies, retaining absent files and empty glob
+     * populations as live topology.
+     *
+     * @evidence contracts/common.md#principled-implementation Both lexical declarations and current physical identities remain observable, including missing members and empty globs; republication can update aliased watcher ownership without requiring population movement.
+     * @evidence contracts/common.md#clear-and-simple-design Publication normalization, baseline population capture and root synchronization are separate stages, with one retained declaration-owner map.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing inputs are not dropped from observation, and an unavailable safe root is reported rather than widened over a system ancestor.
+     * @evidence contracts/common.md#meaningful-documentation Native prose and helper paragraphs explain absent populations, aliases, handoff reconciliation and root ceilings following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Transaction-owned native case observations and physical identities distinguish resolved aliases; unknown case routes both glob interpretations without merging keys, while canonical registration and separate link-entry observation preserve retargets.
+     * @evidence contracts/performance.md#efficient-algorithms Publication normalizes native identities and sorts distinct path lists, then compares snapshots and reconciles alias/watch roots. Changed publications enumerate deduplicated physical glob roots, test applicable patterns with pattern/path/native identity costs and fingerprint selected file bytes or sorted immediate directory entries. Parent/case probes, repeated declaration/root admission and backend work add costs beyond file-pattern visits; payloads and traversal depth are uncapped.
+     * @evidence contracts/performance.md#reuse-equivalent-work Equal normalized publications reuse content baselines but still reconcile lexical aliases; registration microtasks coalesce equivalent handoff work, and transaction indexes reuse identity and output-overlap decisions within one scan.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Publication prunes retired declaration-owner choices and replaces uncapped match/fingerprint populations. Watcher retirement invokes close without awaiting backend completion, and supplied errors can interrupt cleanup. Weak output-overlap keys do not retain old identity transactions; the current declaration snapshot can borrow caller arrays until replaced or the facade is released.
+     */
+    setProjectInputs(inputs: ITtscProjectInputSnapshot): void;
+    /**
+     * Invoke close on owned watchers so their backends can retire. Scheduled
+     * reconciliation callbacks observe the closed state and retire without
+     * creating replacement subscriptions. A thrown close propagates and
+     * interrupts remaining cleanup; this void method does not await
+     * native/backend shutdown or guarantee event-loop drain.
+     *
+     * @evidence contracts/common.md#principled-implementation Marking the owner closed before retiring subscriptions prevents queued reconciliations from reopening native handles.
+     * @evidence contracts/common.md#clear-and-simple-design One shutdown operation closes and clears each distinct watcher population through a shared helper.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Shutdown invokes actual owned subscription close methods rather than only suppressing output; errors propagate and no backend completion is fabricated.
+     * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain event-loop release and queued-work behavior following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Shared close methods retire both Node handles and macOS registry subscriptions without exposing native handle types.
+     * @evidence contracts/performance.md#efficient-algorithms Each successfully reached live map traverses its watcher references and invokes backend-owned close work before clearing. Completed maps make later traversals empty; delegated cleanup costs and a thrown callback are not bounded by reference count alone.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Shutdown decides no equivalence of compilation or fingerprint work.
+     *
+     * @evidence contracts/performance.md#bound-retention-and-release-resources On successful completion all five watcher maps clear and the lexical transaction is replaced; queued tasks observe the closed guard. A thrown close can leave later maps retained, and backend closure is not joined. Snapshot/declaration/pending byte state remains until replaced or the facade is released.
+     */
+    close(): void;
+    /** Start fresh native case observations for one synchronous watch decision. */
+    private beginLexicalTransaction;
+    /** Keep lexical alias ownership while sharing this decision's case probes. */
+    private pathKey;
+    private syncFileWatchers;
+    /**
+     * Compare a tracked file with its last observed bytes and physical owner.
+     *
+     * A named event or observation gap reads the bytes even when time and size
+     * stayed still. A broad registration scan reads only a file whose metadata or
+     * owner moved, so an unrelated event does not read the whole Program.
+     */
+    private compilerFileMovement;
+    /** A config's physical replacement can change resolution with equal bytes. */
+    private compilerMovementReports;
+    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 tracked files whose bytes actually moved.
+     *
+     * A named event checks its file even when time and size stayed still. A gap
+     * can hide such a rewrite anywhere under the watched root, so every candidate
+     * gets a strong check. Ordinary broad scans still use metadata first.
+     */
+    private compilerChangesToReport;
+    /**
+     * Let a selected project input consume its compiler content notification.
+     * Both lanes watch a resolveJsonModule file, but its project fingerprint
+     * decides the resident update once whichever backend hears the edit first. A
+     * missing compiler member instead reconciles Program membership before a
+     * stale file-watch notification can schedule a second build.
+     */
+    private reportCompilerFileChange;
+    private rearmFileWatchers;
+    /**
+     * Watch every directory of every plugin input, and report what a directory
+     * that appeared below an input already watched holds by now.
+     *
+     * Each directory has a watcher of its own, and a directory created below a
+     * plugin module is heard through its parent's; its own watcher is added only
+     * here, when that notification is decided (`decidePluginNotifications`) or
+     * the topology refreshes. A file written into it in between reaches no
+     * watcher on a platform whose watcher reports a directory's direct entries
+     * alone, and a build may have read the directory before the file landed. So
+     * once its watcher is registered, each entry it holds is noted as a plugin
+     * notification, as `@ttsc/unplugin`'s observer announces a directory it
+     * starts watching, and reported when it moved what a build reads. The
+     * directories of an input new to this sync are not reported: the load reports
+     * its inputs before any build reads them.
+     */
+    private syncExtraWatchers;
+    private syncProjectInputWatchers;
+    /**
+     * Watch the directory that holds a declaration which is itself a link.
+     *
+     * A recursive watcher cannot report the link being replaced. The backend that
+     * keys its handles by path skips an entry it already knows, and the handle it
+     * put on the entry followed the link to the target's inode, which unlinking
+     * and recreating the link never touches. A plain directory watch has neither
+     * property: it reports the entry by name the moment it moves. These are kept
+     * apart from the recursive roots because they are not roots — they observe
+     * one directory, they are never reported as watch roots, and an ancestor
+     * covering them does not make them redundant.
+     */
+    private syncProjectInputLinkWatchers;
+    /** 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.
+     *
+     * Consumers that decide from a population rather than from a single path have
+     * to see both, or half of them answer from the file a link pointed at when
+     * the snapshot was published while the event they are judging resolved to the
+     * file it points at now.
+     */
+    private projectInputPopulation;
+    /**
+     * Every spelling of one declaration that has to be anchored separately.
+     *
+     * The retained snapshot is normalized to physical identities, which is what
+     * every comparison needs but not what every watcher needs: a declaration
+     * reached through a symlink resolves to its target's directory, so anchoring
+     * the normalized form alone watches the bytes and never the link. Retargeting
+     * or replacing the link then goes unobserved, even though it is exactly what
+     * decides which bytes the declaration names next. Both spellings are planned
+     * through the same root selection, so the project-root hoist and the
+     * nearest-existing-ancestor boundary still bound each of them, and the active
+     * set drops one again whenever they coincide or share an ancestor.
+     */
+    private projectInputDeclarations;
+    private projectInputWatchRoot;
+    private refreshProjectInputs;
+    private collectProjectInputMatches;
+    private refreshFromDirectory;
+    private isCompilerOutputDirectory;
+    private isCompilerOutput;
+    private isProjectInputCompilerOutputDirectory;
+    private isProjectInputCompilerOutput;
+    private isProjectInputDirectory;
+    private classifyCompilerInput;
+    /**
+     * Note a notification at `location` against the plugin inputs it may have
+     * moved, to be decided once the delivery it came in has reached every
+     * listener (`decidePluginNotifications`).
+     *
+     * A watcher reports more than an edit. Windows reports a directory's entry as
+     * changed when only its metadata moved, such as its access time after a build
+     * enumerated it, and a notification taken at its word restarted the resident
+     * check host for a plugin whose sources nobody edited. An input is decided by
+     * what its build reads, which is every one of its source files, so the
+     * notifications of one delivery are decided together: an install or a
+     * checkout brings hundreds, and each input they name is read once. A location
+     * no input covers, such as a directory above one, names every input.
+     */
+    private notePluginNotification;
+    /**
+     * Report every location noted for a plugin input whose state moved, once
+     * each, and record the state it moved to. A notification that moved no input
+     * is dropped.
+     *
+     * Whether a build must rerun and what must be watched are separate questions.
+     * A delivery can name a directory created below an input: while it is empty
+     * it moves nothing a build reads, yet it needs a watcher of its own before a
+     * file lands in it, or on a platform whose watcher reports a directory's
+     * direct entries alone that file reaches no watcher. So the watchers are
+     * synced first, and what a directory they start watching already holds is
+     * noted into this same decision (`syncExtraWatchers`).
+     */
+    private decidePluginNotifications;
+    /**
+     * Whether a path is one a plugin build keys on: the plugin input itself, or a
+     * path below it outside every directory the build passes over
+     * (`pluginSourceCovers`). A write in a plugin module's `node_modules` or
+     * `.git` is not one, whatever watcher heard it.
+     *
+     * Nor is such a directory's own entry. Windows reports every write inside a
+     * directory as a change of that directory's entry to a watch on its parent,
+     * and nothing of a directory the build passes over, or below it, is a source.
+     * An entry of the same name that is a file is one the build reads.
+     */
+    private isPluginInput;
+}
+type WatchTopologyOptions = Pick<TtscBuildOptions, "binary" | "compilerArgsCwd" | "compilerProjectSelections" | "emit" | "env" | "outDir" | "passthrough" | "projectRoot" | "tsconfig"> & {
+    cwd: string;
+    files: readonly string[];
+    pinCompilerProject?: boolean;
+};
+type WatchTopologyCallbacks = {
+    onError(location: string, error: unknown): void;
+    onInputChange(change: WatchInputChange): void;
+    onProjectInputWatchUnavailable?(roots: readonly string[]): void;
+    onProjectInputWatchRoots?(roots: readonly string[]): void;
+    onTopologyChange(): void;
+};
+declare function listCompilerInputs(project: ITtscParsedProjectConfig, options: WatchTopologyOptions): string[];
+export {};