ttsc 0.21.0 → 0.23.0

package/lib/compiler/internal/runBuild.d.ts

@@ -1,16 +1,28 @@
+import { type ProjectInputPathIdentityContext } from "../../internal/projectInputPathIdentity";
 import type { ITtscCompilerDiagnostic } from "../../structures/ITtscCompilerDiagnostic";
+import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoadedNativePlugin";
 import type { ITtscParsedProjectConfig } from "../../structures/internal/ITtscParsedProjectConfig";
+import type { ITtscProjectInputSnapshot } from "../../structures/internal/ITtscProjectInputSnapshot";
 import type { TtscBuildOptions } from "../../structures/internal/TtscBuildOptions";
 import type { TtscBuildResult } from "../../structures/internal/TtscBuildResult";
-type RunBuildOptions = TtscBuildOptions & {
+import { type ResidentCheckRequest } from "./residentCheckProcess";
+export type RunBuildOptions = TtscBuildOptions & {
     skipDiagnosticsCheck?: boolean;
     forceListEmittedFiles?: boolean;
+    /** Keep every compiler-owned side product inside this private directory. */
+    isolateOutputsTo?: string;
     /**
      * Receives selected native-plugin source roots after the project resolves.
      * The watch launcher uses these roots to invalidate a sidecar when its Go
      * implementation changes between rebuilds.
      */
     onWatchInputs?: (inputs: readonly string[]) => void;
+    /**
+     * Receives the reconciled project-rule filesystem dependency snapshot. Called
+     * only by watch launchers; ordinary builds do not probe the optional sidecar
+     * command.
+     */
+    onProjectInputs?: (inputs: ITtscProjectInputSnapshot) => void;
     /**
      * Emit an external source map from the direct tsgo build lane even when the
      * project configures none. Set by the ttsx runtime builds so a served emit
@@ -27,6 +39,57 @@ type RunBuildOptions = TtscBuildOptions & {
  * decide how to surface diagnostics. Does not throw on non-zero exit.
  */
 export declare function runBuild(options?: RunBuildOptions): TtscBuildResult;
+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[];
+};
+/**
+ * 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.
+ */
+export declare class ResidentCheckWatchSession {
+    private execution;
+    private readonly pendingChanges;
+    private projectInputs;
+    private readonly processes;
+    run(options: RunBuildOptions, change?: ResidentCheckWatchChange): Promise<TtscBuildResult>;
+    /** Terminate every sidecar and discard the cached selection context. */
+    dispose(): void;
+    private reset;
+    private captureProjectInputs;
+    private refreshProjectInputTopology;
+    private runCheckPlugins;
+}
+export type ResidentCheckEntryPlan = {
+    args: string[];
+    entryIndex: number;
+    key: string | undefined;
+    plugin: ITtscLoadedNativePlugin;
+};
+/**
+ * Plan every configured check entry while sharing resident processes only by
+ * binary/name/argument identity.
+ */
+export declare function planResidentCheckEntries(plugins: readonly ITtscLoadedNativePlugin[], createArgs: (plugin: ITtscLoadedNativePlugin) => string[]): ResidentCheckEntryPlan[];
+/** Retain one complete change stream per configured resident check entry. */
+export declare function bufferResidentCheckEntryRequests(pending: Map<number, ResidentCheckRequest>, checks: readonly ResidentCheckEntryPlan[], request: ResidentCheckRequest): void;
+/** Consume exactly one configured entry's buffered request. */
+export declare function takeResidentCheckEntryRequest(pending: Map<number, ResidentCheckRequest>, entryIndex: number): ResidentCheckRequest;
+export declare function residentCheckRequest(change: ResidentCheckWatchChange, cwd: string): ResidentCheckRequest;
+export declare function mergeProjectInputSnapshots(fallbackRoot: string, snapshots: readonly ITtscProjectInputSnapshot[], identities?: ProjectInputPathIdentityContext): ITtscProjectInputSnapshot;
+export declare function parseProjectInputSnapshot(text: string, plugin: ITtscLoadedNativePlugin): ITtscProjectInputSnapshot;
+export declare function isAbsoluteLocalProjectInputPath(location: string, platform?: NodeJS.Platform): boolean;
 /**
  * Merge two `TtscBuildResult` values into one.
  *

package/lib/compiler/internal/runBuild.js

@@ -3,15 +3,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResidentCheckWatchSession = void 0;
 exports.runBuild = runBuild;
+exports.planResidentCheckEntries = planResidentCheckEntries;
+exports.bufferResidentCheckEntryRequests = bufferResidentCheckEntryRequests;
+exports.takeResidentCheckEntryRequest = takeResidentCheckEntryRequest;
+exports.residentCheckRequest = residentCheckRequest;
+exports.mergeProjectInputSnapshots = mergeProjectInputSnapshots;
+exports.parseProjectInputSnapshot = parseProjectInputSnapshot;
+exports.isAbsoluteLocalProjectInputPath = isAbsoluteLocalProjectInputPath;
 exports.appendBuildOutput = appendBuildOutput;
 exports.createProcessDiagnostic = createProcessDiagnostic;
 exports.normalizeBuildOutput = normalizeBuildOutput;
 const node_path_1 = __importDefault(require("node:path"));
 const schema_1 = require("../../flags/schema");
+const projectInputPathIdentity_1 = require("../../internal/projectInputPathIdentity");
 const loadProjectPlugins_1 = require("../../plugin/internal/loadProjectPlugins");
 const createNativeProjectContextArgs_1 = require("./project/createNativeProjectContextArgs");
 const readProjectConfig_1 = require("./project/readProjectConfig");
+const residentCheckProcess_1 = require("./residentCheckProcess");
 const resolveBinary_1 = require("./resolveBinary");
 const resolveTsgo_1 = require("./resolveTsgo");
 const sharedHostHelpers_1 = require("./sharedHostHelpers");
@@ -133,24 +143,276 @@ function runBuild(options = {}) {
     const result = runBuildTimed(options, timing);
     return appendTimingOutput(result, timing);
 }
+/**
+ * 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.
+ */
+class ResidentCheckWatchSession {
+    execution;
+    pendingChanges = new Map();
+    projectInputs;
+    processes = new Map();
+    async run(options, change = {}) {
+        if (change.reload === true)
+            this.reset();
+        const timing = createBuildTiming(options);
+        const projectFree = runProjectFreeTerminalFlag(options);
+        if (projectFree !== null) {
+            this.reset();
+            return appendTimingOutput(projectFree, timing);
+        }
+        let execution = this.execution;
+        const reusedExecution = execution !== undefined;
+        let buildOptions;
+        if (execution === undefined) {
+            const setupStartedAt = process.hrtime.bigint();
+            execution = resolveExecutionContext(options);
+            const discoveryOptions = this.captureProjectInputs(options);
+            const prepared = prepareBuildExecution(discoveryOptions, timing, execution, setupStartedAt);
+            buildOptions = prepared.buildOptions;
+            if (prepared.result !== undefined) {
+                this.reset();
+                return appendTimingOutput(prepared.result, timing);
+            }
+            if (!residentCheckExecutionIsCompatible(buildOptions, execution)) {
+                this.reset();
+                return appendTimingOutput(runPreparedBuild(options, timing, execution, buildOptions), timing);
+            }
+            this.execution = execution;
+        }
+        else {
+            buildOptions = applyProjectNoEmit(options, execution);
+        }
+        if (reusedExecution &&
+            this.refreshProjectInputTopology(options, execution)) {
+            this.reset();
+            return this.run(options);
+        }
+        const checked = await this.runCheckPlugins(buildOptions, execution, timing, change);
+        let result;
+        if (checked.status !== 0) {
+            result = appendTypeScriptDiagnosticsAfterPluginFailure(checked, buildOptions, execution);
+        }
+        else if (checkPluginsReportTypeScriptDiagnostics(execution.nativePlugins)) {
+            result = checked;
+        }
+        else {
+            result = appendBuildOutput(checked, runTsgo(execution, ["--noEmit"], buildOptions));
+        }
+        return appendTimingOutput(result, timing);
+    }
+    /** Terminate every sidecar and discard the cached selection context. */
+    dispose() {
+        this.reset();
+    }
+    reset() {
+        for (const process of this.processes.values())
+            process.dispose();
+        this.processes.clear();
+        this.pendingChanges.clear();
+        this.execution = undefined;
+        this.projectInputs = undefined;
+    }
+    captureProjectInputs(options) {
+        const onProjectInputs = options.onProjectInputs;
+        if (onProjectInputs === undefined)
+            return options;
+        return {
+            ...options,
+            onProjectInputs: (snapshot) => {
+                this.projectInputs = snapshot;
+                onProjectInputs(snapshot);
+            },
+        };
+    }
+    refreshProjectInputTopology(options, execution) {
+        if (options.onProjectInputs === undefined)
+            return false;
+        const next = discoverNativeProjectInputs(options, execution);
+        const changed = this.projectInputs !== undefined &&
+            !projectInputSnapshotsEqual(this.projectInputs, next);
+        this.projectInputs = next;
+        options.onProjectInputs(next);
+        return changed;
+    }
+    async runCheckPlugins(options, execution, timing, change) {
+        let out = {
+            diagnostics: [],
+            status: 0,
+            stderr: "",
+            stdout: "",
+        };
+        const checks = planResidentCheckEntries(execution.nativePlugins, (plugin) => createNativeCheckArgs(execution, options, plugin));
+        const request = residentCheckRequest(change, execution.projectRoot);
+        // Buffer the cycle for every resident plugin before running any of them.
+        // An earlier plugin may fail and short-circuit diagnostics, but a later
+        // sidecar must still receive every filesystem transition when it resumes.
+        bufferResidentCheckEntryRequests(this.pendingChanges, checks, request);
+        for (const { args, entryIndex, key, plugin } of checks) {
+            let result;
+            if (key === undefined) {
+                result = runNativePluginCommand(plugin, args, options, execution, "ttsc.check", timing, `ttsc check plugin ${plugin.name} time`);
+            }
+            else {
+                const startedAt = process.hrtime.bigint();
+                let resident = this.processes.get(key);
+                if (resident === undefined) {
+                    resident = new residentCheckProcess_1.ResidentCheckProcess({
+                        args: ["check-serve", ...args.slice(1)],
+                        binary: plugin.binary,
+                        cwd: execution.projectRoot,
+                        env: nativePluginEnv(options.env, execution, plugin),
+                    });
+                    this.processes.set(key, resident);
+                }
+                try {
+                    const reply = await resident.request(takeResidentCheckEntryRequest(this.pendingChanges, entryIndex));
+                    result = normalizeBuildOutput({
+                        status: reply.status,
+                        stderr: reply.stderr,
+                        stdout: reply.stdout,
+                    }, execution.projectRoot);
+                }
+                catch {
+                    resident.dispose();
+                    this.processes.delete(key);
+                    // The one-shot fallback observes the complete current filesystem,
+                    // and a later sidecar starts cold, so neither needs old deltas.
+                    // A capability-aware host may still disappear or violate framing.
+                    // Preserve correctness by running the established one-shot command
+                    // for this cycle; the next cycle gets one clean respawn attempt.
+                    result = runNativePluginCommand(plugin, args, options, execution, "ttsc.check", { ...timing, enabled: false }, "");
+                }
+                recordTiming(timing, `ttsc check plugin ${plugin.name} time`, startedAt);
+            }
+            out = appendBuildOutput(out, result);
+            if (result.status !== 0)
+                return out;
+        }
+        return out;
+    }
+}
+exports.ResidentCheckWatchSession = ResidentCheckWatchSession;
+function projectInputSnapshotsEqual(left, right) {
+    const leftReloadFiles = left.reloadFiles ?? [];
+    const rightReloadFiles = right.reloadFiles ?? [];
+    const leftReloadDirectories = left.reloadDirectories ?? [];
+    const rightReloadDirectories = right.reloadDirectories ?? [];
+    return (left.root === right.root &&
+        left.files.length === right.files.length &&
+        left.globs.length === right.globs.length &&
+        leftReloadDirectories.length === rightReloadDirectories.length &&
+        leftReloadFiles.length === rightReloadFiles.length &&
+        left.files.every((value, index) => value === right.files[index]) &&
+        left.globs.every((value, index) => value === right.globs[index]) &&
+        leftReloadDirectories.every((value, index) => value === rightReloadDirectories[index]) &&
+        leftReloadFiles.every((value, index) => value === rightReloadFiles[index]));
+}
+function residentCheckExecutionIsCompatible(options, execution) {
+    return (options.emit === false &&
+        options.fix !== true &&
+        options.format !== true &&
+        forwardsTerminalTsgoFlag(options) === false &&
+        execution.nativePlugins.every((plugin) => plugin.stage === "check"));
+}
+function residentCheckProcessKey(plugin, args) {
+    return `${plugin.binary}\0${plugin.name}\0${JSON.stringify(args)}`;
+}
+/**
+ * Plan every configured check entry while sharing resident processes only by
+ * binary/name/argument identity.
+ */
+function planResidentCheckEntries(plugins, createArgs) {
+    return plugins
+        .filter((candidate) => candidate.stage === "check")
+        .map((plugin, entryIndex) => {
+        const args = createArgs(plugin);
+        return {
+            args,
+            entryIndex,
+            key: plugin.capabilities?.residentCheck === true
+                ? residentCheckProcessKey(plugin, args)
+                : undefined,
+            plugin,
+        };
+    });
+}
+/** Retain one complete change stream per configured resident check entry. */
+function bufferResidentCheckEntryRequests(pending, checks, request) {
+    for (const check of checks) {
+        if (check.key === undefined)
+            continue;
+        pending.set(check.entryIndex, mergeResidentCheckRequests(pending.get(check.entryIndex), request));
+    }
+}
+/** Consume exactly one configured entry's buffered request. */
+function takeResidentCheckEntryRequest(pending, entryIndex) {
+    const request = pending.get(entryIndex);
+    if (request === undefined) {
+        throw new Error(`ttsc: resident check entry ${String(entryIndex)} has no buffered request`);
+    }
+    pending.delete(entryIndex);
+    return request;
+}
+function residentCheckRequest(change, cwd) {
+    const normalize = (values) => [...new Set(values?.map((value) => node_path_1.default.resolve(cwd, value)) ?? [])].sort();
+    const changed = normalize(change.changed);
+    const external = normalize(change.external);
+    return {
+        ...(change.invalidate === true ? { invalidate: true } : {}),
+        ...(changed.length === 0 ? {} : { changed }),
+        ...(external.length === 0 ? {} : { external }),
+    };
+}
+function mergeResidentCheckRequests(previous, current) {
+    const merge = (left, right) => [...new Set([...(left ?? []), ...(right ?? [])])].sort();
+    const changed = merge(previous?.changed, current.changed);
+    const external = merge(previous?.external, current.external);
+    return {
+        ...(changed.length === 0 ? {} : { changed }),
+        ...(external.length === 0 ? {} : { external }),
+        ...(previous?.invalidate === true || current.invalidate === true
+            ? { invalidate: true }
+            : {}),
+    };
+}
 function runBuildTimed(options, timing) {
     const projectFree = runProjectFreeTerminalFlag(options);
     if (projectFree !== null)
         return projectFree;
     const setupStartedAt = process.hrtime.bigint();
     const execution = resolveExecutionContext(options);
-    options.onWatchInputs?.(execution.nativePlugins.flatMap((plugin) => [
-        plugin.source,
-        ...(plugin.contributors?.map((contributor) => contributor.source) ?? []),
-    ]));
+    return runBuildWithExecution(options, timing, execution, setupStartedAt);
+}
+function runBuildWithExecution(options, timing, execution, setupStartedAt) {
+    const prepared = prepareBuildExecution(options, timing, execution, setupStartedAt);
+    if (prepared.result !== undefined)
+        return prepared.result;
+    return runPreparedBuild(options, timing, execution, prepared.buildOptions);
+}
+function prepareBuildExecution(options, timing, execution, setupStartedAt) {
     if (execution.nativePlugins.length > 0 ||
         execution.pluginSetupFailure !== undefined) {
         recordTiming(timing, "ttsc plugin setup time", setupStartedAt);
     }
     const buildOptions = applyProjectNoEmit(options, execution);
     if (execution.pluginSetupFailure !== undefined) {
-        return appendTypeScriptDiagnosticsAfterPluginFailure(execution.pluginSetupFailure, buildOptions, execution);
+        return {
+            buildOptions,
+            result: appendTypeScriptDiagnosticsAfterPluginFailure(execution.pluginSetupFailure, buildOptions, execution),
+        };
     }
+    if (options.onProjectInputs !== undefined) {
+        options.onProjectInputs(discoverNativeProjectInputs(options, execution));
+    }
+    return { buildOptions };
+}
+function runPreparedBuild(options, timing, execution, buildOptions) {
     if (execution.nativePlugins.length > 0) {
         const compilers = execution.nativePlugins.filter((plugin) => plugin.stage === "transform");
         const checked = runNativeCheckPlugins(buildOptions, execution, timing);
@@ -612,6 +874,7 @@ function createTsgoBuildArgs(execution, options, flags) {
     args.push(...createTsgoDiagnosticArgs(options));
     args.push(...createTsgoThreadingArgs(options));
     args.push(...(options.passthrough ?? []));
+    args.push(...isolatedTsgoOutputArgs(options));
     if (flags.noEmitOnError === true) {
         args.push("--noEmitOnError");
     }
@@ -710,6 +973,18 @@ function createNativeCheckArgs(execution, options, plugin) {
     args.push(...createNativeTsgoArgs(options));
     return args;
 }
+function createNativeProjectInputsArgs(execution, plugin) {
+    const args = [
+        "project-inputs",
+        "--tsconfig=" + execution.tsconfig,
+        "--plugins-json=" + serializeNativePlugins(execution.nativePlugins),
+        "--cwd=" + execution.projectRoot,
+    ];
+    if (plugin.capabilities?.projectContextArgs === true) {
+        args.push(...(0, createNativeProjectContextArgs_1.createNativeProjectContextArgs)(execution.project, execution.pluginConfigDir));
+    }
+    return args;
+}
 // `--singleThreaded` / `--checkers` are forwarded to native check-stage hosts
 // only when the host is one ttsc itself owns (currently `@ttsc/lint`). #113
 // forwarded both flags as bare CLI tokens to every native sidecar, then
@@ -785,12 +1060,33 @@ function transformHostTimingLabel(plugins) {
  * single token so the sidecars' unknown-flag filters keep it intact.
  */
 function createNativeTsgoArgs(options) {
-    const passthrough = nativeTsgoPassthroughArgs(options);
-    if (passthrough === undefined || passthrough.length === 0) {
+    const passthrough = [
+        ...(nativeTsgoPassthroughArgs(options) ?? []),
+        ...isolatedTsgoOutputArgs(options),
+    ];
+    if (passthrough.length === 0) {
         return [];
     }
     return ["--tsgo-args=" + JSON.stringify(passthrough)];
 }
+function isolatedTsgoOutputArgs(options) {
+    const target = "isolateOutputsTo" in options &&
+        typeof options.isolateOutputsTo === "string"
+        ? node_path_1.default.resolve(options.isolateOutputsTo)
+        : undefined;
+    if (target === undefined)
+        return [];
+    return [
+        "--outFile",
+        "null",
+        "--declarationDir",
+        "null",
+        "--tsBuildInfoFile",
+        "null",
+        "--outDir",
+        target,
+    ];
+}
 function nativeTsgoPassthroughArgs(options) {
     const passthrough = options.passthrough;
     if (passthrough === undefined)
@@ -862,6 +1158,183 @@ function runNativeCheckPlugins(options, execution, timing) {
     }
     return out;
 }
+function discoverNativeProjectInputs(options, execution) {
+    const snapshots = [];
+    for (const plugin of execution.nativePlugins.filter((candidate) => candidate.stage === "check" &&
+        candidate.capabilities?.projectInputs === true)) {
+        const res = (0, spawnNative_1.spawnNative)(plugin.binary, createNativeProjectInputsArgs(execution, plugin), {
+            cwd: execution.projectRoot,
+            env: nativePluginEnv(options.env, execution, plugin),
+            encoding: "utf8",
+        });
+        if (res.error) {
+            throw new Error(`ttsc.project-inputs: failed to spawn ${plugin.binary}: ${res.error.message}`);
+        }
+        const stdout = (0, spawnNative_1.outputText)(res.stdout).trim();
+        if (res.status !== 0) {
+            const detail = (0, spawnNative_1.outputText)(res.stderr).trim() || stdout;
+            throw new Error(`ttsc.project-inputs: ${plugin.name ?? plugin.binary} failed${detail ? `: ${detail}` : ""}`);
+        }
+        const snapshot = parseProjectInputSnapshot(stdout, plugin);
+        snapshots.push(snapshot);
+    }
+    return mergeProjectInputSnapshots(execution.projectRoot, snapshots);
+}
+function arraysEqual(left, right) {
+    return (left.length === right.length && left.every((item, i) => item === right[i]));
+}
+/**
+ * Keep every declared spelling of one identity, ordered without regard to which
+ * producer ran first.
+ *
+ * Two contributors can name the same file through different aliases, and each
+ * alias is a path a watcher has to observe: keeping only one of them would
+ * discard the link whose retarget the other spelling exists to catch. Insertion
+ * order is not canonical, so the caller sorts the flattened result.
+ */
+function retainDeclaredSpelling(target, key, declared) {
+    const previous = target.get(key);
+    if (previous === undefined) {
+        target.set(key, [declared]);
+        return;
+    }
+    if (previous.includes(declared))
+        return;
+    previous.push(declared);
+}
+function mergeProjectInputSnapshots(fallbackRoot, snapshots, identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)()) {
+    const files = new Map();
+    const globs = new Map();
+    const reloadDirectories = new Map();
+    const reloadFiles = new Map();
+    // Deduplicated on the same identity keys, but holding what the contributors
+    // wrote. Normalization resolves a declaration through its symlinks, which is
+    // right for every comparison and wrong for the watcher that has to observe
+    // the link itself being retargeted.
+    const declaredFiles = new Map();
+    const declaredGlobs = new Map();
+    const declaredReloadDirectories = new Map();
+    const declaredReloadFiles = new Map();
+    const rootIdentity = identities.resolve(fallbackRoot);
+    for (const snapshot of snapshots) {
+        const candidateRoot = identities.resolve(snapshot.root);
+        if (rootIdentity.key !== candidateRoot.key) {
+            throw new Error(`ttsc.project-inputs: plugin root ${candidateRoot.path} differs from the selected project root ${rootIdentity.path}`);
+        }
+        for (const file of snapshot.files) {
+            const identity = identities.resolve(file);
+            files.set(identity.key, identity.path);
+            retainDeclaredSpelling(declaredFiles, identity.key, node_path_1.default.resolve(file));
+        }
+        for (const glob of snapshot.globs) {
+            const identity = identities.resolve(glob);
+            globs.set(identity.key, identity.path.split(node_path_1.default.sep).join("/"));
+            retainDeclaredSpelling(declaredGlobs, identity.key, node_path_1.default.resolve(glob).split(node_path_1.default.sep).join("/"));
+        }
+        for (const reloadFile of snapshot.reloadFiles ?? []) {
+            const identity = identities.resolve(reloadFile);
+            reloadFiles.set(identity.key, identity.path);
+            retainDeclaredSpelling(declaredReloadFiles, identity.key, node_path_1.default.resolve(reloadFile));
+        }
+        for (const reloadDirectory of snapshot.reloadDirectories ?? []) {
+            const identity = identities.resolve(reloadDirectory);
+            reloadDirectories.set(identity.key, identity.path);
+            retainDeclaredSpelling(declaredReloadDirectories, identity.key, node_path_1.default.resolve(reloadDirectory));
+        }
+    }
+    const normalized = {
+        root: rootIdentity.path,
+        files: [...files.values()].sort(),
+        globs: [...globs.values()].sort(),
+        reloadDirectories: [...reloadDirectories.values()].sort(),
+        reloadFiles: [...reloadFiles.values()].sort(),
+    };
+    const declared = {
+        files: [...declaredFiles.values()].flat().sort(),
+        globs: [...declaredGlobs.values()].flat().sort(),
+        reloadDirectories: [...declaredReloadDirectories.values()].flat().sort(),
+        reloadFiles: [...declaredReloadFiles.values()].flat().sort(),
+    };
+    // Carried only when it says something the normalized arrays do not. A tree
+    // with no alias on any declaration produces the same four lists, and a
+    // consumer that has to scan both would pay twice for one population.
+    return arraysEqual(declared.files, normalized.files) &&
+        arraysEqual(declared.globs, normalized.globs) &&
+        arraysEqual(declared.reloadDirectories, normalized.reloadDirectories) &&
+        arraysEqual(declared.reloadFiles, normalized.reloadFiles)
+        ? normalized
+        : { ...normalized, declared };
+}
+function parseProjectInputSnapshot(text, plugin) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`ttsc.project-inputs: ${plugin.name ?? plugin.binary} returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof value !== "object" ||
+        value === null ||
+        typeof value.root !== "string" ||
+        !isStringArray(value.files) ||
+        !isStringArray(value.globs) ||
+        (value.reloadDirectories !==
+            undefined &&
+            !isStringArray(value.reloadDirectories)) ||
+        (value.reloadFiles !== undefined &&
+            !isStringArray(value.reloadFiles))) {
+        throw new Error(`ttsc.project-inputs: ${plugin.name ?? plugin.binary} returned an invalid snapshot`);
+    }
+    const snapshot = value;
+    const invalid = [
+        ["root", snapshot.root],
+        ...snapshot.files.map((file) => ["file", file]),
+        ...snapshot.globs.map((glob) => ["glob", glob]),
+        ...(snapshot.reloadDirectories ?? []).map((directory) => ["reload directory", directory]),
+        ...(snapshot.reloadFiles ?? []).map((file) => ["reload file", file]),
+    ].find(([, location]) => location.length === 0 || !isAbsoluteLocalProjectInputPath(location));
+    if (invalid !== undefined) {
+        throw new Error(`ttsc.project-inputs: ${plugin.name ?? plugin.binary} returned an invalid snapshot: ${invalid[0]} ${JSON.stringify(invalid[1])} is not an absolute local path`);
+    }
+    return {
+        ...snapshot,
+        reloadDirectories: snapshot.reloadDirectories ?? [],
+        reloadFiles: snapshot.reloadFiles ?? [],
+    };
+}
+function isAbsoluteLocalProjectInputPath(location, platform = process.platform) {
+    if (location.includes("\0"))
+        return false;
+    if (platform !== "win32")
+        return node_path_1.default.posix.isAbsolute(location);
+    const normalized = location.replaceAll("/", "\\");
+    if (/^[A-Za-z]:\\/.test(normalized))
+        return true;
+    if (normalized.startsWith("\\\\?\\")) {
+        const extended = normalized.slice(4);
+        if (/^[A-Za-z]:\\/.test(extended))
+            return true;
+        if (extended.toLowerCase().startsWith("unc\\")) {
+            return isWindowsUncProjectInputPath(`\\\\${extended.slice(4)}`);
+        }
+        return false;
+    }
+    if (normalized.startsWith("\\\\.\\"))
+        return false;
+    return isWindowsUncProjectInputPath(normalized);
+}
+function isWindowsUncProjectInputPath(location) {
+    const matched = /^\\\\([^\\]+)\\([^\\]+)(?:\\|$)/.exec(location);
+    return (matched !== null &&
+        isWindowsUncVolumeSegment(matched[1]) &&
+        isWindowsUncVolumeSegment(matched[2]));
+}
+function isWindowsUncVolumeSegment(segment) {
+    return segment !== "." && segment !== ".." && !/[\0<>:"/\\|?*]/.test(segment);
+}
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((item) => typeof item === "string"));
+}
 /**
  * Spawn a single native plugin binary with the given args and return the
  * normalized build result. `label` is used in the thrown error message so the
@@ -943,11 +1416,15 @@ function resolveExecutionContext(options) {
                 cwd,
                 entries: options.plugins,
                 env: { ...process.env, ...options.env },
+                onWatchInputs: options.onWatchInputs,
                 pluginConfigDir: options.pluginConfigDir,
                 projectRoot,
                 tsconfig,
             }).nativePlugins;
         }
+        else {
+            options.onWatchInputs?.([]);
+        }
     }
     catch (error) {
         pluginSetupFailure = {