nx 23.0.0-beta.2 → 23.0.0-beta.21

package/dist/src/command-line/show/show-target/info.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.showTargetInfoHandler = showTargetInfoHandler;
 const task_hasher_1 = require("../../../hasher/task-hasher");
+const create_task_graph_1 = require("../../../tasks-runner/create-task-graph");
 const utils_1 = require("../../../tasks-runner/utils");
 const utils_2 = require("./utils");
 // ── Handler ─────────────────────────────────────────────────────────
@@ -19,10 +20,9 @@ function resolveTargetInfoData(t) {
             allTargetNames.add(name);
         }
     }
-    const extraTargetDeps = Object.fromEntries(Object.entries(nxJson.targetDefaults ?? {})
-        .filter(([, config]) => config.dependsOn)
-        .map(([name, config]) => [name, config.dependsOn]));
-    const depConfigs = (0, utils_1.getDependencyConfigs)({ project: projectName, target: targetName }, extraTargetDeps, graph, [...allTargetNames]);
+    const depConfigs = (0, utils_1.getDependencyConfigs)({ project: projectName, target: targetName }, 
+    // no programmatic extras — `dependsOn` is already merged into the graph node
+    {}, graph, [...allTargetNames]) ?? [];
     // Determine the hoisted command value and which option key it came from
     let command;
     let commandSourceKey;
@@ -43,18 +43,7 @@ function resolveTargetInfoData(t) {
         command = targetConfig.options.script;
         commandSourceKey = 'options.script';
     }
-    const dependsOn = [];
-    const depSourceIndices = [];
-    if (depConfigs && depConfigs.length > 0) {
-        for (let i = 0; i < depConfigs.length; i++) {
-            const dep = depConfigs[i];
-            const projects = resolveDependencyProjects(dep, projectName, graph);
-            for (const p of projects) {
-                dependsOn.push(`${p}:${dep.target}`);
-                depSourceIndices.push(i);
-            }
-        }
-    }
+    const { dependsOn, depSourceIndices, transitiveTasks } = resolveTaskGraphDependencies(graph, {}, projectName, targetName, configuration, depConfigs);
     const configurations = Object.keys(targetConfig.configurations ?? {});
     const targetSourceMap = extractTargetSourceMap(node.data.root, targetName, sourceMaps);
     const usesCustomHasher = (0, utils_2.hasCustomHasher)(projectName, targetName, graph);
@@ -68,6 +57,7 @@ function resolveTargetInfoData(t) {
         ...(dependsOn.length > 0
             ? { dependsOn, _depSources: depSourceIndices }
             : {}),
+        ...(transitiveTasks.length > 0 ? { transitiveTasks } : {}),
         parallelism: targetConfig.parallelism ?? true,
         continuous: targetConfig.continuous ?? false,
         cache: targetConfig.cache ?? false,
@@ -110,6 +100,93 @@ function resolveDependencyProjects(dep, projectName, graph) {
     }
     return [projectName];
 }
