ttsc 0.31.6 → 0.32.1

package/lib/plugin/internal/load/loadProjectPlugins.js

@@ -9,11 +9,13 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
 const node_url_1 = require("node:url");
+const WatchInputPublication_1 = require("../../../compiler/internal/build/WatchInputPublication");
 const readJsonFile_1 = require("../../../compiler/internal/project/readJsonFile");
 const readProjectConfig_1 = require("../../../compiler/internal/project/readProjectConfig");
 const SidecarEnvironment_1 = require("../../../compiler/internal/sharedHost/SidecarEnvironment");
 const E2ETrace_1 = require("../../../internal/E2ETrace");
 const OwnedSynchronousProcess_1 = require("../../../internal/OwnedSynchronousProcess");
+const TtsxNodeOptions_1 = require("../../../internal/TtsxNodeOptions");
 const createCanonicalTempDirectory_1 = require("../../../internal/createCanonicalTempDirectory");
 const javascriptRuntimeCapabilities_1 = require("../../../internal/javascriptRuntimeCapabilities");
 const resolveNodeBinary_1 = require("../../../internal/resolveNodeBinary");
@@ -79,6 +81,9 @@ const visitImportMappedCandidates_1 = require("./visitImportMappedCandidates");
  * declaration. Sequential content, metadata and physical-path observations are
  * not an atomic snapshot or detection of every omitted read.
  *
+ * Synchronous callers require synchronous watch-input handlers; use
+ * {@link loadProjectPlugins.async} to await a worker's baseline publication.
+ *
  * @param options.binary - Absolute path to the ttsc native helper binary.
  * @param options.cacheDir - Override the plugin binary cache directory.
  * @param options.cwd - Working directory for resolving relative paths.
@@ -89,11 +94,12 @@ const visitImportMappedCandidates_1 = require("./visitImportMappedCandidates");
  *   native environment-name identity. Defaults to `process.env` for CLI
  *   callers, so ambient behavior is unchanged.
  * @param options.file - Path to the tsconfig/jsconfig file.
- * @param options.pluginConfigDir - Caller-declared anchor for plugin
- *   config-file discovery (see `ITtscPluginFactoryContext.pluginConfigDir`).
- * @param options.projectRoot - Override the project root directory.
+ * @param options.pluginConfigDir - Caller-declared consumer directory for
+ *   plugin packages, factory contexts and config-file discovery.
+ * @param options.projectRoot - Override the source root, native working
+ *   directory, cache anchor and returned relative Go-source base.
  * @param options.tsconfig - Alias for `file`.
- * @evidence contracts/common.md#principled-implementation The loader brackets project discovery observations, evaluates descriptors in isolated processes and validates declarations before publishing conservative source repair interests. Metadata refusal remains terminal; valid records narrow watch interests before final admission/build, while contradictory content or physical observations are omitted from proof rather than retroactively blessed.
+ * @evidence contracts/common.md#principled-implementation The loader brackets discovery at the selected config or explicit pluginConfigDir and factories receive that consumer anchor, independently of the source root retained for descriptor/native process cwd, caches and relative Go sources. It validates declarations before publishing conservative source repair interests. Metadata refusal remains terminal; valid records narrow watch interests before final admission/build, while contradictory content or physical observations are omitted from proof rather than retroactively blessed.
  * @evidence contracts/common.md#clear-and-simple-design The operation owns one ordered load generation; private helpers separate discovery, evaluation, validation, composition and proof merging, while package resolution and source building remain their own modules.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Descriptor module caches are isolated rather than deleting application singletons. ttsx retry occurs only for explicit supported TypeScript loader incompatibility, with plugins disabled to avoid recursive self-hosting; arbitrary descriptor failures are not retried into false success.
  * @evidence contracts/common.md#meaningful-documentation Native JSDoc explains result provenance, environment and path options; helper comments explain input races, conservative proof omission, fallback authority and cleanup. Member/tag spacing and separated concepts follow the documentation skill.
