@ohos-ports/nx 23.2.0-beta.0 → 23.2.1-beta.0

package/dist/src/project-graph/plugins/get-plugins.d.ts

@@ -1,51 +0,0 @@
-import { NxJsonConfiguration, PluginConfiguration } from '../../config/nx-json';
-import type { LoadedNxPlugin } from './loaded-nx-plugin';
-export interface SeparatedPlugins {
-    specifiedPlugins: LoadedNxPlugin[];
-    defaultPlugins: LoadedNxPlugin[];
-}
-/** Exported for tests: the fallback latch is process-scoped by design. */
-export declare function resetIsolationFallbackForTesting(): void;
-/**
- * Loads a plugin in a worker, falling back to this process when the worker's
- * socket was refused.
- *
- * Isolation is preferred: it is what keeps two plugins with conflicting
- * TypeScript versions or module-level state apart. But a sandbox that has not
- * been told about the Nx socket root refuses the worker's socket, and failing
- * the whole command over that is worse than running the plugins here. The
- * fallback is narrow on purpose. It needs a failure to start or reach the
- * worker, plus either a detectable sandbox or the worker's own EPERM/EACCES
- * exit code under an AI agent — the second arm is what covers an agent whose
- * sandbox sets no variable `isSandbox()` reads. A plugin that loaded and then
- * threw is rethrown, because rerunning it in-process would bury its actual
- * error.
- */
-export declare const loadingMethod: (plugin: PluginConfiguration, root: string, index?: number) => Promise<readonly [Promise<LoadedNxPlugin>, () => void]>;
-/**
- * Returns all plugins (specified + default) as a flat list.
- * Specified plugins come first, followed by default plugins.
- */
-export declare function getPlugins(nxJson: NxJsonConfiguration, root?: string): Promise<LoadedNxPlugin[]>;
-/**
- * Returns specified plugins (from nx.json) and default plugins (project.json,
- * package.json, etc.) as separate arrays. This separation is needed for
- * two-phase project configuration processing where target defaults are
- * applied between specified and default plugin results.
- *
- * `nxJson` is required so callers control the snapshot of nx.json the plugin
- * loader uses. This matters for the daemon's freshness-gated recompute, where
- * the snap hash and the plugin set must reflect the same disk state.
- */
-export declare function getPluginsSeparated(nxJson: NxJsonConfiguration, root?: string): Promise<SeparatedPlugins>;
-export declare function getOnlyDefaultPlugins(root?: string): Promise<LoadedNxPlugin[]>;
-/**
- * The plugins from an in-flight load (whose workers may already be forked) or
- * the last committed one, without triggering a load. Undefined when neither
- * exists or plugins were cleaned up. After a plugins-config change the
- * committed set can be the previous, already-disposed one until the new load
- * commits, so callers must tolerate a disposed worker.
- */
-export declare function getPluginsIfLoadedOrLoading(): Promise<LoadedNxPlugin[]> | undefined;
-export declare function cleanupPlugins(): void;
-export declare function reasonToError(reason: unknown): Error;

package/dist/src/project-graph/plugins/get-plugins.js