+/**
+ * Builds a task graph rooted at the requested target and returns:
+ *   - `dependsOn`: direct task dependencies of the root, with real
+ *     project/target resolution applied.
+ *   - `depSourceIndices`: for each direct dep, the index of the original
+ *     depConfig it corresponds to (for source-map hints), or -1 if unknown.
+ *   - `transitiveTasks`: task IDs reachable through the direct deps (not
+ *     the root, not direct deps).
+ *
+ * If `createTaskGraph` throws (e.g. circular dependencies), falls back to
+ * the `depConfig`-based resolution so the output still shows the configured
+ * list rather than silently collapsing to empty.
+ */
+function resolveTaskGraphDependencies(graph, extraTargetDeps, projectName, targetName, configuration, depConfigs) {
+    try {
+        const taskGraph = (0, create_task_graph_1.createTaskGraph)(graph, extraTargetDeps, [projectName], [targetName], configuration, {});
+        const rootId = (0, utils_1.createTaskId)(projectName, targetName, configuration);
+        const directDeps = taskGraph.dependencies[rootId] ?? [];
+        const directDepSet = new Set(directDeps);
+        const depSourceIndices = directDeps.map((depTaskId) => {
+            const task = taskGraph.tasks[depTaskId];
+            if (!task)
+                return -1;
+            return findDepConfigIndex(task.target, depConfigs, projectName, graph);
+        });
+        // `Object.keys(dependencies)` gives the set of real (non-dummy) tasks
+        // in the graph — `filterDummyTasks` (called inside `createTaskGraph`)
+        // removes dummy entries from `dependencies` but leaves them in `tasks`.
+        const transitiveTasks = Object.keys(taskGraph.dependencies).filter((id) => id !== rootId && !directDepSet.has(id));
+        return { dependsOn: directDeps, depSourceIndices, transitiveTasks };
+    }
+    catch {
+        return {
+            ...resolveDependsOnFromConfigs(depConfigs, projectName, graph),
+            transitiveTasks: [],
+        };
+    }
+}
+function resolveDependsOnFromConfigs(depConfigs, projectName, graph) {
+    const dependsOn = [];
+    const depSourceIndices = [];
+    for (let i = 0; i < depConfigs.length; i++) {
+        const dep = depConfigs[i];
+        const projects = resolveDependencyProjects(dep, projectName, graph);
+        for (const p of projects) {
+            dependsOn.push(`${p}:${dep.target}`);
+            depSourceIndices.push(i);
+        }
+    }
+    return { dependsOn, depSourceIndices };
+}
+/**
+ * Builds the summary line shown beneath the direct `Depends On` list.
+ *
+ * Up to 3 unique target names: list them (`and 5 build, compile transitive tasks`).
+ * Beyond that: collapse to the count alone (`and 12 transitive tasks`).
+ */
+function formatTransitiveSummary(taskIds) {
+    const count = taskIds.length;
+    const plural = count === 1 ? 'task' : 'tasks';
+    const targetNames = uniqueTargetNames(taskIds);
+    if (targetNames.length === 0 || targetNames.length > 3) {
+        return `and ${count} transitive ${plural}`;
+    }
+    return `and ${count} ${targetNames.join(', ')} transitive ${plural}`;
+}
+function uniqueTargetNames(taskIds) {
+    const set = new Set();
+    for (const id of taskIds) {
+        // task ids are `project:target` or `project:target:config`
+        const parts = id.split(':');
+        if (parts.length >= 2)
+            set.add(parts[1]);
+    }
+    return [...set].sort();
+}
+function findDepConfigIndex(taskTarget, depConfigs, rootProject, graph) {
+    for (let i = 0; i < depConfigs.length; i++) {
+        const dep = depConfigs[i];
+        if (dep.target !== taskTarget.target)
+            continue;
+        const resolved = resolveDependencyProjects(dep, rootProject, graph);
+        if (resolved.includes(taskTarget.project))
+            return i;
+    }
+    return -1;
+}
 /**
  * Expands named inputs (e.g. "production") to their definitions while
  * tracking which original input index each expanded item came from.
@@ -216,11 +293,15 @@ function renderTargetInfo(data, args) {
     if (data.dependsOn && data.dependsOn.length > 0) {
         console.log(`${c.bold('Depends On')}:`);
         for (let i = 0; i < data.dependsOn.length; i++) {
-            const hint = data._depSources?.[i] !== undefined
-                ? sourceHint(`dependsOn.${data._depSources[i]}`, 'dependsOn')
-                : '';
+            const srcIdx = data._depSources?.[i];
+            const hint = srcIdx !== undefined && srcIdx >= 0
+                ? sourceHint(`dependsOn.${srcIdx}`, 'dependsOn')
+                : sourceHint('dependsOn');
             console.log(`  ${data.dependsOn[i]}${hint}`);
         }
+        if (data.transitiveTasks && data.transitiveTasks.length > 0) {
+            console.log(`  ${c.dim(formatTransitiveSummary(data.transitiveTasks))}`);
+        }
     }
     console.log(`${c.bold('Parallelism')}: ${data.parallelism}${sourceHint('parallelism')}`);
     console.log(`${c.bold('Continuous')}: ${data.continuous}${sourceHint('continuous')}`);

package/dist/src/command-line/watch/command-object.js

@@ -13,7 +13,7 @@ exports.yargsWatchCommand = {
     },
 };
 function withWatchOptions(yargs) {
-    return (0, shared_options_1.withVerbose)(yargs)
+    return ((0, shared_options_1.withVerbose)(yargs)
         .parserConfiguration({
         'strip-dashed': true,
         'populate--': true,
@@ -28,10 +28,16 @@ function withWatchOptions(yargs) {
         type: 'boolean',
         description: 'Watch all projects.',
     })
-        .option('includeDependentProjects', {
+        .option('includeDependencies', {
         type: 'boolean',
-        description: 'When watching selected projects, include dependent projects as well.',
+        description: 'When watching selected projects, also include the projects they depend on.',
         alias: 'd',
+    })
+        // TODO(v24): remove the deprecated --includeDependentProjects alias
+        .option('includeDependentProjects', {
+        type: 'boolean',
+        hidden: true,
+        describe: "Deprecated in favor of --includeDependencies; will be removed in Nx 24. The flag name was misleading since it includes the watched project's dependencies, not its dependents. The new flag is functionally identical.",
     })
         .option('includeGlobalWorkspaceFiles', {
         type: 'boolean',
@@ -67,5 +73,19 @@ function withWatchOptions(yargs) {
         else {
             throw Error('No command specified for watch mode.');
         }
-    }, true);
+        // --includeDependentProjects was renamed to --includeDependencies in
+        // Nx 23 because the original name was misleading: it includes the
+        // watched project's *dependencies*, not its dependents. The new flag
+        // is functionally identical — only the name changed. Map the legacy
+        // name through so existing scripts keep working during the
+        // deprecation window.
+        // TODO(v24): remove the legacy includeDependentProjects pass-through
+        const a = args;
+        if (a.includeDependentProjects !== undefined &&
+            a.includeDependencies === undefined) {
+            a.includeDependencies = a.includeDependentProjects;
+            // eslint-disable-next-line no-console
+            console.warn("--includeDependentProjects is deprecated in favor of --includeDependencies and will be removed in Nx 24. The flag name was misleading since it includes the watched project's dependencies, not its dependents. The new flag is functionally identical.");
+        }
+    }, true));
 }

package/dist/src/command-line/watch/completion.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/command-line/watch/completion.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = require("../completion/metadata");
+const completion_providers_1 = require("../completion/completion-providers");
+(0, metadata_1.registerCompletion)('watch', {
+    flags: {
+        projects: completion_providers_1.getProjectNameCompletions,
+        p: completion_providers_1.getProjectNameCompletions,
+    },
+});

package/dist/src/command-line/watch/watch.d.ts

@@ -2,6 +2,13 @@ import { ChangedFile } from '../../daemon/client/client';
 export interface WatchArguments {
     projects?: string[];
     all?: boolean;
+    includeDependencies?: boolean;
+    /**
+     * @deprecated Renamed to {@link WatchArguments.includeDependencies}; will be
+     * removed in Nx 24. The original name was misleading: this flag includes
+     * the watched project's dependencies, not its dependents. The new property
+     * is functionally identical — only the name changed.
+     */
     includeDependentProjects?: boolean;
     includeGlobalWorkspaceFiles?: boolean;
     verbose?: boolean;