@@ -103,420 +109,463 @@ const visitImportMappedCandidates_1 = require("./visitImportMappedCandidates");
  * @evidence contracts/performance.md#bound-retention-and-release-resources Finally restores injected environment locators, attempts evaluator directory removal and closes direct-evaluator diagnostic descriptors. Close/removal can fail; synchronous completion concerns the selected evaluator and does not certify arbitrary descendants are gone. Generation maps/results scale with observed data, and disk diagnostics/result/observation files have no independent byte ceiling here. Default disk pruning has its own interval/protection/failure policy; explicit roots remain caller-owned.
  */
 function loadProjectPlugins(options) {
-    // Snapshot the caller environment before `withPluginLoaderEnv` injects
-    // host-owned Node/ttsx locators into process.env. Under a Bun parent the
-    // direct descriptor evaluator must remain Bun unless the caller explicitly
-    // selected another runtime.
-    const effectiveEnv = SidecarEnvironment_1.SidecarEnvironment.merge(options.env ?? process.env);
-    const projectSnapshot = readProjectHostInputSnapshot({
-        cwd: options.cwd,
-        file: options.file,
-        includePluginDiscovery: options.entries === undefined,
-        projectRoot: options.projectRoot,
-        tsconfig: options.tsconfig,
-    });
-    const { project } = projectSnapshot;
-    const projectHostInputs = projectSnapshot.hostInputs;
-    const projectHostInputHashes = projectSnapshot.hostInputHashes;
-    const projectHostInputRealpaths = projectSnapshot.hostInputRealpaths;
-    const entries = options.entries === false
-        ? []
-        : ProjectPluginEntries_1.ProjectPluginEntries.resolvePluginEntries(project, options.entries).filter((entry) => entry.config.enabled !== false);
-    if (entries.length === 0) {
-        options.onWatchInputs?.([]);
-        return {
-            ...collectHostInputSnapshot(project, {}, [], projectHostInputs, revalidateHostInputHashes(projectHostInputHashes, projectHostInputs), revalidateHostInputRealpaths(projectHostInputRealpaths, projectHostInputs)),
-            descriptorReadsDeclared: true,
-            discoveryInputsComplete: project.configInputsComplete === true,
-            nativePlugins: [],
-            pluginSources: {},
-            project,
-        };
+    return WatchInputPublication_1.WatchInputPublication.run(loadProjectPlugins.steps(options));
+}
+/**
+ * Keep synchronous loading and awaited watch handoffs on one load sequence.
+ *
+ * @evidence contracts/common.md#principled-implementation Both completion modes advance one ordered discovery, admission, publication and build sequence. Awaited stepping preserves baseline-before-read handoffs before package selection and source builds, including empty selection and conservative repair roots.
+ * @evidence contracts/common.md#clear-and-simple-design The namespace adds an awaited runner beside synchronous loading and exposes one generator to build orchestration; existing helpers retain discovery, validation and compilation responsibilities.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Publication suspension retains failed-build interests and source proof rather than rebuilding a baseline after compilation. Pending publication cannot establish observation; rejection enters the real load failure path without replacing admission or native builds.
+ * @evidence contracts/common.md#meaningful-documentation Entry prose distinguishes completion modes, baseline-before-read ordering and internal sequence completion/rejection duties; the primary loader documents input and result provenance.
+ * @evidence contracts/portability.md#os-neutral-implementation The shared sequence retains existing native resolution, paths, environment and argument-array handling; the namespace adds no independent boundary.
+ * @evidence contracts/performance.md#efficient-algorithms Discovery, source hashing, Go metadata, validation and builds retain their original input costs; each publication adds one suspension without repeating those phases.
+ * @evidence contracts/performance.md#reuse-equivalent-work Validated descriptor/source records and load-local digest/reader sharing remain available across suspension; the completion wrapper retains no reusable load or in-flight cache.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One load generation stays live while its current handoff settles; evaluator cleanup and returned-generation ownership remain with the sequence, and handler rejection enters generator cleanup.
+ */
+(function (loadProjectPlugins) {
+    /**
+     * Load plugins after each watch owner confirms its reported input baseline. A
+     * rejected handoff fails loading before the next source read or build.
+     */
+    function async(options) {
+        return WatchInputPublication_1.WatchInputPublication.runAsync(steps(options));
     }
-    const cwd = node_path_1.default.resolve(options.cwd ?? process.cwd());
-    const context = {
-        binary: options.binary,
-        cwd,
-        ...(options.pluginConfigDir === undefined || options.pluginConfigDir === ""
-            ? {}
-            : { pluginConfigDir: node_path_1.default.resolve(cwd, options.pluginConfigDir) }),
-        projectRoot: project.root,
-        tsconfig: project.path,
-    };
-    // Where isolated descriptor evaluations keep their answers across launches
-    // (`PluginDescriptorEvaluationCache`).
-    // WARNING (#1721, #1722, #1723): a warm load must prove its unchanged inputs
-    // from this store, not re-read them. Every launch is a new process, so any
-    // module-level memo of this load's work dies with it; a 27 s warm typia
-    // launch whose native build took 0.28 s is what that looked like.
-    const identities = options.identities ??
-        PluginContentIdentities_1.PluginContentIdentities.open({
-            projectRoot: project.root,
-            cacheDir: options.cacheDir,
-            env: effectiveEnv,
+    loadProjectPlugins.async = async;
+    /**
+     * Produce one load, suspending at each watch-input handoff before continuing.
+     * Internal build orchestration consumes the whole sequence with its chosen
+     * completion runner; it must deliver rejection back into the sequence.
+     */
+    function* steps(options) {
+        // Snapshot the caller environment before `withPluginLoaderEnv` injects
+        // host-owned Node/ttsx locators into process.env. Under a Bun parent the
+        // direct descriptor evaluator must remain Bun unless the caller explicitly
+        // selected another runtime.
+        const effectiveEnv = SidecarEnvironment_1.SidecarEnvironment.merge(options.env ?? process.env);
+        const projectSnapshot = readProjectHostInputSnapshot({
+            cwd: options.cwd,
+            file: options.file,
+            includePluginDiscovery: options.entries === undefined,
+            pluginConfigDir: options.pluginConfigDir,
+            projectRoot: options.projectRoot,
+            tsconfig: options.tsconfig,
         });
-    const descriptorCache = {
-        cacheDir: options.cacheDir,
-        identities,
-        version: (0, pluginBuildVersions_1.pluginBuildVersions)(project.root).ttsc,
-    };
-    const loadedEntries = withPluginLoaderEnv(() => entries.map((entry) => {
-        const specifier = entry.config.transform;
-        if (typeof specifier !== "string" || specifier.length === 0) {
-            throw new Error(`ttsc: plugin entry is missing a string "transform" field`);
-        }
-        const entryParent = node_path_1.default.join(entry.baseDir, "package.json");
-        const probedCandidates = collectModuleResolutionCandidates(specifier, entryParent, undefined);
-        // Capture every candidate before resolution chooses the descriptor entry.
-        // A post-resolution snapshot could bless a higher-priority file created
-        // after the resolver had already selected the old entry.
-        const probedCandidateHashes = (0, hashHostInputPaths_1.hashHostInputPaths)(probedCandidates);
-        const probedCandidateRealpaths = (0, realpathHostInputPaths_1.realpathHostInputPaths)(probedCandidates);
-        const request = PluginPackageResolution_1.PluginPackageResolution.resolvePluginRequest(specifier, entry.baseDir);
-        // Keep the candidates of the search roots up to the one the entry
-        // resolved in: the lookup never read the roots after it
-        // (`moduleResolutionBaseSelects`).
-        const read = new Set(collectModuleResolutionCandidates(specifier, entryParent, request).map((candidate) => node_path_1.default.resolve(candidate)));
-        const entryCandidates = probedCandidates.filter((candidate) => read.has(node_path_1.default.resolve(candidate)));
-        const entryCandidateHashes = pickHostInputEntries(probedCandidateHashes, entryCandidates);
-        const entryCandidateRealpaths = pickHostInputEntries(probedCandidateRealpaths, entryCandidates);
-        const loaded = loadPluginEntry(entry.config, { ...context, plugin: entry.config }, request, effectiveEnv, descriptorCache);
-        const loadedHostInputHashes = mergeObservedHostInputHashes(loaded.hostInputHashes, (0, hashHostInputPaths_1.hashHostInputPaths)(Object.keys(loaded.hostInputHashes)));
-        const loadedHostInputRealpaths = mergeObservedHostInputRealpaths(loaded.hostInputRealpaths, (0, realpathHostInputPaths_1.realpathHostInputPaths)(Object.keys(loaded.hostInputRealpaths)));
-        const hostInputHashes = mergeObservedHostInputHashes(entryCandidateHashes, loadedHostInputHashes);
-        const hostInputRealpaths = mergeObservedHostInputRealpaths(entryCandidateRealpaths, loadedHostInputRealpaths);
-        for (const input of loaded.hostInputs) {
-            const absolute = node_path_1.default.resolve(input);
-            if (!Object.prototype.hasOwnProperty.call(loadedHostInputHashes, absolute)) {
-                delete hostInputHashes[absolute];
-            }
+        const { project } = projectSnapshot;
+        const projectHostInputs = projectSnapshot.hostInputs;
+        const projectHostInputHashes = projectSnapshot.hostInputHashes;
+        const projectHostInputRealpaths = projectSnapshot.hostInputRealpaths;
+        const entries = options.entries === false
+            ? []
+            : ProjectPluginEntries_1.ProjectPluginEntries.resolvePluginEntries(project, options.entries, options.pluginConfigDir).filter((entry) => entry.config.enabled !== false);
+        if (entries.length === 0) {
+            yield options.onWatchInputs?.([]);
+            return {
+                ...collectHostInputSnapshot(project, {}, [], projectHostInputs, revalidateHostInputHashes(projectHostInputHashes, projectHostInputs), revalidateHostInputRealpaths(projectHostInputRealpaths, projectHostInputs)),
+                descriptorReadsDeclared: true,
+                discoveryInputsComplete: project.configInputsComplete === true,
+                nativePlugins: [],
+                pluginSources: {},
+                project,
+            };
         }
-        return {
-            ...loaded,
-            hostInputHashes,
-            hostInputRealpaths,
-            hostInputs: [...loaded.hostInputs, ...entryCandidates],
-            request,
+        const cwd = node_path_1.default.resolve(options.cwd ?? process.cwd());
+        const context = {
+            binary: options.binary,
+            cwd,
+            ...(options.pluginConfigDir === undefined ||
+                options.pluginConfigDir === ""
+                ? {}
+                : { pluginConfigDir: node_path_1.default.resolve(cwd, options.pluginConfigDir) }),
+            projectRoot: project.root,
+            tsconfig: project.path,
         };
-    }), identities);
-    const plugins = (0, composePluginSources_1.composePluginSources)(entries, loadedEntries.map((entry) => entry.plugin));
-    const { ttsc: ttscVersion, tsgo: tsgoVersion } = (0, pluginBuildVersions_1.pluginBuildVersions)(context.projectRoot);
-    const candidates = plugins
-        .map((plugin, index) => {
-        const stage = PluginDescriptorAdmission_1.PluginDescriptorAdmission.stage(plugin);
-        (0, validatePluginSource_1.validatePluginSource)(plugin);
-        const contributors = (0, validatePluginContributors_1.validatePluginContributors)(plugin);
-        const source = resolvePluginSource(plugin.source, context.projectRoot);
-        const label = (0, pluginLabel_1.pluginLabel)(plugin, entries[index].config, index);
-        (0, requirePluginSource_1.requirePluginSource)(source, label);
-        return { plugin, index, stage, contributors, source, label };
-    })
-        .map((candidate) => ({
-        ...candidate,
-        ...(0, resolvePluginGoModule_1.resolvePluginGoModule)(candidate.source, candidate.label),
-    }));
-    // One reading of each source directory, shared by package selection and
-    // every build below and reported as the state the binaries were keyed on.
-    const sourceDigests = new Map();
-    // And one reading of the environment each build directory is keyed on, which
-    // a plugin module root's state reports as it is.
-    const environmentDigests = new Map();
-    // With the witness of each such reading, so a build of a directory package
-    // selection already read keys on that reading instead of probing Go again.
-    const environmentWitnesses = new Map();
-    const readings = {
-        sources: sourceDigests,
-        environments: environmentDigests,
-        witnesses: environmentWitnesses,
-    };
-    // Records describing sources must never land inside one, so the store is
-    // admitted for source proofs only once every source of the load is known.
-    const sourceIdentities = PluginContentIdentities_1.PluginContentIdentities.outside(identities, [
-        ...candidates.flatMap((candidate) => [
-            candidate.moduleRoot,
-            candidate.packageDir,
-            ...(candidate.contributors ?? []).map((input) => input.source),
-        ]),
-        ...SourcePluginWorkspace_1.SourcePluginWorkspace.findTtscOverlayDirs(),
-    ]);
-    // One fixed-effective-environment load owns manifest syntax sharing from the
-    // first watch query through metadata and builds. Do not allocate this after
-    // watch projection: that silently repeats selected-Go work (#1712).
-    const packageReaders = new Map();
-    const watchReplacements = options.onWatchInputs === undefined
-        ? undefined
-        : new Map();
-    if (options.onWatchInputs !== undefined) {
-        // The prospective context reads the admitted module layout and anchors its
-        // tool there before kind exists. Keep both possible final-root baselines:
-        // a linked package keeps packageDir, and an executable keeps moduleRoot.
-        const interests = new Set(candidates
-            .flatMap((candidate) => [
-            candidate.moduleRoot,
-            candidate.packageDir,
-            ...(candidate.contributors ?? []).map((input) => input.source),
-        ])
-            .filter(reportsPluginSource));
-        // WARNING (#1728): hand the watch owner this load's store with the roots.
-        // It baselines each root before any build reads it; without the store it
-        // read every source the load proves from records a moment later.
-        options.onWatchInputs([...interests].sort(), sourceIdentities);
-        const initialSize = interests.size;
-        for (const candidate of candidates) {
-            // Nested source-only proposals replace the outer root manifests. Do not
-            // activate their irrelevant module graph just to discover watch inputs.
-            if (candidate.stage === "transform" && candidate.entry !== ".")
-                continue;
-            for (const directory of pluginReplacementWatchDirectories(candidate.moduleRoot, effectiveEnv, watchReplacements, packageReaders))
-                if (reportsPluginSource(directory))
-                    interests.add(directory);
-        }
-        if (interests.size !== initialSize)
-            options.onWatchInputs([...interests].sort(), sourceIdentities);
-    }
-    const proposals = NativeSourcePackages_1.NativeSourcePackages.propose(candidates.map((candidate) => ({
-        ...candidate,
-        ownModule: candidate.stage !== "transform",
-    })), effectiveEnv, packageReaders, sourceIdentities, readings);
-    const records = candidates.map(({ plugin, index, stage, contributors, source, packageDir }) => {
-        const { kind, moduleRoot } = (0, resolveNativeSource_1.resolveNativeSource)(source, plugin, entries[index].config, index, {
-            env: effectiveEnv,
-            observation: proposals[index].observation,
-        });
-        if (kind === "linked" && stage !== "transform") {
-            throw new Error(`ttsc: plugin "${(0, pluginLabel_1.pluginLabel)(plugin, entries[index].config, index)}" source is a linked Go package, but only transform-stage plugins can be linked into a compiler host`);
-        }
-        const linkedContributorName = kind === "linked"
-            ? `linked_${String(index).padStart(6, "0")}`
-            : undefined;
-        const hostInputs = validatePluginHostInputs(plugin, index);
-        const pluginHostInputHashes = validatePluginHostInputHashes(plugin, index, hostInputs);
-        const pluginHostInputRealpaths = validatePluginHostInputRealpaths(plugin, index, hostInputs);
-        return {
-            capabilities: plugin.capabilities,
-            contributors,
-            config: entries[index].config,
-            kind,
-            label: (0, pluginLabel_1.pluginLabel)(plugin, entries[index].config, index),
-            linkedContributorName,
-            name: plugin.name,
-            reportsTypeScriptDiagnostics: plugin.reportsTypeScriptDiagnostics === true,
-            request: loadedEntries[index].request,
-            hostInputHashes: mergePluginHostInputHashes(loadedEntries[index].hostInputHashes, pluginHostInputHashes, loadedEntries[index].hostInputs, hostInputs),
-            hostInputRealpaths: mergePluginHostInputHashes(loadedEntries[index].hostInputRealpaths, pluginHostInputRealpaths, loadedEntries[index].hostInputs, hostInputs),
-            hostInputs: [...loadedEntries[index].hostInputs, ...hostInputs],
-            moduleRoot,
-            packageDir,
-            source,
-            stage,
+        // Where isolated descriptor evaluations keep their answers across launches
+        // (`PluginDescriptorEvaluationCache`).
+        // WARNING (#1721, #1722, #1723): a warm load must prove its unchanged inputs
+        // from this store, not re-read them. Every launch is a new process, so any
+        // module-level memo of this load's work dies with it; a 27 s warm typia
+        // launch whose native build took 0.28 s is what that looked like.
+        const identities = options.identities ??
+            PluginContentIdentities_1.PluginContentIdentities.open({
+                projectRoot: project.root,
+                cacheDir: options.cacheDir,
+                env: effectiveEnv,
+            });
+        const descriptorCache = {
+            cacheDir: options.cacheDir,
+            identities,
+            projectRoot: project.root,
+            version: (0, pluginBuildVersions_1.pluginBuildVersions)(project.root).ttsc,
         };
-    });
-    const executableCandidates = candidates.filter((candidate) => records[candidate.index].kind === "executable" &&
-        !proposals[candidate.index].ownModule);
-    const buildDirectories = pluginBuildDirectories(records, effectiveEnv, watchReplacements, packageReaders);
-    // Admission can now narrow the provisional interests without restamping the
-    // retained package/module baselines. Final host errors still keep these roots.
-    options.onWatchInputs?.(buildDirectories, sourceIdentities);
-    const keyedDirectories = new Set(buildDirectories);
-    const linkedContributors = records
-        .filter((record) => record.stage === "transform")
-        .flatMap((record) => record.kind === "linked"
-        ? [{ name: record.linkedContributorName, source: record.source }]
-        : []);
-    const transformHosts = records.filter((record) => record.stage === "transform" && record.kind === "executable");
-    const hostContributors = linkedContributors.length === 0 ? undefined : linkedContributors;
-    // Every host compiles the linked sources under its own module/tool context.
-    // Equivalent entries in one module share this metadata command and reader;
-    // a second executable host can select a genuinely different Go context.
-    const admittedExecutables = new Set();
-    if (linkedContributors.length !== 0) {
-        const hosts = transformHosts.length === 0
-            ? [
-                {
-                    source: node_path_1.default.join(ttscPackageRoot(), "cmd", "utility-host"),
-                    label: "linked-plugin-host",
-                },
-            ]
-            : transformHosts;
-        const contexts = new Map();
-        for (const host of hosts) {
-            const moduleRoot = (0, resolvePluginGoModule_1.resolvePluginGoModule)(host.source, host.label).moduleRoot;
-            let context = contexts.get(moduleRoot);
-            if (context === undefined) {
-                context = { source: host.source, label: host.label, records: [] };
-                contexts.set(moduleRoot, context);
+        const loadedEntries = withPluginLoaderEnv(() => entries.map((entry) => {
+            const specifier = entry.config.transform;
+            if (typeof specifier !== "string" || specifier.length === 0) {
+                throw new Error(`ttsc: plugin entry is missing a string "transform" field`);
             }
+            const entryParent = node_path_1.default.join(entry.baseDir, "package.json");
+            const probedCandidates = collectModuleResolutionCandidates(specifier, entryParent, undefined);
+            // Capture every candidate before resolution chooses the descriptor entry.
+            // A post-resolution snapshot could bless a higher-priority file created
+            // after the resolver had already selected the old entry.
+            const probedCandidateHashes = (0, hashHostInputPaths_1.hashHostInputPaths)(probedCandidates);
+            const probedCandidateRealpaths = (0, realpathHostInputPaths_1.realpathHostInputPaths)(probedCandidates);
+            const request = PluginPackageResolution_1.PluginPackageResolution.resolvePluginRequest(specifier, entry.baseDir);
+            // Keep the candidates of the search roots up to the one the entry
+            // resolved in: the lookup never read the roots after it
+            // (`moduleResolutionBaseSelects`).
+            const read = new Set(collectModuleResolutionCandidates(specifier, entryParent, request).map((candidate) => node_path_1.default.resolve(candidate)));
+            const entryCandidates = probedCandidates.filter((candidate) => read.has(node_path_1.default.resolve(candidate)));
+            const entryCandidateHashes = pickHostInputEntries(probedCandidateHashes, entryCandidates);
+            const entryCandidateRealpaths = pickHostInputEntries(probedCandidateRealpaths, entryCandidates);
+            const loaded = loadPluginEntry(entry.config, {
+                ...context,
+                plugin: entry.config,
+                // Package factories such as typia resolve their own package from
+                // this consumer anchor. Keep the compiler source root below for
+                // native cwd, cache ownership and returned relative Go sources.
+                projectRoot: ProjectPluginEntries_1.ProjectPluginEntries.resolvePluginBaseDir(project, options.pluginConfigDir),
+            }, request, effectiveEnv, descriptorCache);
+            const loadedHostInputHashes = mergeObservedHostInputHashes(loaded.hostInputHashes, (0, hashHostInputPaths_1.hashHostInputPaths)(Object.keys(loaded.hostInputHashes)));
+            const loadedHostInputRealpaths = mergeObservedHostInputRealpaths(loaded.hostInputRealpaths, (0, realpathHostInputPaths_1.realpathHostInputPaths)(Object.keys(loaded.hostInputRealpaths)));
+            const hostInputHashes = mergeObservedHostInputHashes(entryCandidateHashes, loadedHostInputHashes);
+            const hostInputRealpaths = mergeObservedHostInputRealpaths(entryCandidateRealpaths, loadedHostInputRealpaths);
+            for (const input of loaded.hostInputs) {
+                const absolute = node_path_1.default.resolve(input);
+                if (!Object.prototype.hasOwnProperty.call(loadedHostInputHashes, absolute)) {
+                    delete hostInputHashes[absolute];
+                }
+            }
+            return {
+                ...loaded,
+                hostInputHashes,
+                hostInputRealpaths,
+                hostInputs: [...loaded.hostInputs, ...entryCandidates],
+                request,
+            };
+        }), identities);
+        const plugins = (0, composePluginSources_1.composePluginSources)(entries, loadedEntries.map((entry) => entry.plugin));
+        const { ttsc: ttscVersion, tsgo: tsgoVersion } = (0, pluginBuildVersions_1.pluginBuildVersions)(context.projectRoot);
+        const candidates = plugins
+            .map((plugin, index) => {
+            const stage = PluginDescriptorAdmission_1.PluginDescriptorAdmission.stage(plugin);
+            (0, validatePluginSource_1.validatePluginSource)(plugin);
+            const contributors = (0, validatePluginContributors_1.validatePluginContributors)(plugin);
+            const source = resolvePluginSource(plugin.source, context.projectRoot);
+            const label = (0, pluginLabel_1.pluginLabel)(plugin, entries[index].config, index);
+            (0, requirePluginSource_1.requirePluginSource)(source, label);
+            return { plugin, index, stage, contributors, source, label };
+        })
+            .map((candidate) => ({
+            ...candidate,
+            ...(0, resolvePluginGoModule_1.resolvePluginGoModule)(candidate.source, candidate.label),
+        }));
+        // One reading of each source directory, shared by package selection and
+        // every build below and reported as the state the binaries were keyed on.
+        const sourceDigests = new Map();
+        // And one reading of the environment each build directory is keyed on, which
+        // a plugin module root's state reports as it is.
+        const environmentDigests = new Map();
+        // With the witness of each such reading, so a build of a directory package
+        // selection already read keys on that reading instead of probing Go again.
+        const environmentWitnesses = new Map();
+        const readings = {
+            sources: sourceDigests,
+            environments: environmentDigests,
+            witnesses: environmentWitnesses,
+        };
+        // Records describing sources must never land inside one, so the store is
+        // admitted for source proofs only once every source of the load is known.
+        const sourceIdentities = PluginContentIdentities_1.PluginContentIdentities.outside(identities, [
+            ...candidates.flatMap((candidate) => [
+                candidate.moduleRoot,
+                candidate.packageDir,
+                ...(candidate.contributors ?? []).map((input) => input.source),
+            ]),
+            ...SourcePluginWorkspace_1.SourcePluginWorkspace.findTtscOverlayDirs(),
+        ]);
+        // One fixed-effective-environment load owns manifest syntax sharing from the
+        // first watch query through metadata and builds. Do not allocate this after
+        // watch projection: that silently repeats selected-Go work (#1712).
+        const packageReaders = new Map();
+        const watchReplacements = options.onWatchInputs === undefined
+            ? undefined
+            : new Map();
+        if (options.onWatchInputs !== undefined) {
+            // The prospective context reads the admitted module layout and anchors its
+            // tool there before kind exists. Keep both possible final-root baselines:
+            // a linked package keeps packageDir, and an executable keeps moduleRoot.
+            const interests = new Set(candidates
+                .flatMap((candidate) => [
+                candidate.moduleRoot,
+                candidate.packageDir,
+                ...(candidate.contributors ?? []).map((input) => input.source),
+            ])
+                .filter(reportsPluginSource));
+            // WARNING (#1728): hand the watch owner this load's store with the roots.
+            // It baselines each root before any build reads it; without the store it
+            // read every source the load proves from records a moment later.
+            // A worker owns the watch baseline now. Complete this handoff before Go
+            // metadata or source proof consumes the roots, preserving #1728 (#1758).
+            yield options.onWatchInputs([...interests].sort(), sourceIdentities);
+            const initialSize = interests.size;
+            for (const candidate of candidates) {
+                // Nested source-only proposals replace the outer root manifests. Do not
+                // activate their irrelevant module graph just to discover watch inputs.
+                if (candidate.stage === "transform" && candidate.entry !== ".")
+                    continue;
+                for (const directory of pluginReplacementWatchDirectories(candidate.moduleRoot, effectiveEnv, watchReplacements, packageReaders, sourceIdentities))
+                    if (reportsPluginSource(directory))
+                        interests.add(directory);
+            }
+            if (interests.size !== initialSize)
+                yield options.onWatchInputs([...interests].sort(), sourceIdentities);
         }
-        for (const record of transformHosts)
-            contexts.get(record.moduleRoot).records.push(record);
-        for (const host of contexts.values()) {
-            const moduleHosts = host.records;
-            const hostEntries = moduleHosts.map((record) => ({
-                entry: (0, resolvePluginGoModule_1.resolvePluginGoModule)(record.source, record.label).entry,
-            }));
-            const observations = NativeSourcePackages_1.NativeSourcePackages.inspect({
-                source: host.source,
-                pluginName: host.label,
+        const proposals = NativeSourcePackages_1.NativeSourcePackages.propose(candidates.map((candidate) => ({
+            ...candidate,
+            ownModule: candidate.stage !== "transform",
+        })), effectiveEnv, packageReaders, sourceIdentities, readings);
+        const records = candidates.map(({ plugin, index, stage, contributors, source, packageDir }) => {
+            const { kind, moduleRoot } = (0, resolveNativeSource_1.resolveNativeSource)(source, plugin, entries[index].config, index, {
                 env: effectiveEnv,
-                readers: packageReaders,
-                identities: sourceIdentities,
-                readings,
-                packages: [
-                    ...hostEntries,
-                    ...linkedContributors.map((input) => ({
-                        ...input,
-                        entry: `./contrib/${input.name}`,
-                    })),
-                ],
-            });
-            moduleHosts.forEach((record, index) => {
-                NativeSourcePackages_1.NativeSourcePackages.kind(observations[index], record.label, "executable");
-                admittedExecutables.add(record.source);
+                observation: proposals[index].observation,
             });
-            linkedContributors.forEach((input, index) => {
-                NativeSourcePackages_1.NativeSourcePackages.kind(observations[hostEntries.length + index], `${input.name} inside host ${host.label}`, "linked");
-            });
-        }
-    }
-    // A nested main proposal still needs its actual owning manifests. Hosts
-    // with linked contributors were admitted together above; other equivalent
-    // entries share one standalone observation, with no repeated host copy.
-    const standaloneCandidates = executableCandidates.filter((candidate) => !admittedExecutables.has(candidate.source));
-    const executablePackages = NativeSourcePackages_1.NativeSourcePackages.ownPackages(standaloneCandidates, effectiveEnv, packageReaders, sourceIdentities, readings);
-    standaloneCandidates.forEach((candidate, index) => {
-        NativeSourcePackages_1.NativeSourcePackages.kind(executablePackages[index], candidate.label, "executable");
-    });
-    const packageOwnership = (source, label, linked) => [
-        {
-            entry: (0, resolvePluginGoModule_1.resolvePluginGoModule)(source, label).entry,
-            kind: "executable",
-        },
-        ...(linked
-            ? linkedContributors.map((input) => ({
-                entry: `./contrib/${input.name}`,
-                kind: "linked",
-            }))
-            : []),
-    ];
-    const builtTransformHosts = new Map();
-    for (const record of transformHosts) {
-        builtTransformHosts.set(record, (0, buildSourcePlugin_1.buildSourcePlugin)({
-            baseDir: context.projectRoot,
-            cacheDir: options.cacheDir,
-            contributors: mergeContributors(record.contributors, hostContributors),
-            env: effectiveEnv,
-            goModReaders: packageReaders,
-            identities: sourceIdentities,
-            pluginName: record.label,
-            packageOwnership: packageOwnership(record.source, record.label, true),
-            source: record.source,
-            environmentDigests,
-            environmentWitnesses,
-            sourceDigests,
-            ttscVersion,
-            tsgoVersion,
-        }));
-    }
-    const fallbackDriverHost = transformHosts.length === 0 && linkedContributors.length !== 0
-        ? (0, buildSourcePlugin_1.buildSourcePlugin)({
-            baseDir: context.projectRoot,
-            cacheDir: options.cacheDir,
-            contributors: linkedContributors,
-            env: effectiveEnv,
-            goModReaders: packageReaders,
-            identities: sourceIdentities,
-            label: "linked plugin host",
-            pluginName: "linked-plugin-host",
-            source: node_path_1.default.join(ttscPackageRoot(), "cmd", "utility-host"),
-            packageOwnership: packageOwnership(node_path_1.default.join(ttscPackageRoot(), "cmd", "utility-host"), "linked-plugin-host", true),
-            environmentDigests,
-            environmentWitnesses,
-            sourceDigests,
-            ttscVersion,
-            tsgoVersion,
-        })
-        : undefined;
-    const selectedTransformHost = transformHosts.length === 0
-        ? fallbackDriverHost
-        : builtTransformHosts.get(transformHosts[0]);
-    const nativePlugins = records.map((record) => {
-        const binary = record.stage === "transform" && record.kind === "linked"
-            ? selectedTransformHost
-            : record.stage === "transform"
-                ? builtTransformHosts.get(record)
-                : (0, buildSourcePlugin_1.buildSourcePlugin)({
-                    baseDir: context.projectRoot,
-                    cacheDir: options.cacheDir,
-                    contributors: record.contributors,
+            if (kind === "linked" && stage !== "transform") {
+                throw new Error(`ttsc: plugin "${(0, pluginLabel_1.pluginLabel)(plugin, entries[index].config, index)}" source is a linked Go package, but only transform-stage plugins can be linked into a compiler host`);
+            }
+            const linkedContributorName = kind === "linked"
+                ? `linked_${String(index).padStart(6, "0")}`
+                : undefined;
+            const hostInputs = validatePluginHostInputs(plugin, index);
+            const pluginHostInputHashes = validatePluginHostInputHashes(plugin, index, hostInputs);
+            const pluginHostInputRealpaths = validatePluginHostInputRealpaths(plugin, index, hostInputs);
+            return {
+                capabilities: plugin.capabilities,
+                contributors,
+                config: entries[index].config,
+                kind,
+                label: (0, pluginLabel_1.pluginLabel)(plugin, entries[index].config, index),
+                linkedContributorName,
+                name: plugin.name,
+                reportsTypeScriptDiagnostics: plugin.reportsTypeScriptDiagnostics === true,
+                request: loadedEntries[index].request,
+                hostInputHashes: mergePluginHostInputHashes(loadedEntries[index].hostInputHashes, pluginHostInputHashes, loadedEntries[index].hostInputs, hostInputs),
+                hostInputRealpaths: mergePluginHostInputHashes(loadedEntries[index].hostInputRealpaths, pluginHostInputRealpaths, loadedEntries[index].hostInputs, hostInputs),
+                hostInputs: [...loadedEntries[index].hostInputs, ...hostInputs],
+                moduleRoot,
+                packageDir,
+                source,
+                stage,
+            };
+        });
+        const executableCandidates = candidates.filter((candidate) => records[candidate.index].kind === "executable" &&
+            !proposals[candidate.index].ownModule);
+        const buildDirectories = pluginBuildDirectories(records, effectiveEnv, watchReplacements, packageReaders, sourceIdentities);
+        // Admission can now narrow the provisional interests without restamping the
+        // retained package/module baselines. Final host errors still keep these roots.
+        yield options.onWatchInputs?.(buildDirectories, sourceIdentities);
+        const keyedDirectories = new Set(buildDirectories);
+        const linkedContributors = records
+            .filter((record) => record.stage === "transform")
+            .flatMap((record) => record.kind === "linked"
+            ? [{ name: record.linkedContributorName, source: record.source }]
+            : []);
+        const transformHosts = records.filter((record) => record.stage === "transform" && record.kind === "executable");
+        const hostContributors = linkedContributors.length === 0 ? undefined : linkedContributors;
+        // Every host compiles the linked sources under its own module/tool context.
+        // Equivalent entries in one module share this metadata command and reader;
+        // a second executable host can select a genuinely different Go context.
+        const admittedExecutables = new Set();
+        if (linkedContributors.length !== 0) {
+            const hosts = transformHosts.length === 0
+                ? [
+                    {
+                        source: node_path_1.default.join(ttscPackageRoot(), "cmd", "utility-host"),
+                        label: "linked-plugin-host",
+                    },
+                ]
+                : transformHosts;
+            const contexts = new Map();
+            for (const host of hosts) {
+                const moduleRoot = (0, resolvePluginGoModule_1.resolvePluginGoModule)(host.source, host.label).moduleRoot;
+                let context = contexts.get(moduleRoot);
+                if (context === undefined) {
+                    context = { source: host.source, label: host.label, records: [] };
+                    contexts.set(moduleRoot, context);
+                }
+            }
+            for (const record of transformHosts)
+                contexts.get(record.moduleRoot).records.push(record);
+            for (const host of contexts.values()) {
+                const moduleHosts = host.records;
+                const hostEntries = moduleHosts.map((record) => ({
+                    entry: (0, resolvePluginGoModule_1.resolvePluginGoModule)(record.source, record.label).entry,
+                }));
+                const observations = NativeSourcePackages_1.NativeSourcePackages.inspect({
+                    source: host.source,
+                    pluginName: host.label,
                     env: effectiveEnv,
-                    goModReaders: packageReaders,
+                    readers: packageReaders,
                     identities: sourceIdentities,
-                    pluginName: record.label,
-                    packageOwnership: packageOwnership(record.source, record.label, false),
-                    source: record.source,
-                    environmentDigests,
-                    environmentWitnesses,
-                    sourceDigests,
-                    ttscVersion,
-                    tsgoVersion,
+                    readings,
+                    packages: [
+                        ...hostEntries,
+                        ...linkedContributors.map((input) => ({
+                            ...input,
+                            entry: `./contrib/${input.name}`,
+                        })),
+                    ],
+                });
+                moduleHosts.forEach((record, index) => {
+                    NativeSourcePackages_1.NativeSourcePackages.kind(observations[index], record.label, "executable");
+                    admittedExecutables.add(record.source);
                 });
-        if (binary === undefined) {
-            throw new Error(`ttsc: plugin "${record.label}" is a linked Go package, but no compiler host is available`);
+                linkedContributors.forEach((input, index) => {
+                    NativeSourcePackages_1.NativeSourcePackages.kind(observations[hostEntries.length + index], `${input.name} inside host ${host.label}`, "linked");
+                });
+            }
+        }
+        // A nested main proposal still needs its actual owning manifests. Hosts
+        // with linked contributors were admitted together above; other equivalent
+        // entries share one standalone observation, with no repeated host copy.
+        const standaloneCandidates = executableCandidates.filter((candidate) => !admittedExecutables.has(candidate.source));
+        const executablePackages = NativeSourcePackages_1.NativeSourcePackages.ownPackages(standaloneCandidates, effectiveEnv, packageReaders, sourceIdentities, readings);
+        standaloneCandidates.forEach((candidate, index) => {
+            NativeSourcePackages_1.NativeSourcePackages.kind(executablePackages[index], candidate.label, "executable");
+        });
+        const packageOwnership = (source, label, linked) => [
+            {
+                entry: (0, resolvePluginGoModule_1.resolvePluginGoModule)(source, label).entry,
+                kind: "executable",
+            },
+            ...(linked
+                ? linkedContributors.map((input) => ({
+                    entry: `./contrib/${input.name}`,
+                    kind: "linked",
+                }))
+                : []),
+        ];
+        const builtTransformHosts = new Map();
+        for (const record of transformHosts) {
+            builtTransformHosts.set(record, (0, buildSourcePlugin_1.buildSourcePlugin)({
+                baseDir: context.projectRoot,
+                cacheDir: options.cacheDir,
+                contributors: mergeContributors(record.contributors, hostContributors),
+                env: effectiveEnv,
+                goModReaders: packageReaders,
+                identities: sourceIdentities,
+                pluginName: record.label,
+                packageOwnership: packageOwnership(record.source, record.label, true),
+                source: record.source,
+                environmentDigests,
+                environmentWitnesses,
+                sourceDigests,
+                ttscVersion,
+                tsgoVersion,
+            }));
         }
+        const fallbackDriverHost = transformHosts.length === 0 && linkedContributors.length !== 0
+            ? (0, buildSourcePlugin_1.buildSourcePlugin)({
+                baseDir: context.projectRoot,
+                cacheDir: options.cacheDir,
+                contributors: linkedContributors,
+                env: effectiveEnv,
+                goModReaders: packageReaders,
+                identities: sourceIdentities,
+                label: "linked plugin host",
+                pluginName: "linked-plugin-host",
+                source: node_path_1.default.join(ttscPackageRoot(), "cmd", "utility-host"),
+                packageOwnership: packageOwnership(node_path_1.default.join(ttscPackageRoot(), "cmd", "utility-host"), "linked-plugin-host", true),
+                environmentDigests,
+                environmentWitnesses,
+                sourceDigests,
+                ttscVersion,
+                tsgoVersion,
+            })
+            : undefined;
+        const selectedTransformHost = transformHosts.length === 0
+            ? fallbackDriverHost
+            : builtTransformHosts.get(transformHosts[0]);
+        const nativePlugins = records.map((record) => {
+            const binary = record.stage === "transform" && record.kind === "linked"
+                ? selectedTransformHost
+                : record.stage === "transform"
+                    ? builtTransformHosts.get(record)
+                    : (0, buildSourcePlugin_1.buildSourcePlugin)({
+                        baseDir: context.projectRoot,
+                        cacheDir: options.cacheDir,
+                        contributors: record.contributors,
+                        env: effectiveEnv,
+                        goModReaders: packageReaders,
+                        identities: sourceIdentities,
+                        pluginName: record.label,
+                        packageOwnership: packageOwnership(record.source, record.label, false),
+                        source: record.source,
+                        environmentDigests,
+                        environmentWitnesses,
+                        sourceDigests,
+                        ttscVersion,
+                        tsgoVersion,
+                    });
+            if (binary === undefined) {
+                throw new Error(`ttsc: plugin "${record.label}" is a linked Go package, but no compiler host is available`);
+            }
+            return {
+                binary,
+                // This fallback is compiled from our utility-host, whose actual writer
+                // publishes provenance and supports a separate compiler argument cwd.
+                // A separately selected executable host must opt in itself; a linked
+                // library cannot certify that foreign host. An undeclared capability
+                // only withholds the optional protocol: build execution still runs such
+                // a host and observes it from outside, never rejecting it.
+                capabilities: record.stage === "transform" &&
+                    record.kind === "linked" &&
+                    fallbackDriverHost !== undefined
+                    ? {
+                        ...record.capabilities,
+                        compilerArgsCwd: true,
+                        emitProvenance: true,
+                    }
+                    : record.capabilities,
+                config: record.config,
+                contributors: record.contributors,
+                kind: record.kind,
+                name: record.name,
+                reportsTypeScriptDiagnostics: record.reportsTypeScriptDiagnostics,
+                source: record.source,
+                stage: record.stage,
+            };
+        });
         return {
-            binary,
-            // This fallback is compiled from our utility-host, whose actual writer
-            // publishes provenance and supports a separate compiler argument cwd.
-            // A separately selected executable host must opt in itself; a linked
-            // library cannot certify that foreign host. An undeclared capability
-            // only withholds the optional protocol: build execution still runs such
-            // a host and observes it from outside, never rejecting it.
-            capabilities: record.stage === "transform" &&
-                record.kind === "linked" &&
-                fallbackDriverHost !== undefined
-                ? {
-                    ...record.capabilities,
-                    compilerArgsCwd: true,
-                    emitProvenance: true,
-                }
-                : record.capabilities,
-            config: record.config,
-            contributors: record.contributors,
-            kind: record.kind,
-            name: record.name,
-            reportsTypeScriptDiagnostics: record.reportsTypeScriptDiagnostics,
-            source: record.source,
-            stage: record.stage,
+            ...collectHostInputSnapshot(project, context, records, projectHostInputs, revalidateHostInputHashes(projectHostInputHashes, projectHostInputs), revalidateHostInputRealpaths(projectHostInputRealpaths, projectHostInputs)),
+            descriptorReadsDeclared: loadedEntries.every((entry) => entry.observationsComplete && (0, declaresHostInputReads_1.declaresHostInputReads)(entry.plugin)),
+            discoveryInputsComplete: project.configInputsComplete === true,
+            ...(identities === undefined ? {} : { identities }),
+            nativePlugins: orderNativePlugins(nativePlugins),
+            ...(loadedEntries.some((entry) => !entry.observationsComplete)
+                ? { observationsComplete: false }
+                : {}),
+            // The directories the watch inputs named before the builds, as the builds
+            // read them. Package selection shares these readings and also reads a
+            // linked plugin's module root, which no build keys on, so only the build
+            // directories are reported.
+            pluginSources: Object.fromEntries([...sourceDigests]
+                .filter(([directory]) => keyedDirectories.has(directory))
+                .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+                .map(([directory, sourceDigest]) => [
+                directory,
+                (0, pluginSourceState_1.pluginSourceState)(directory, {
+                    env: effectiveEnv,
+                    sourceDigest,
+                    environment: environmentDigests.get(directory) ??
+                        (0, pluginBuildEnvironment_1.pluginBuildEnvironment)(directory, effectiveEnv, undefined, sourceIdentities),
+                }),
+            ])),
+            project,
         };
-    });
-    return {
-        ...collectHostInputSnapshot(project, context, records, projectHostInputs, revalidateHostInputHashes(projectHostInputHashes, projectHostInputs), revalidateHostInputRealpaths(projectHostInputRealpaths, projectHostInputs)),
-        descriptorReadsDeclared: loadedEntries.every((entry) => entry.observationsComplete && (0, declaresHostInputReads_1.declaresHostInputReads)(entry.plugin)),
-        discoveryInputsComplete: project.configInputsComplete === true,
-        ...(identities === undefined ? {} : { identities }),
-        nativePlugins: orderNativePlugins(nativePlugins),
-        ...(loadedEntries.some((entry) => !entry.observationsComplete)
-            ? { observationsComplete: false }
-            : {}),
-        // The directories the watch inputs named before the builds, as the builds
-        // read them. Package selection shares these readings and also reads a
-        // linked plugin's module root, which no build keys on, so only the build
-        // directories are reported.
-        pluginSources: Object.fromEntries([...sourceDigests]
-            .filter(([directory]) => keyedDirectories.has(directory))
-            .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
-            .map(([directory, sourceDigest]) => [
-            directory,
-            (0, pluginSourceState_1.pluginSourceState)(directory, {
-                env: effectiveEnv,
-                sourceDigest,
-                environment: environmentDigests.get(directory) ??
-                    (0, pluginBuildEnvironment_1.pluginBuildEnvironment)(directory, effectiveEnv, undefined, sourceIdentities),
-            }),
-        ])),
-        project,
-    };
-}
+    }
+    loadProjectPlugins.steps = steps;
+})(loadProjectPlugins || (exports.loadProjectPlugins = loadProjectPlugins = {}));
 /**
  * Collect exact JavaScript-host files that universally influence the loaded
  * transform. Program files belong to the native reference graph; this list is
@@ -597,16 +646,16 @@ function collectHostInputSnapshot(project, context, records, baselineInputs, bas
  * cache proof for the ambiguous snapshot.
  */
 function readProjectHostInputSnapshot(options) {
-    const { includePluginDiscovery, ...projectOptions } = options;
+    const { includePluginDiscovery, pluginConfigDir, ...projectOptions } = options;
     let project = (0, readProjectConfig_1.readProjectConfig)(projectOptions);
-    let hostInputs = (0, collectProjectHostInputs_1.collectProjectHostInputs)(project, includePluginDiscovery);
+    let hostInputs = (0, collectProjectHostInputs_1.collectProjectHostInputs)(project, includePluginDiscovery, pluginConfigDir);
     const observedInputs = new Set(hostInputs);
     for (let attempt = 0; attempt < 3; attempt++) {
         const before = (0, hashHostInputPaths_1.hashHostInputPaths)(hostInputs);
         const beforeRealpaths = (0, realpathHostInputPaths_1.realpathHostInputPaths)(hostInputs);
         const beforeSignatures = hostInputMetadataSignatures(hostInputs);
         const candidateProject = (0, readProjectConfig_1.readProjectConfig)(projectOptions);
-        const candidateInputs = (0, collectProjectHostInputs_1.collectProjectHostInputs)(candidateProject, includePluginDiscovery);
+        const candidateInputs = (0, collectProjectHostInputs_1.collectProjectHostInputs)(candidateProject, includePluginDiscovery, pluginConfigDir);
         for (const input of candidateInputs)
             observedInputs.add(input);
         const after = (0, hashHostInputPaths_1.hashHostInputPaths)(candidateInputs);
@@ -927,7 +976,7 @@ function loadPluginDescriptor(request, context, effectiveEnv, descriptorCache) {
             !error.retryWithTtsx) {
             throw error;
         }
-        const loaded = loadDescriptorViaTtsx(request, context, effectiveEnv, descriptorCache.identities);
+        const loaded = loadDescriptorViaTtsx(request, context, effectiveEnv, descriptorCache);
         if (loaded === undefined) {
             throw error;
         }
@@ -957,20 +1006,26 @@ class CommonJsDescriptorLoadError extends Error {
  * (`PluginDescriptorEvaluationCache`): an unchanged project pays a proof of its
  * descriptor inputs instead of a runtime start and a graph load.
  */
-function loadCommonJsDescriptor(request, context, effectiveEnv, descriptorCache) {
+function loadCommonJsDescriptor(request, context, loadEnv, descriptorCache) {
+    // The evaluator is ttsc's own helper: inside a ttsx run it gets the user's
+    // NODE_OPTIONS, not ttsx's preloads, which would refuse the descriptor cache
+    // and run in every evaluation (#1740). The runtime probe below does the same.
+    const effectiveEnv = TtsxNodeOptions_1.TtsxNodeOptions.forHelpers(loadEnv);
     const runtime = pluginDescriptorRuntimeBinary(effectiveEnv);
     const ttsx = effectiveEnv.TTSC_TTSX_BINARY ?? process.env.TTSC_TTSX_BINARY;
-    const runtimeCapabilities = (0, javascriptRuntimeCapabilities_1.javascriptRuntimeCapabilities)(runtime, effectiveEnv, context.projectRoot, descriptorCache.identities);
+    const runtimeCapabilities = (0, javascriptRuntimeCapabilities_1.javascriptRuntimeCapabilities)(runtime, effectiveEnv, descriptorCache.projectRoot, descriptorCache.identities);
     const node = !runtimeCapabilities.bun &&
         runtimeCapabilities.registerHooks &&
         runtimeCapabilities.executable !== undefined
         ? runtimeCapabilities.executable
-        : (0, resolveNodeBinary_1.resolveNodeBinary)(effectiveEnv, context.projectRoot, descriptorCache.identities);
+        : (0, resolveNodeBinary_1.resolveNodeBinary)(effectiveEnv, descriptorCache.projectRoot, descriptorCache.identities);
     const cacheAuthority = {
         additionalRuntime: node,
         cacheDir: descriptorCache.cacheDir,
         identities: descriptorCache.identities,
         context,
+        // Factory context anchors the consumer; the evaluator runs at the source root.
+        cwd: descriptorCache.projectRoot,
         // Everything the child receives besides the per-evaluation output paths.
         env: {
             ...effectiveEnv,
@@ -978,7 +1033,7 @@ function loadCommonJsDescriptor(request, context, effectiveEnv, descriptorCache)
             ...descriptorRecordRoot(descriptorCache.identities),
             TTSC_TTSX_BINARY: ttsx,
         },
-        projectRoot: context.projectRoot,
+        projectRoot: descriptorCache.projectRoot,
         request,
         runtime,
         version: descriptorCache.version,
@@ -1044,7 +1099,7 @@ function loadCommonJsDescriptor(request, context, effectiveEnv, descriptorCache)
                 ...(runtimeCapabilities.bun ? [] : ["--input-type", ""]),
                 shim,
             ], {
-                cwd: context.projectRoot,
+                cwd: descriptorCache.projectRoot,
                 env: {
                     ...effectiveEnv,
                     // The direct evaluator may be Bun, but ttsx and native config
@@ -1307,11 +1362,11 @@ const TS_SOURCE_PATTERN = /\.(?:[cm]?ts|tsx)$/i;
  * shim with plugins disabled across the whole graph. Returns `undefined` when
  * `ttsx` is unavailable, so the caller can rethrow the original load error.
  */
-function loadDescriptorViaTtsx(request, context, effectiveEnv, identities) {
+function loadDescriptorViaTtsx(request, context, effectiveEnv, descriptorCache) {
     // Binary discovery prefers the instance environment, then the ambient
     // process.env (where `withPluginLoaderEnv` injects ttsc's own node/ttsx paths
     // just before this runs), then the running interpreter.
-    const node = (0, resolveNodeBinary_1.resolveNodeBinary)(effectiveEnv, context.projectRoot, identities);
+    const node = (0, resolveNodeBinary_1.resolveNodeBinary)(effectiveEnv, descriptorCache.projectRoot, descriptorCache.identities);
     const ttsx = effectiveEnv.TTSC_TTSX_BINARY ?? process.env.TTSC_TTSX_BINARY;
     if (node === undefined || ttsx === undefined || ttsx.length === 0) {
         return undefined;
@@ -1332,9 +1387,9 @@ function loadDescriptorViaTtsx(request, context, effectiveEnv, identities) {
             },
         }));
         node_fs_1.default.writeFileSync(shim, PLUGIN_DESCRIPTOR_SHIM_SOURCE_1.PLUGIN_DESCRIPTOR_SHIM_SOURCE);
-        const trace = E2ETrace_1.E2ETrace.begin(node, [ttsx, "--no-plugins", shim], { cwd: context.projectRoot }, "plugin-descriptor");
+        const trace = E2ETrace_1.E2ETrace.begin(node, [ttsx, "--no-plugins", shim], { cwd: descriptorCache.projectRoot }, "plugin-descriptor");
         const result = spawnOwnedDescriptor(node, [ttsx, "--no-plugins", shim], {
-            cwd: context.projectRoot,
+            cwd: descriptorCache.projectRoot,
             encoding: "utf8",
             env: {
                 ...effectiveEnv,
@@ -1342,7 +1397,7 @@ function loadDescriptorViaTtsx(request, context, effectiveEnv, identities) {
                 // may recurse into further descriptor loads) finds them even when the
                 // instance-env snapshot predates `withPluginLoaderEnv`.
                 TTSC_NODE_BINARY: node,
-                ...descriptorRecordRoot(identities),
+                ...descriptorRecordRoot(descriptorCache.identities),
                 TTSC_TTSX_BINARY: ttsx,
                 TTSC_PLUGIN_CONTEXT: JSON.stringify({
                     binary: context.binary,
@@ -1625,12 +1680,12 @@ function resolvePluginSource(source, projectRoot) {
  * that it replaces a module with, which the build compiles in place
  * (`pluginModuleReplaceDirectories`).
  */
-function pluginBuildDirectories(records, env, replacements, readers) {
+function pluginBuildDirectories(records, env, replacements, readers, identities) {
     const directories = new Set();
     for (const record of records) {
         directories.add(node_path_1.default.resolve(record.kind === "linked" ? record.packageDir : record.moduleRoot));
         if (record.kind === "executable") {
-            for (const directory of pluginReplacementWatchDirectories(record.moduleRoot, env, replacements, readers))
+            for (const directory of pluginReplacementWatchDirectories(record.moduleRoot, env, replacements, readers, identities))
                 directories.add(directory);
         }
         for (const contributor of record.contributors ?? [])
@@ -1643,13 +1698,14 @@ function pluginBuildDirectories(records, env, replacements, readers) {
  * The load shares this best-effort watch projection, not package validity or a
  * cross-load manifest cache. Go metadata/build admission still owns errors.
  */
-function pluginReplacementWatchDirectories(moduleRoot, env, observed, readers) {
+function pluginReplacementWatchDirectories(moduleRoot, env, observed, readers, identities) {
     const previous = observed?.get(moduleRoot);
     if (previous !== undefined)
         return previous;
     let directories;
     try {
-        directories = (0, pluginModuleReplaceDirectories_1.pluginModuleReplaceDirectories)(moduleRoot, env, undefined, undefined, readers).map((replacement) => replacement.directory);
+        // The load's store goes with the reader this registers first (#1739).
+        directories = (0, pluginModuleReplaceDirectories_1.pluginModuleReplaceDirectories)(moduleRoot, env, undefined, undefined, readers, identities).map((replacement) => replacement.directory);
     }
     catch {
         // An unreadable manifest/tool is not valid metadata. The already observed