@@ -1,401 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadingMethod = void 0;
-exports.resetIsolationFallbackForTesting = resetIsolationFallbackForTesting;
-exports.getPlugins = getPlugins;
-exports.getPluginsSeparated = getPluginsSeparated;
-exports.getOnlyDefaultPlugins = getOnlyDefaultPlugins;
-exports.getPluginsIfLoadedOrLoading = getPluginsIfLoadedOrLoading;
-exports.cleanupPlugins = cleanupPlugins;
-exports.reasonToError = reasonToError;
-const node_path_1 = require("node:path");
-const angular_json_1 = require("../../adapter/angular-json");
-const file_hasher_1 = require("../../hasher/file-hasher");
-const workspace_root_1 = require("../../utils/workspace-root");
-const in_process_loader_1 = require("./in-process-loader");
-const isolation_1 = require("./isolation");
-const resolve_plugin_1 = require("./resolve-plugin");
-const enabled_1 = require("./isolation/enabled");
-const isolated_plugin_1 = require("./isolation/isolated-plugin");
-const sandbox_socket_hint_1 = require("../../daemon/sandbox-socket-hint");
-const is_sandbox_1 = require("../../utils/is-sandbox");
-const native_1 = require("../../native");
-const output_1 = require("../../utils/output");
-const transpiler_1 = require("./transpiler");
-/**
- * Stuff for specified NX Plugins.
- */
-let currentPluginsConfigurationHash;
-let loadedPlugins;
-let cachedSeparatedPlugins;
-let pendingPluginsPromise;
-let cleanupSpecifiedPlugins;
-// In-flight separated-plugins load, tagged with its hash. Two roles: a
-// concurrent caller for the same set shares this load instead of racing a
-// second one, and it gates the cache commit — a load writes the cache only if
-// it's still the registered load when it finishes, so a slow older load can't
-// clobber a newer one's result (two recomputes can overlap).
-let pendingSeparatedPlugins;
-/**
- * Set once a worker has been refused in this process, and read by every later
- * plugin: nothing about a second attempt can succeed once the first has been
- * refused for a reason that belongs to the sandbox.
- *
- * It does not stop the spawns of the plugins already in flight. Callers load
- * plugins concurrently, so all of them are past the entry check before the
- * first worker dies; what the latch guarantees is that the advice is printed
- * once rather than once per plugin, and that anything loaded after the refusal
- * skips the worker entirely.
- *
- * Process-scoped rather than persisted: the refusal describes the environment
- * Nx is running in, so it must not follow the workspace into a plain terminal.
- */
-let isolationRefusedInThisProcess = false;
-/** Exported for tests: the fallback latch is process-scoped by design. */
-function resetIsolationFallbackForTesting() {
-    isolationRefusedInThisProcess = false;
-}
-/**
- * Loads a plugin in a worker, falling back to this process when the worker's
- * socket was refused.
- *
- * Isolation is preferred: it is what keeps two plugins with conflicting
- * TypeScript versions or module-level state apart. But a sandbox that has not
- * been told about the Nx socket root refuses the worker's socket, and failing
- * the whole command over that is worse than running the plugins here. The
- * fallback is narrow on purpose. It needs a failure to start or reach the
- * worker, plus either a detectable sandbox or the worker's own EPERM/EACCES
- * exit code under an AI agent — the second arm is what covers an agent whose
- * sandbox sets no variable `isSandbox()` reads. A plugin that loaded and then
- * threw is rethrown, because rerunning it in-process would bury its actual
- * error.
- */
-const loadingMethod = async (plugin, root, index) => {
-    if (!(0, enabled_1.isIsolationEnabled)() || isolationRefusedInThisProcess) {
-        return (0, in_process_loader_1.loadNxPlugin)(plugin, root, index);
-    }
-    const [isolatedPlugin, cleanup] = await (0, isolation_1.loadIsolatedNxPlugin)(plugin, root, index);
-    // Awaited here rather than handed on, because the worker failure surfaces on
-    // this promise and the fallback has to happen before the caller sees it.
-    try {
-        return [Promise.resolve(await isolatedPlugin), cleanup];
-    }
-    catch (e) {
-        // Proof, kept separate from policy. The errno the worker saw is what makes
-        // the message certain; whether that errno is also grounds for degrading is a
-        // different question, and conflating them made the warning assert a sandbox
-        // for agents the hint itself declines to name.
-        const provenRefusal = (0, isolated_plugin_1.isPluginWorkerSocketRefusal)(e);
-        // An agent is required alongside the errno, so a refusal on an ordinary
-        // workstation still surfaces rather than silently losing isolation.
-        if (!(0, isolated_plugin_1.isPluginWorkerStartupFailure)(e) ||
-            !((provenRefusal && (0, native_1.isAiAgent)()) || (0, is_sandbox_1.isSandbox)())) {
-            throw e;
-        }
-        cleanup();
-        // Read and set in one synchronous step. Concurrently loaded plugins each
-        // arrive here with their own failure, so testing the latch after setting it
-        // is what keeps the advice to one copy.
-        const alreadyRefused = isolationRefusedInThisProcess;
-        isolationRefusedInThisProcess = true;
-        if (!alreadyRefused) {
-            output_1.output.warn({
-                // Names what Nx observed, not what it infers. `isAiAgent()` is broader
-                // than the agents `sandboxSpecificRemedy` will name a setting for, so a
-                // title asserting a sandbox could sit above a body that deliberately
-                // does not.
-                title: provenRefusal
-                    ? 'Nx was denied permission to create a plugin worker socket. Running plugins in the main process instead.'
-                    : 'Could not start a plugin worker. Running plugins in the main process instead.',
-                bodyLines: [
-                    'Plugins that expect isolation may misbehave, and this is slower than a worker.',
-                    // `certain` on the errno alone. Reaching here via `isSandbox()` proves
-                    // only that a worker died before it connected, which denied permission
-                    // explains but so does an OOM kill or a broken install.
-                    ...(0, sandbox_socket_hint_1.sandboxSocketHint)({ certain: provenRefusal }),
-                ],
-            });
-        }
-        return (0, in_process_loader_1.loadNxPlugin)(plugin, root, index);
-    }
-};
-exports.loadingMethod = loadingMethod;
-/**
- * Returns all plugins (specified + default) as a flat list.
- * Specified plugins come first, followed by default plugins.
- */
-async function getPlugins(nxJson, root = workspace_root_1.workspaceRoot) {
-    const { specifiedPlugins, defaultPlugins } = await getPluginsSeparated(nxJson, root);
-    return specifiedPlugins.concat(defaultPlugins);
-}
-/**
- * Returns specified plugins (from nx.json) and default plugins (project.json,
- * package.json, etc.) as separate arrays. This separation is needed for
- * two-phase project configuration processing where target defaults are
- * applied between specified and default plugin results.
- *
- * `nxJson` is required so callers control the snapshot of nx.json the plugin
- * loader uses. This matters for the daemon's freshness-gated recompute, where
- * the snap hash and the plugin set must reflect the same disk state.
- */
-async function getPluginsSeparated(nxJson, root = workspace_root_1.workspaceRoot) {
-    const pluginsConfiguration = nxJson.plugins ?? [];
-    const pluginsConfigurationHash = (0, file_hasher_1.hashObject)(pluginsConfiguration);
-    // If the plugins configuration has not changed, reuse the current plugins
-    if (cachedSeparatedPlugins &&
-        pluginsConfigurationHash === currentPluginsConfigurationHash) {
-        return cachedSeparatedPlugins;
-    }
-    // A concurrent call is already loading this exact plugin set — share its
-    // load rather than starting a second one that would race the module-level
-    // cache state below.
-    if (pendingSeparatedPlugins?.hash === pluginsConfigurationHash) {
-        return pendingSeparatedPlugins.promise;
-    }
-    // Plugins config changed (e.g. `nx add @nx/maven` updated nx.json). The
-    // cached SeparatedPlugins is invalidated by the early-return above, but
-    // pendingPluginsPromise — the in-flight load — would otherwise be reused
-    // by the `??=` below and serve the previous plugin set forever. Tear
-    // down the old workers and force a fresh load.
-    cleanupSpecifiedPlugins?.();
-    pendingPluginsPromise = undefined;
-    const loadPromise = (async () => {
-        const results = await Promise.allSettled([
-            getOnlyDefaultPlugins(root),
-            (pendingPluginsPromise ??= loadSpecifiedNxPlugins(pluginsConfiguration, root)),
-        ]);
-        const errors = [];
-        const defaultPlugins = [];
-        const specifiedPlugins = [];
-        for (let i = 0; i < results.length; i++) {
-            const result = results[i];
-            if (result.status === 'fulfilled') {
-                (i === 0 ? defaultPlugins : specifiedPlugins).push(...result.value);
-            }
-            else {
-                errors.push(reasonToError(result.reason));
-            }
-        }
-        if (errors.length > 0) {
-            throw new AggregateError(errors, errors.map((e) => e.message).join('\n'));
-        }
-        const separatedPlugins = {
-            specifiedPlugins,
-            defaultPlugins,
-        };
-        // Commit only if we're still the registered load — so the hash and the
-        // cached set are always written together and describe the same plugins.
-        if (pendingSeparatedPlugins?.promise === loadPromise) {
-            cachedSeparatedPlugins = separatedPlugins;
-            currentPluginsConfigurationHash = pluginsConfigurationHash;
-            loadedPlugins = specifiedPlugins.concat(defaultPlugins);
-        }
-        return separatedPlugins;
-    })();
-    pendingSeparatedPlugins = {
-        hash: pluginsConfigurationHash,
-        promise: loadPromise,
-    };
-    try {
-        return await loadPromise;
-    }
-    finally {
-        // Clear the in-flight marker, but only if it still points at our load —
-        // a newer call may have already replaced it.
-        if (pendingSeparatedPlugins?.promise === loadPromise) {
-            pendingSeparatedPlugins = undefined;
-        }
-    }
-}
-/**
- * Stuff for default NX Plugins.
- */
-let loadedDefaultPlugins;
-let loadedDefaultPluginsHash;
-let cleanupDefaultPlugins;
-let pendingDefaultPluginPromise;
-async function getOnlyDefaultPlugins(root = workspace_root_1.workspaceRoot) {
-    const hash = root;
-    // If the plugins configuration has not changed, reuse the current plugins
-    if (loadedDefaultPlugins && hash === loadedDefaultPluginsHash) {
-        return loadedDefaultPlugins;
-    }
-    // Cleanup current plugins before loading new ones
-    if (cleanupDefaultPlugins) {
-        cleanupDefaultPlugins();
-    }
-    pendingDefaultPluginPromise ??= loadDefaultNxPlugins(workspace_root_1.workspaceRoot);
-    const [result, cleanupFn] = await pendingDefaultPluginPromise;
-    cleanupDefaultPlugins = () => {
-        loadedDefaultPlugins = undefined;
-        pendingDefaultPluginPromise = undefined;
-        cleanupFn();
-    };
-    loadedDefaultPlugins = result;
-    loadedDefaultPluginsHash = hash;
-    return result;
-}
-/**
- * The plugins from an in-flight load (whose workers may already be forked) or
- * the last committed one, without triggering a load. Undefined when neither
- * exists or plugins were cleaned up. After a plugins-config change the
- * committed set can be the previous, already-disposed one until the new load
- * commits, so callers must tolerate a disposed worker.
- */
-function getPluginsIfLoadedOrLoading() {
-    const separated = pendingSeparatedPlugins
-        ? pendingSeparatedPlugins.promise
-        : cachedSeparatedPlugins;
-    if (!separated) {
-        return undefined;
-    }
-    return Promise.resolve(separated).then(({ specifiedPlugins, defaultPlugins }) => specifiedPlugins.concat(defaultPlugins));
-}
-function cleanupPlugins() {
-    cleanupSpecifiedPlugins?.();
-    cleanupDefaultPlugins?.();
-    pendingPluginsPromise = undefined;
-    pendingDefaultPluginPromise = undefined;
-    cachedSeparatedPlugins = undefined;
-    // Drop the in-flight load too: clearing the marker flips its commit gate to
-    // false, so a load resolving after teardown can't repopulate the torn-down cache.
-    pendingSeparatedPlugins = undefined;
-}
-/**
- * Stuff for generic loading
- */
-async function loadDefaultNxPlugins(root = workspace_root_1.workspaceRoot) {
-    performance.mark('loadDefaultNxPlugins:start');
-    const plugins = getDefaultPlugins(root);
-    const cleanupFunctions = [];
-    const results = await Promise.allSettled(plugins.map(async (plugin) => {
-        performance.mark(`Load Nx Plugin: ${plugin} - start`);
-        const [loadedPluginPromise, cleanup] = await (0, exports.loadingMethod)(plugin, root);
-        cleanupFunctions.push(cleanup);
-        const res = await loadedPluginPromise;
-        performance.mark(`Load Nx Plugin: ${plugin} - end`);
-        performance.measure(`Load Nx Plugin: ${plugin}`, `Load Nx Plugin: ${plugin} - start`, `Load Nx Plugin: ${plugin} - end`);
-        return res;
-    }));
-    const defaultPluginResults = [];
-    const errors = [];
-    for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-        if (result.status === 'fulfilled') {
-            defaultPluginResults.push(result.value);
-        }
-        else {
-            errors.push({
-                pluginName: plugins[i],
-                error: reasonToError(result.reason),
-            });
-        }
-    }
-    if (errors.length > 0) {
-        for (const fn of cleanupFunctions) {
-            fn();
-        }
-        const errorMessage = errors
-            .map((e) => `  - ${e.pluginName}: ${e.error.message}`)
-            .join('\n');
-        throw new AggregateError(errors.map((e) => e.error), `Failed to load ${errors.length} default Nx plugin(s):\n${errorMessage}`);
-    }
-    const ret = [
-        defaultPluginResults,
-        () => {
-            for (const fn of cleanupFunctions) {
-                fn();
-            }
-            if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
-                (0, transpiler_1.cleanupPluginTSTranspiler)();
-            }
-        },
-    ];
-    performance.mark('loadDefaultNxPlugins:end');
-    performance.measure('loadDefaultNxPlugins', 'loadDefaultNxPlugins:start', 'loadDefaultNxPlugins:end');
-    return ret;
-}
-async function loadSpecifiedNxPlugins(pluginsConfigurations, root = workspace_root_1.workspaceRoot) {
-    // Returning existing plugins is handled by getPlugins,
-    // so, if we are here and there are existing plugins, they are stale
-    if (cleanupSpecifiedPlugins) {
-        cleanupSpecifiedPlugins();
-    }
-    performance.mark('loadSpecifiedNxPlugins:start');
-    pluginsConfigurations ??= [];
-    // Drop the cached workspace-layout snapshot local-plugin resolution uses:
-    // in a long-lived daemon it can predate a newly added local plugin and
-    // resolve it to the workspace root. Runs only when the plugin set changed.
-    (0, resolve_plugin_1.resetResolvePluginCache)();
-    const cleanupFunctions = [];
-    const results = await Promise.allSettled(pluginsConfigurations.map(async (plugin, index) => {
-        const pluginPath = typeof plugin === 'string' ? plugin : plugin.plugin;
-        performance.mark(`Load Nx Plugin: ${pluginPath} - start`);
-        const [loadedPluginPromise, cleanup] = await (0, exports.loadingMethod)(plugin, root, index);
-        cleanupFunctions.push(cleanup);
-        const res = await loadedPluginPromise;
-        performance.mark(`Load Nx Plugin: ${pluginPath} - end`);
-        performance.measure(`Load Nx Plugin: ${pluginPath}`, `Load Nx Plugin: ${pluginPath} - start`, `Load Nx Plugin: ${pluginPath} - end`);
-        return res;
-    }));
-    performance.mark('loadSpecifiedNxPlugins:end');
-    performance.measure('loadSpecifiedNxPlugins', 'loadSpecifiedNxPlugins:start', 'loadSpecifiedNxPlugins:end');
-    const plugins = [];
-    const errors = [];
-    for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-        if (result.status === 'fulfilled') {
-            plugins.push(result.value);
-        }
-        else {
-            const pluginConfig = pluginsConfigurations[i];
-            const pluginName = typeof pluginConfig === 'string' ? pluginConfig : pluginConfig.plugin;
-            errors.push({
-                pluginName,
-                error: reasonToError(result.reason),
-            });
-        }
-    }
-    if (errors.length > 0) {
-        for (const fn of cleanupFunctions) {
-            fn();
-        }
-        const errorMessage = errors
-            .map((e) => `  - ${e.pluginName}: ${e.error.message}`)
-            .join('\n');
-        throw new AggregateError(errors.map((e) => e.error), `Failed to load ${errors.length} Nx plugin(s):\n${errorMessage}`);
-    }
-    cleanupSpecifiedPlugins = () => {
-        for (const fn of cleanupFunctions) {
-            fn();
-        }
-        if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
-            (0, transpiler_1.cleanupPluginTSTranspiler)();
-        }
-        pendingPluginsPromise = undefined;
-    };
-    return plugins;
-}
-function reasonToError(reason) {
-    if (reason instanceof Error) {
-        return reason;
-    }
-    if (typeof reason === 'object' && reason !== null && 'message' in reason) {
-        const error = new Error(String(reason.message));
-        if ('stack' in reason) {
-            error.stack = String(reason.stack);
-        }
-        return error;
-    }
-    return new Error(String(reason));
-}
-function getDefaultPlugins(root) {
-    return [
-        (0, node_path_1.join)(__dirname, '../../plugins/js'),
-        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
-            ? [(0, node_path_1.join)(__dirname, '../../adapter/angular-json')]
-            : []),
-        (0, node_path_1.join)(__dirname, '../../plugins/package-json'),
-        (0, node_path_1.join)(__dirname, '../../plugins/project-json/build-nodes/project-json'),
-    ];
-}