package/dist/src/command-line/watch/watch.js

@@ -149,7 +149,7 @@ async function watch(args) {
     }
     await client_1.daemonClient.registerFileWatcher({
         watchProjects: whatToWatch,
-        includeDependentProjects: args.includeDependentProjects,
+        includeDependencies: args.includeDependencies ?? args.includeDependentProjects,
         includeGlobalWorkspaceFiles: args.includeGlobalWorkspaceFiles,
     }, async (err, data) => {
         if (err === 'reconnecting') {

package/dist/src/config/misc-interfaces.d.ts

@@ -61,12 +61,28 @@ export type PackageJsonUpdates = {
  * Returning a string[] from the migration function will be interpreted as
  * a list of next steps to be displayed to the user.
  */
-export type Migration = (tree: Tree) => void | Promise<void> | string[] | Promise<string[]>;
+/**
+ * Structured return value for a migration function.
+ *
+ * - `nextSteps`: workspace-wide notes surfaced to the human in the `nx migrate`
+ *   post-run summary. Same audience as the legacy `string[]` return.
+ * - `agentContext`: for hybrid migrations (`implementation` + `prompt`). When the
+ *   paired prompt runs under `--agentic`, these strings are delivered to the
+ *   agent as part of its outer prompt. When no agent runs, this bucket is
+ *   silently dropped — it is agent-only by contract. Content meant for the
+ *   human in any scenario belongs in `nextSteps`.
+ */
+export interface MigrationReturnObject {
+    nextSteps?: string[];
+    agentContext?: string[];
+}
+export type Migration = (tree: Tree) => void | string[] | MigrationReturnObject | Promise<void | string[] | MigrationReturnObject>;
 export interface MigrationsJsonEntry {
     version: string;
     description?: string;
     implementation?: string;
     factory?: string;
+    prompt?: string;
     requires?: Record<string, string>;
 }
 export type MigrationDetailsWithId = GeneratedMigrationDetails & {
@@ -77,7 +93,8 @@ export interface GeneratedMigrationDetails {
     version: string;
     package: string;
     description: string;
-    implementation: string;
+    implementation?: string;
+    prompt?: string;
 }
 export interface MigrationsJson {
     name?: string;
@@ -148,6 +165,12 @@ export type TaskResult = {
     terminalOutput: string;
     startTime?: number;
     endTime?: number;
+    /**
+     * Explicit status. When set, takes precedence over `success`. Required for
+     * batch executors that need to distinguish `'skipped'` peers (tasks that
+     * never ran because a sibling failed) from real failures.
+     */
+    status?: 'success' | 'failure' | 'skipped';
 };
 export type BatchExecutorResult = Record<string, TaskResult>;
 export type BatchExecutorTaskResult = {

package/dist/src/config/nx-json.d.ts

@@ -18,7 +18,43 @@ export interface NxAffectedConfig {
      */
     defaultBase?: string;
 }
-export type TargetDefaults = Record<string, Partial<TargetConfiguration>>;
+/**
+ * A single entry in the array-shaped `targetDefaults` configuration.
+ * Supports filtering the default's applicability by project set and/or the
+ * plugin that originated the target.
+ *
+ * Either `target` or `executor` must be set. An entry with both narrows
+ * the match further (target name AND executor must agree).
+ */
+export type TargetDefaultEntry = {
+    /**
+     * Target name or glob pattern (e.g. `build`, `e2e-ci--*`). When omitted,
+     * the entry matches by `executor` alone.
+     */
+    target?: string;
+    /**
+     * Restrict the default to a subset of projects. Accepts any pattern
+     * supported by `findMatchingProjects` (project names, globs, `tag:foo`,
+     * directory globs, negation with `!`).
+     */
+    projects?: string | string[];
+    /**
+     * Restrict the default to targets originated by a specific plugin
+     * (e.g. `@nx/vite`). Matches against the plugin that wrote the target's
+     * `executor` or `command`.
+     */
+    plugin?: string;
+} & Partial<TargetConfiguration>;
+/**
+ * @deprecated Use the array-shaped {@link TargetDefaultEntry}[] form instead.
+ * Retained so devkit helpers can still read nx.json files that predate the
+ * migration.
+ * @todo(v24) Remove this type and all branches that read it.
+ */
+export type TargetDefaultsRecord = Record<string, Partial<TargetConfiguration>>;
+export type TargetDefaults = TargetDefaultEntry[] | TargetDefaultsRecord;
+/** Internal-only: the post-normalization shape consumed by the nx core matcher. */
+export type NormalizedTargetDefaults = TargetDefaultEntry[];
 export type TargetDependencies = Record<string, (TargetDependencyConfig | string)[]>;
 export interface NrwlJsPluginConfig {
     analyzeSourceFiles?: boolean;
@@ -179,7 +215,7 @@ export interface NxReleaseVersionConfiguration {
      *  The new version will be "1.2.0" and the current version range in dependents is already "^1.0.0"
      *  Therefore, the manifest file is not updated.
      *
-     * This is false by default.
+     * This is true by default. Set to false to always rewrite dependent manifests with the new version.
      */
     preserveMatchingDependencyRanges?: boolean | Array<'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies'>;
     /**
@@ -195,7 +231,7 @@ export interface NxReleaseVersionConfiguration {
      *
      * Versions 1.0.0 and above are unaffected.
      *
-     * This is false by default for backward compatibility.
+     * This is true by default. Set to false to opt out and treat all bumps the same regardless of major version.
      */
     adjustSemverBumpsForZeroMajorVersion?: boolean;
     /**
@@ -215,7 +251,7 @@ export interface NxReleaseChangelogConfiguration {
      * Optionally create a release containing all relevant changes on a supported version control system, it
      * is false by default.
      *
-     * NOTE: if createRelease is set on a group of projects, it will cause the default releaseTagPattern of
+     * NOTE: if createRelease is set on a group of projects, it will cause the default releaseTag.pattern of
      * "{projectName}@{version}" to be used for those projects, even when versioning everything together.
      */
     createRelease?: false | 'github' | 'gitlab' | {
@@ -426,7 +462,7 @@ export interface NxReleaseConfiguration {
              */
             pattern?: string;
             /**
-             * By default, we will try and resolve the latest match for the releaseTagPattern from the current branch,
+             * By default, we will try and resolve the latest match for the releaseTag.pattern from the current branch,
              * falling back to all branches if no match is found on the current branch.
              *
              * - Setting this to true will cause us to ALWAYS check all branches for the latest match.
@@ -468,31 +504,10 @@ export interface NxReleaseConfiguration {
              * If "strictPreid" is set to false, the git tag "my-lib@1.2.4-beta.1" will always be resolved as the latest tag that matches the pattern,
              * regardless of any preid which gets passed to nx release.
              *
-             * NOTE: This feature was added in a minor version and is therefore set to false by default, but this may change in a future major version.
+             * This is true by default. Set to false to always resolve the latest matching tag regardless of preid.
              */
             strictPreid?: boolean;
         };
-        /**
-         * @deprecated Use `releaseTag.pattern` instead. Will be removed in Nx 23.
-         * Optionally override the git/release tag pattern to use for this group.
-         */
-        releaseTagPattern?: string;
-        /**
-         * @deprecated Use `releaseTag.checkAllBranchesWhen` instead. Will be removed in Nx 23.
-         */
-        releaseTagPatternCheckAllBranchesWhen?: boolean | string[];
-        /**
-         * @deprecated Use `releaseTag.requireSemver` instead. Will be removed in Nx 23.
-         */
-        releaseTagPatternRequireSemver?: boolean;
-        /**
-         * @deprecated Use `releaseTag.preferDockerVersion` instead. Will be removed in Nx 23.
-         */
-        releaseTagPatternPreferDockerVersion?: boolean | 'both';
-        /**
-         * @deprecated Use `releaseTag.strictPreid` instead. Will be removed in Nx 23.
-         */
-        releaseTagPatternStrictPreid?: boolean;
         /**
          * Enables using version plans as a specifier source for versioning and
          * to determine changes for changelog generation.
@@ -598,38 +613,10 @@ export interface NxReleaseConfiguration {
          * If "strictPreid" is set to false, the git tag "my-lib@1.2.4-beta.1" will always be resolved as the latest tag that matches the pattern,
          * regardless of any preid which gets passed to nx release.
          *
-         * NOTE: This feature was added in a minor version and is therefore set to false by default, but this may change in a future major version.
+         * This is true by default. Set to false to always resolve the latest matching tag regardless of preid.
          */
         strictPreid?: boolean;
     };
-    /**
-     * @deprecated Use `releaseTag.pattern` instead. Will be removed in Nx 23.
-     * Optionally override the git/release tag pattern to use. This field is the source of truth
-     * for changelog generation and release tagging, as well as for conventional commits parsing.
-     *
-     * It supports interpolating the version as {version} and (if releasing independently or forcing
-     * project level version control system releases) the project name as {projectName} within the string.
-     *
-     * The default releaseTagPattern for fixed/unified releases is: "v{version}"
-     * The default releaseTagPattern for independent releases at the project level is: "{projectName}@{version}"
-     */
-    releaseTagPattern?: string;
-    /**
-     * @deprecated Use `releaseTag.checkAllBranchesWhen` instead. Will be removed in Nx 23.
-     */
-    releaseTagPatternCheckAllBranchesWhen?: boolean | string[];
-    /**
-     * @deprecated Use `releaseTag.requireSemver` instead. Will be removed in Nx 23.
-     */
-    releaseTagPatternRequireSemver?: boolean;
-    /**
-     * @deprecated Use `releaseTag.preferDockerVersion` instead. Will be removed in Nx 23.
-     */
-    releaseTagPatternPreferDockerVersion?: boolean | 'both';
-    /**
-     * @deprecated Use `releaseTag.strictPreid` instead. Will be removed in Nx 23.
-     */
-    releaseTagPatternStrictPreid?: boolean;
     /**
      * Enable and configure automatic git operations as part of the release
      */

package/dist/src/config/schema-utils.d.ts

@@ -1,4 +1,25 @@
 import type { ProjectConfiguration } from './workspace-json-project-json';
+/**
+ * Thrown when the schema file of an executor or generator cannot be resolved.
+ */
+export declare class SchemaResolutionError extends Error {
+    readonly schemaPath: string;
+    readonly directory: string;
+    constructor(schemaPath: string, directory: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when the implementation module of an executor or generator cannot be
+ * resolved.
+ */
+export declare class ImplementationResolutionError extends Error {
+    readonly implementationModulePath: string;
+    readonly directory: string;
+    constructor(implementationModulePath: string, directory: string, options?: {
+        cause?: unknown;
+    });
+}
 /**
  * This function is used to get the implementation factory of an executor or generator.
  * @param implementation path to the implementation

package/dist/src/config/schema-utils.js

@@ -1,14 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImplementationResolutionError = exports.SchemaResolutionError = void 0;
 exports.getImplementationFactory = getImplementationFactory;
 exports.resolveImplementation = resolveImplementation;
 exports.resolveSchema = resolveSchema;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const resolve_exports_1 = require("resolve.exports");
+const register_1 = require("../plugins/js/utils/register");
 const packages_1 = require("../plugins/js/utils/packages");
-const plugins_1 = require("../project-graph/plugins");
+const typescript_1 = require("../plugins/js/utils/typescript");
+const find_project_for_path_1 = require("../project-graph/utils/find-project-for-path");
+const fileutils_1 = require("../utils/fileutils");
+const package_json_1 = require("../utils/package-json");
 const path_2 = require("../utils/path");
+const workspace_root_1 = require("../utils/workspace-root");
+/**
+ * Thrown when the schema file of an executor or generator cannot be resolved.
+ */
+class SchemaResolutionError extends Error {
+    constructor(schemaPath, directory, options) {
+        super(`Could not resolve schema "${schemaPath}" from "${directory}".`, options);
+        this.schemaPath = schemaPath;
+        this.directory = directory;
+        this.name = 'SchemaResolutionError';
+    }
+}
+exports.SchemaResolutionError = SchemaResolutionError;
+/**
+ * Thrown when the implementation module of an executor or generator cannot be
+ * resolved.
+ */
+class ImplementationResolutionError extends Error {
+    constructor(implementationModulePath, directory, options) {
+        super(`Could not resolve "${implementationModulePath}" from "${directory}".`, options);
+        this.implementationModulePath = implementationModulePath;
+        this.directory = directory;
+        this.name = 'ImplementationResolutionError';
+    }
+}
+exports.ImplementationResolutionError = ImplementationResolutionError;
 /**
  * This function is used to get the implementation factory of an executor or generator.
  * @param implementation path to the implementation
@@ -19,10 +50,14 @@ function getImplementationFactory(implementation, directory, packageName, projec
     const [implementationModulePath, implementationExportName] = implementation.split('#');
     return () => {
         const modulePath = resolveImplementation(implementationModulePath, directory, packageName, projects);
-        if ((0, path_1.extname)(modulePath) === '.ts') {
-            (0, plugins_1.registerPluginTSTranspiler)();
-        }
-        const module = require(modulePath);
+        // Route .ts entrypoints through loadTsFile so the native-strip ->
+        // swc/ts-node fallback chain runs. Plain require() bypasses the matcher
+        // set and bubbles errors like extensionless `./schema` imports (strict
+        // ESM resolution failures) straight to the CLI. JS entrypoints use
+        // requireWithTsconfigFallback so workspace-alias imports still resolve.
+        const module = /\.[cm]?ts$/.test(modulePath)
+            ? (0, register_1.loadTsFile)(modulePath)
+            : (0, register_1.requireWithTsconfigFallback)(modulePath);
         return implementationExportName
             ? module[implementationExportName]
             : (module.default ?? module);
@@ -59,7 +94,7 @@ function resolveImplementation(implementationModulePath, directory, packageName,
         }
         catch { }
     }
-    throw new Error(`Could not resolve "${implementationModulePath}" from "${directory}".`);
+    throw new ImplementationResolutionError(implementationModulePath, directory);
 }
 function resolveSchema(schemaPath, directory, packageName, projects) {
     if (!directory.includes('node_modules')) {
@@ -75,24 +110,63 @@ function resolveSchema(schemaPath, directory, packageName, projects) {
     if ((0, fs_1.existsSync)(maybeSchemaPath)) {
         return maybeSchemaPath;
     }
-    return require.resolve(schemaPath, {
-        paths: [directory],
-    });
+    try {
+        return require.resolve(schemaPath, {
+            paths: [directory],
+        });
+    }
+    catch (e) {
+        throw new SchemaResolutionError(schemaPath, directory, { cause: e });
+    }
 }
-let packageToProjectMap;
+let projectRootMappings;
+function getProjectForDirectory(directory, projects) {
+    projectRootMappings ??=
+        (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projects);
+    const projectName = (0, find_project_for_path_1.findProjectForPath)((0, path_1.relative)(workspace_root_1.workspaceRoot, directory), projectRootMappings);
+    return projectName ? projects[projectName] : null;
+}
+/**
+ * Reads the JS package metadata (package name and exports) for a project
+ * directly from its `package.json`. Used as a fallback when a project's graph
+ * metadata doesn't include the JS metadata.
+ */
+function readJsPackageMetadata(project) {
+    const packageJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, project.root, 'package.json');
+    if (!(0, fs_1.existsSync)(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+        return (0, package_json_1.getMetadataFromPackageJson)(packageJson, false).js;
+    }
+    catch {
+        return null;
+    }
+}
+let packageMetadata;
 function tryResolveFromSource(path, directory, packageName, projects) {
-    packageToProjectMap ??=
-        (0, packages_1.getWorkspacePackagesMetadata)(projects).packageToProjectMap;
-    const localProject = packageToProjectMap[packageName];
+    packageMetadata ??= (0, packages_1.getWorkspacePackagesMetadata)(projects);
+    let localProject = packageMetadata.packageToProjectMap[packageName];
+    // The `packageName` might be a path to the collection rather than an actual
+    // package name (e.g. when a generator/executor collection is referenced by
+    // path). In that case, `directory` points inside the local project, so we
+    // find the project that contains it.
+    localProject ??= getProjectForDirectory(directory, projects);
     if (!localProject) {
-        // it doesn't match any of the package names from the local projects
         return null;
     }
+    const js = localProject.metadata?.js ??
+        readJsPackageMetadata(localProject);
+    if (!js) {
+        return null;
+    }
+    const name = js.packageName;
+    const exports = js.packageExports;
     try {
-        const fromExports = (0, resolve_exports_1.resolve)({
-            name: localProject.metadata.js.packageName,
-            exports: localProject.metadata.js.packageExports,
-        }, path, { conditions: ['development'] });
+        const fromExports = (0, resolve_exports_1.resolve)({ name, exports }, path, {
+            conditions: (0, typescript_1.getRootTsConfigResolveExportsConditions)(),
+        });
         if (fromExports && fromExports.length) {
             for (const exportPath of fromExports) {
                 if ((0, fs_1.existsSync)((0, path_1.join)(directory, exportPath))) {