package/dist/src/project-graph/plugins/in-process-loader.d.ts

@@ -1,10 +0,0 @@
-import { ProjectConfiguration } from '../../config/workspace-json-project-json';
-import { PackageJson } from '../../utils/package-json';
-import type { PluginConfiguration } from '../../config/nx-json';
-import type { LoadedNxPlugin } from './loaded-nx-plugin';
-export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
-    path: string;
-    json: PackageJson;
-};
-export declare function loadNxPlugin(plugin: PluginConfiguration, root: string, index?: number): readonly [Promise<LoadedNxPlugin>, () => void];
-export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], root: string, index?: number): Promise<LoadedNxPlugin>;

package/dist/src/project-graph/plugins/in-process-loader.js

@@ -1,61 +0,0 @@
-"use strict";
-// This file contains methods and utilities that should **only** be used by the plugin worker.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readPluginPackageJson = readPluginPackageJson;
-exports.loadNxPlugin = loadNxPlugin;
-exports.loadNxPluginAsync = loadNxPluginAsync;
-const installation_directory_1 = require("../../utils/installation-directory");
-const package_json_1 = require("../../utils/package-json");
-const fileutils_1 = require("../../utils/fileutils");
-const error_types_1 = require("../error-types");
-const path = require("node:path/posix");
-const resolve_plugin_1 = require("./resolve-plugin");
-const transpiler_1 = require("./transpiler");
-const handle_import_1 = require("../../utils/handle-import");
-function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
-    try {
-        const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
-        return {
-            json: result.packageJson,
-            path: result.path,
-        };
-    }
-    catch (e) {
-        if (e.code === 'MODULE_NOT_FOUND') {
-            const localPluginPath = (0, resolve_plugin_1.resolveLocalNxPlugin)(pluginName, projects);
-            if (localPluginPath) {
-                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
-                if (!(0, transpiler_1.pluginTranspilerIsRegistered)()) {
-                    (0, transpiler_1.registerPluginTSTranspiler)();
-                }
-                return {
-                    path: localPluginPackageJson,
-                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
-                };
-            }
-        }
-        throw e;
-    }
-}
-function loadNxPlugin(plugin, root, index) {
-    return [
-        loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), root, index),
-        () => { },
-    ];
-}
-async function loadNxPluginAsync(pluginConfiguration, paths, root, index) {
-    const moduleName = typeof pluginConfiguration === 'string'
-        ? pluginConfiguration
-        : pluginConfiguration.plugin;
-    try {
-        const { pluginPath, name, shouldRegisterTSTranspiler } = await (0, resolve_plugin_1.resolveNxPlugin)(moduleName, root, paths);
-        if (shouldRegisterTSTranspiler) {
-            (0, transpiler_1.registerPluginTSTranspiler)();
-        }
-        const { loadResolvedNxPluginAsync } = await (0, handle_import_1.handleImport)(require.resolve('./load-resolved-plugin'));
-        return loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name, index);
-    }
-    catch (e) {
-        throw new error_types_1.LoadPluginError(moduleName, e);
-    }
-}

package/dist/src/project-graph/plugins/index.d.ts

@@ -1,4 +0,0 @@
-export * from './public-api';
-export { readPluginPackageJson } from './in-process-loader';
-export { registerPluginTSTranspiler } from './transpiler';
-export { createNodesFromFiles } from './utils';

package/dist/src/project-graph/plugins/index.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodesFromFiles = exports.registerPluginTSTranspiler = exports.readPluginPackageJson = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./public-api"), exports);
-// export * from './get-plugins';
-var in_process_loader_1 = require("./in-process-loader");
-Object.defineProperty(exports, "readPluginPackageJson", { enumerable: true, get: function () { return in_process_loader_1.readPluginPackageJson; } });
-var transpiler_1 = require("./transpiler");
-Object.defineProperty(exports, "registerPluginTSTranspiler", { enumerable: true, get: function () { return transpiler_1.registerPluginTSTranspiler; } });
-var utils_1 = require("./utils");
-Object.defineProperty(exports, "createNodesFromFiles", { enumerable: true, get: function () { return utils_1.createNodesFromFiles; } });

package/dist/src/project-graph/plugins/isolation/enabled.d.ts

@@ -1 +0,0 @@
-export declare function isIsolationEnabled(): boolean;

package/dist/src/project-graph/plugins/isolation/enabled.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIsolationEnabled = isIsolationEnabled;
-const native_1 = require("../../../native");
-function isIsolationEnabled() {
-    // Explicitly enabled, regardless of further conditions
-    if (process.env.NX_ISOLATE_PLUGINS === 'true') {
-        return true;
-    }
-    if (
-    // Explicitly disabled
-    process.env.NX_ISOLATE_PLUGINS === 'false' ||
-        // Isolation is disabled on WASM builds currently.
-        native_1.IS_WASM) {
-        return false;
-    }
-    // Default value
-    return true;
-}

package/dist/src/project-graph/plugins/isolation/index.d.ts

@@ -1 +0,0 @@
-export { loadIsolatedNxPlugin } from './load-isolated-plugin';

package/dist/src/project-graph/plugins/isolation/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadIsolatedNxPlugin = void 0;
-var load_isolated_plugin_1 = require("./load-isolated-plugin");
-Object.defineProperty(exports, "loadIsolatedNxPlugin", { enumerable: true, get: function () { return load_isolated_plugin_1.loadIsolatedNxPlugin; } });

package/dist/src/project-graph/plugins/isolation/isolated-plugin.d.ts

@@ -1,79 +0,0 @@
-import type { PluginConfiguration } from '../../../config/nx-json';
-import type { ProjectGraph } from '../../../config/project-graph';
-import type { RawProjectGraphDependency } from '../../project-graph-builder';
-import { LoadedNxPlugin } from '../loaded-nx-plugin';
-import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContext, CreateNodesResult, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from '../public-api';
-import type { PluginWorkerLoadResult } from './messaging';
-import { Hook, Phase } from './plugin-lifecycle-manager';
-export type LoadResultPayload = Extract<PluginWorkerLoadResult['payload'], {
-    success: true;
-}>;
-export declare class IsolatedPlugin implements LoadedNxPlugin {
-    readonly index?: number;
-    readonly name: string;
-    readonly include?: string[];
-    readonly exclude?: string[];
-    readonly createNodes?: [
-        filePattern: string,
-        fn: (matchedFiles: string[], context: CreateNodesContext) => Promise<Array<readonly [plugin: string, file: string, result: CreateNodesResult]>>
-    ];
-    readonly createDependencies?: (context: CreateDependenciesContext) => Promise<RawProjectGraphDependency[]>;
-    readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => Promise<ProjectsMetadata>;
-    readonly preTasksExecution?: (context: PreTasksExecutionContext) => Promise<NodeJS.ProcessEnv>;
-    readonly postTasksExecution?: (context: PostTasksExecutionContext) => Promise<void>;
-    private worker;
-    private socket;
-    private _alive;
-    private _connectPromise;
-    private txId;
-    private pendingCount;
-    private responseHandlers;
-    private readonly plugin;
-    private readonly root;
-    private readonly pluginPath;
-    private readonly shouldRegisterTSTranspiler;
-    private lifecycle;
-    private exitHandler;
-    /**
-     * Creates and loads an isolated plugin worker.
-     */
-    static load(plugin: PluginConfiguration, root: string, index?: number): Promise<IsolatedPlugin>;
-    private constructor();
-    private spawnAndConnect;
-    /**
-     * Ensures the worker is alive, restarting it if necessary.
-     * Called before each hook execution to handle plugins that were
-     * eagerly shutdown (e.g., post-task-only plugins).
-     *
-     * Uses a stored promise to coalesce concurrent restart attempts
-     * so that only one worker is ever spawned at a time.
-     */
-    private ensureAlive;
-    private handleSocketData;
-    private sendLoadMessage;
-    private setupHooks;
-    private generateTxId;
-    private sendRequest;
-    private shutdownIfInactive;
-    setWorkerEnv(env: Record<string, string>): Promise<void>;
-    notifyPhaseAborted(phase: Phase, lastCompletedHook: Hook): void;
-    shutdown(): void;
-    private registerProcessMetrics;
-}
-export declare function getPluginWorkerSocketId(): string;
-/**
- * Marks a failure to *start or reach* a worker, as distinct from a plugin that
- * loaded and then threw. Only the former can be retried in-process: swallowing
- * the latter would rerun a plugin that already failed on its own merits and
- * bury the real error.
- */
-export declare const PLUGIN_WORKER_STARTUP_FAILURE: unique symbol;
-/**
- * Set when the worker exited with the socket-refused code. Narrower than
- * {@link PLUGIN_WORKER_STARTUP_FAILURE}, which covers every way a worker can
- * fail to come up, and is what lets the caller degrade on a refusal without
- * also degrading for an OOM kill or a broken install.
- */
-export declare const PLUGIN_WORKER_SOCKET_REFUSED: unique symbol;
-export declare function isPluginWorkerStartupFailure(error: unknown): boolean;
-export declare function isPluginWorkerSocketRefusal(error: unknown): boolean;