@ohos-ports/nx 23.3.0-beta.2 → 24.0.2-beta.0

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

@@ -4,11 +4,19 @@ 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 ready_when_1 = require("../../../tasks-runner/readiness/ready-when");
+const native_1 = require("../../../native");
+const ci_status_1 = require("../../../ultracache/ci-status");
 const utils_2 = require("./utils");
 // ── Handler ─────────────────────────────────────────────────────────
 async function showTargetInfoHandler(args) {
     const t = await (0, utils_2.resolveTarget)(args, { withSourceMaps: true });
     const data = resolveTargetInfoData(t);
+    if (!args.json &&
+        data.ultracacheMode &&
+        (await (0, ci_status_1.isUltracacheOnInCI)(t.nxJson))) {
+        data.ultracacheInCI = data.ultracacheMode;
+    }
     renderTargetInfo(data, args);
 }
 function resolveTargetInfoData(t) {
@@ -43,10 +51,13 @@ function resolveTargetInfoData(t) {
         command = targetConfig.options.script;
         commandSourceKey = 'options.script';
     }
-    const { dependsOn, depSourceIndices, transitiveTasks } = resolveTaskGraphDependencies(graph, {}, projectName, targetName, configuration, depConfigs);
+    const { dependsOn, depSourceIndices, transitiveTasks, continuousDeps } = 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);
+    const expandedInputs = targetConfig.inputs
+        ? expandInputsForDisplay(targetConfig.inputs, node, nxJson)
+        : undefined;
     return {
         project: projectName,
         target: targetName,
@@ -55,20 +66,24 @@ function resolveTargetInfoData(t) {
         ...(command ? { command, _commandSourceKey: commandSourceKey } : {}),
         ...(usesCustomHasher ? { customHasher: true } : {}),
         ...(dependsOn.length > 0
-            ? { dependsOn, _depSources: depSourceIndices }
+            ? {
+                dependsOn,
+                _depSources: depSourceIndices,
+                _continuousDeps: continuousDeps,
+            }
             : {}),
         ...(transitiveTasks.length > 0 ? { transitiveTasks } : {}),
         parallelism: targetConfig.parallelism ?? true,
         continuous: targetConfig.continuous ?? false,
+        ...(targetConfig.readyWhen !== undefined
+            ? { readyWhen: withEffectiveTimeout(targetConfig.readyWhen) }
+            : {}),
         cache: targetConfig.cache ?? false,
-        ...(targetConfig.inputs
-            ? (() => {
-                const expanded = expandInputsForDisplay(targetConfig.inputs, node, nxJson);
-                return {
-                    inputs: expanded.map((e) => e.value),
-                    _inputSources: expanded.map((e) => e.originalIndex),
-                };
-            })()
+        ...(expandedInputs
+            ? {
+                inputs: expandedInputs.map((e) => e.value),
+                _inputSources: expandedInputs.map((e) => e.originalIndex),
+            }
             : {}),
         ...(targetConfig.outputs
             ? { outputs: targetConfig.outputs }
@@ -84,8 +99,16 @@ function resolveTargetInfoData(t) {
             ? { defaultConfiguration: targetConfig.defaultConfiguration }
             : {}),
         ...(targetSourceMap ? { sourceMap: targetSourceMap } : {}),
+        /** Set by the handler once Nx Cloud confirms the workspace is On. */
+        ultracacheInCI: undefined,
+        ultracacheMode: (0, ci_status_1.ultracacheModeInCI)(targetConfig, usesCustomHasher),
     };
 }
+function withEffectiveTimeout(readyWhen) {
+    if (readyWhen === null || typeof readyWhen !== 'object')
+        return readyWhen;
+    return { ...readyWhen, timeout: readyWhen.timeout ?? ready_when_1.DEFAULT_READY_TIMEOUT };
+}
 function resolveDependencyProjects(dep, projectName, graph) {
     if (dep.projects && dep.projects.length > 0)
         return dep.projects;
@@ -126,8 +149,15 @@ function resolveTaskGraphDependencies(graph, extraTargetDeps, projectName, targe
         const directDeps = [
             ...(taskGraph.dependencies[rootId] ?? []),
             ...(taskGraph.continuousDependencies[rootId] ?? []),
-        ];
+        ].map((edge) => edge.id);
         const directDepSet = new Set(directDeps);
+        const continuousDeps = Object.fromEntries((taskGraph.continuousDependencies[rootId] ?? []).map((edge) => [
+            edge.id,
+            {
+                inputsHashed: edge.inputs !== false,
+                waitsForReady: edge.waitFor === 'ready',
+            },
+        ]));
         const depSourceIndices = directDeps.map((depTaskId) => {
             const task = taskGraph.tasks[depTaskId];
             if (!task)
@@ -138,7 +168,12 @@ function resolveTaskGraphDependencies(graph, extraTargetDeps, projectName, targe
         // 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 };
+        return {
+            dependsOn: directDeps,
+            depSourceIndices,
+            transitiveTasks,
+            continuousDeps,
+        };
     }
     catch {
         return {
@@ -259,10 +294,39 @@ function extractTargetSourceMap(projectRoot, targetName, sourceMaps) {
     return Object.keys(result).length > 0 ? result : undefined;
 }
 // ── Render ──────────────────────────────────────────────────────────
+function describeReadyWhen(readyWhen) {
+    if (readyWhen === null)
+        return 'off (null)';
+    if (typeof readyWhen !== 'object')
+        return JSON.stringify(readyWhen);
+    const timing = [`timeout ${(0, native_1.formatDuration)(readyWhen.timeout)}`];
+    if ('interval' in readyWhen && readyWhen.interval !== undefined) {
+        timing.push(`interval ${(0, native_1.formatDuration)(readyWhen.interval)}`);
+    }
+    return `${describeReadyCheck(readyWhen)} (${timing.join(', ')})`;
+}
+function describeReadyCheck(readyWhen) {
+    if ('url' in readyWhen)
+        return `url ${readyWhen.url}`;
+    if ('port' in readyWhen) {
+        return readyWhen.host
+            ? `port ${readyWhen.port} on ${readyWhen.host}`
+            : `port ${readyWhen.port}`;
+    }
+    if ('command' in readyWhen)
+        return `command "${readyWhen.command}"`;
+    if ('logMatches' in readyWhen) {
+        const matches = [readyWhen.logMatches].flat().map((m) => `"${m}"`);
+        return `logMatches ${matches.join(', ')}`;
+    }
+    if ('signal' in readyWhen)
+        return 'signal';
+    return JSON.stringify(readyWhen);
+}
 function renderTargetInfo(data, args) {
     if (args.json) {
         // Strip internal renderer-only fields from JSON output
-        const { _inputSources, _depSources, _commandSourceKey, ...jsonData } = data;
+        const { _inputSources, _depSources, _commandSourceKey, _continuousDeps, ultracacheMode, ultracacheInCI, ...jsonData } = data;
         console.log(JSON.stringify(jsonData, null, 2));
         return;
     }
@@ -306,7 +370,13 @@ function renderTargetInfo(data, args) {
             const hint = srcIdx !== undefined && srcIdx >= 0
                 ? sourceHint(`dependsOn.${srcIdx}`, 'dependsOn')
                 : sourceHint('dependsOn');
-            console.log(`  ${data.dependsOn[i]}${hint}`);
+            const continuousDep = data._continuousDeps?.[data.dependsOn[i]];
+            const note = continuousDep
+                ? ` ${c.dim(continuousDep.waitsForReady
+                    ? '(continuous, waits for ready)'
+                    : '(continuous)')}`
+                : '';
+            console.log(`  ${data.dependsOn[i]}${note}${hint}`);
         }
         if (data.transitiveTasks && data.transitiveTasks.length > 0) {
             console.log(`  ${c.dim(formatTransitiveSummary(data.transitiveTasks))}`);
@@ -314,9 +384,21 @@ function renderTargetInfo(data, args) {
     }
     console.log(`${c.bold('Parallelism')}: ${data.parallelism}${sourceHint('parallelism')}`);
     console.log(`${c.bold('Continuous')}: ${data.continuous}${sourceHint('continuous')}`);
+    if (data.readyWhen !== undefined) {
+        console.log(`${c.bold('Ready when')}: ${describeReadyWhen(data.readyWhen)}${sourceHint('readyWhen')}`);
+    }
     console.log(`${c.bold('Cache')}: ${data.cache}${sourceHint('cache')}`);
-    if (data.inputs && data.inputs.length > 0) {
+    if (data.ultracacheInCI) {
+        const notice = (0, ci_status_1.ultracacheInCINotice)(data.ultracacheInCI, (0, ci_status_1.hasAlwaysInput)(data.inputs));
+        console.log(`${c.bold('Ultracache')}: ${notice} ${(0, ci_status_1.ultracacheDocsLink)()}`);
+    }
+    const hashedContinuousDeps = Object.entries(data._continuousDeps ?? {})
+        .filter(([, { inputsHashed }]) => inputsHashed)
+        .map(([depId]) => depId);
+    if (data.inputs?.length || hashedContinuousDeps.length) {
         console.log(`${c.bold('Inputs')}:`);
+    }
+    if (data.inputs && data.inputs.length > 0) {
         const inputSources = data._inputSources;
         // Build sortable entries with their source index
         const entries = data.inputs.map((input, i) => ({
@@ -351,6 +433,9 @@ function renderTargetInfo(data, args) {
             console.log(`  - ${display}${hint}`);
         }
     }
+    for (const depId of hashedContinuousDeps) {
+        console.log(`  - inputs of ${depId} ${c.dim('(continuous dependency)')}`);
+    }
     if (data.outputs && data.outputs.length > 0) {
         console.log(`${c.bold('Outputs')}:`);
         for (let i = 0; i < data.outputs.length; i++) {

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.showTargetInputsHandler = showTargetInputsHandler;
 const check_task_files_1 = require("../../../hasher/check-task-files");
 const utils_1 = require("../../../tasks-runner/utils");
+const ci_status_1 = require("../../../ultracache/ci-status");
 const utils_2 = require("./utils");
 // ── Handler ─────────────────────────────────────────────────────────
 async function showTargetInputsHandler(args) {
@@ -27,7 +28,10 @@ async function showTargetInputsHandler(args) {
         (0, utils_2.setCheckExitCode)(results);
         return;
     }
-    renderInputs({ project: projectName, target: targetName, ...hashInputs }, t.node.data.targets[targetName].inputs, args);
+    const targetConfig = t.node.data.targets[targetName];
+    const mode = args.json ? undefined : (0, ci_status_1.ultracacheModeInCI)(targetConfig, false);
+    const ultracacheInCI = mode && (await (0, ci_status_1.isUltracacheOnInCI)(t.nxJson)) ? mode : undefined;
+    renderInputs({ project: projectName, target: targetName, ...hashInputs }, targetConfig.inputs, args, ultracacheInCI);
 }
 // ── Data resolution ─────────────────────────────────────────────────
 async function checkInputs(taskId, check, hashInputs) {
@@ -51,13 +55,17 @@ async function checkInputs(taskId, check, hashInputs) {
     });
 }
 // ── Render ──────────────────────────────────────────────────────────
-function renderInputs(data, configuredInputs, args) {
+function renderInputs(data, configuredInputs, args, ultracacheInCI) {
     if (args.json) {
         (0, utils_2.printJson)(data);
         return;
     }
     const c = (0, utils_2.pc)();
     console.log(`${c.bold('Inputs for')} ${c.cyan(data.project)}:${c.green(data.target)}`);
+    if (ultracacheInCI) {
+        const notice = (0, ci_status_1.ultracacheInCINotice)(ultracacheInCI, (0, ci_status_1.hasAlwaysInput)(configuredInputs));
+        console.log(`${c.bold('Ultracache')}: ${notice} ${(0, ci_status_1.ultracacheDocsLink)()}`);
+    }
     if (configuredInputs?.length) {
         (0, utils_2.printList)('Configured inputs', configuredInputs.map((i) => typeof i === 'string' ? i : JSON.stringify(i)));
     }

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

@@ -142,6 +142,7 @@ function validateConfiguration(projectName, targetName, configuration, targetCon
     }
 }
 // ── Custom hasher detection ──────────────────────────────────────────
+// TODO(v25): remove custom hasher support.
 /**
  * Checks whether a target's executor defines a custom hasher.
  * Returns true if the executor has a hasherFactory — meaning the

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,
@@ -32,12 +32,6 @@ function withWatchOptions(yargs) {
         type: 'boolean',
         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',
@@ -59,6 +53,7 @@ function withWatchOptions(yargs) {
         .conflicts({
         all: 'projects',
     })
+        .strictOptions()
         .check((args) => {
         if (!args.all && !args.projects) {
             throw Error('Please specify either --all or --projects');
@@ -73,19 +68,5 @@ function withWatchOptions(yargs) {
         else {
             throw Error('No command specified for watch mode.');
         }
-        // --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));
+    }, true);
 }

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

@@ -3,13 +3,6 @@ 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;
     command?: string;

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

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

package/dist/src/command-line/yargs-utils/shared-options.js

@@ -249,7 +249,7 @@ function withAffectedOptions(yargs) {
 function withExplainOption(yargs) {
     return yargs.option('explain', {
         type: 'string',
-        describe: 'Print why each task was considered affected, instead of running anything. Needs task selection (NX_LEGACY_AFFECTED=false). Pass a file path to save the reasons as JSON instead. Pass "stdout" to print the JSON to the terminal.',
+        describe: 'Print why each task was considered affected, instead of running anything. Not available with affected.legacy in nx.json. Pass a file path to save the reasons as JSON instead. Pass "stdout" to print the JSON to the terminal.',
         // Same shape as `--graph`: the value is a destination, and a bare
         // `--explain` has to arrive as a boolean. `nx affected` leaves `--json`
         // undeclared so it still reaches the executor.

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

@@ -32,6 +32,9 @@ export interface ExecutorJsonEntryConfig {
     batchImplementation?: string;
     preferBatch?: boolean;
     description?: string;
+    /**
+     * @deprecated Use target inputs instead. This will be removed in Nx 25.
+     */
     hasher?: string;
 }
 export type ExecutorsJsonEntry = string | ExecutorJsonEntryConfig;
@@ -103,6 +106,12 @@ export interface MigrationsJsonEntry {
      * an outer agent or to the user.
      */
     documentation?: string;
+    /**
+     * Marks a migration that applies an optional dependency update.
+     * `nx migrate --include=required` skips it, and `--include=optional` runs it
+     * whenever `requires` is met, so it must set `requires`.
+     */
+    optionalUpdate?: boolean;
 }
 export type MigrationDetailsWithId = GeneratedMigrationDetails & {
     id: string;
@@ -143,6 +152,9 @@ export interface ExecutorConfig {
         outputCapture?: OutputCaptureMethod;
         continuous?: boolean;
     } & Schema;
+    /**
+     * @deprecated Use target inputs instead. This will be removed in Nx 25.
+     */
     hasherFactory?: () => CustomHasher;
     implementationFactory: () => Executor;
     batchImplementationFactory?: () => TaskGraphExecutor;
@@ -172,6 +184,9 @@ options: T, context: ExecutorContext) => AsyncIterableIterator<{
  * Implementation of a target of a project
  */
 export type Executor<T = any> = PromiseExecutor<T> | AsyncIteratorExecutor<T>;
+/**
+ * @deprecated Use target inputs instead. This will be removed in Nx 25.
+ */
 export interface HasherContext {
     hasher: TaskHasher;
     projectGraph: ProjectGraph;
@@ -179,6 +194,9 @@ export interface HasherContext {
     projectsConfigurations: ProjectsConfigurations;
     nxJsonConfiguration: NxJsonConfiguration;
 }
+/**
+ * @deprecated Use target inputs instead. This will be removed in Nx 25.
+ */
 export type CustomHasher = (task: Task, context: HasherContext) => Promise<Hash>;
 export type TaskResult = {
     success: boolean;

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

@@ -11,14 +11,17 @@ export type ImplicitDependencyEntry<T = '*' | string[]> = {
 export interface ImplicitJsonSubsetDependency<T = '*' | string[]> {
     [key: string]: T | ImplicitJsonSubsetDependency<T>;
 }
-/**
- * @deprecated Use {@link NxJsonConfiguration#defaultBase } instead
- */
 export interface NxAffectedConfig {
     /**
      * Default based branch used by affected commands.
+     * @deprecated Use {@link NxJsonConfiguration#defaultBase } instead. This will be removed in Nx 25.
      */
     defaultBase?: string;
+    /**
+     * Select every task of each affected project, instead of only the tasks
+     * whose inputs a change reaches. Defaults to `false`.
+     */
+    legacy?: boolean;
 }
 /**
  * A logical, flat view of a single target default — the shape devkit helpers
@@ -711,7 +714,9 @@ export interface NxSyncConfiguration {
 export interface NxMigrateConfiguration {
     /**
      * Whether to automatically create a git commit after each migration runs.
-     * Equivalent to the `--create-commits` flag. Defaults to `false`.
+     * Equivalent to the `--create-commits` flag. Defaults to `true` when the
+     * agentic flow runs the migrations in a Git repository, and `false`
+     * otherwise.
      */
     createCommits?: boolean;
     /**
@@ -739,8 +744,7 @@ export interface NxMigrateConfiguration {
     /**
      * Whether `nx migrate` resolves package versions via the npm registry
      * (faster) instead of a package-manager install. The
-     * `NX_MIGRATE_USE_REGISTRY_RESOLUTION` and legacy
-     * `NX_MIGRATE_SKIP_REGISTRY_FETCH` env vars take precedence over this.
+     * `NX_MIGRATE_USE_REGISTRY_RESOLUTION` env var takes precedence over this.
      * Defaults to `true`.
      */
     useRegistryResolution?: boolean;
@@ -753,11 +757,18 @@ export interface NxMigrateConfiguration {
      */
     agentic?: boolean | AgentId;
     /**
-     * Whether to run agent-driven validation after generator-only migrations when
-     * the agentic flow is enabled. Equivalent to the `--validate` flag. Defaults
-     * to `true` when the agentic flow is enabled.
+     * Whether the AI agent driving a migrate run reviews the changes of
+     * generator-only migrations. Equivalent to the `--validate` flag. Defaults to
+     * `true`.
      */
     validate?: boolean;
+    /**
+     * Whether a migrate run an AI agent drives ends with a final check, where the
+     * agent makes sure the projects the run touched still lint, build, and pass
+     * their unit tests. Equivalent to the `--final-validation` flag. Defaults to
+     * `true`.
+     */
+    finalValidation?: boolean;
 }
 /**
  * Nx.json configuration
@@ -789,7 +800,6 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
     targetDefaults?: TargetDefaults;
     /**
      * Default options for `nx affected`
-     * @deprecated use {@link defaultBase} instead. For more information see https://nx.dev/docs/reference/nx-json#default-base
      */
     affected?: NxAffectedConfig;
     /**
@@ -903,7 +913,8 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
      */
     useDaemonProcess?: boolean;
     /**
-     * Set this to false to disable adding inference plugins when generating new projects
+     * When false, `nx add` does not update package.json scripts by default and
+     * `nx init` uses its legacy setup. Generators always add their inference plugin.
      */
     useInferencePlugins?: boolean;
     /**

package/dist/src/config/task-graph.d.ts

@@ -3,4 +3,4 @@
  * `packages/nx/src/native/tasks/types.rs` and exposed to TypeScript via NAPI.
  * This file re-exports them so existing imports keep working.
  */
-export type { Task, TaskGraph, TaskTarget, TaskHashDetails, TaskUltracacheSettings, } from '../native';
+export type { Task, TaskGraph, TaskGraphEdge, TaskTarget, TaskHashDetails, TaskUltracacheSettings, } from '../native';

package/dist/src/config/workspace-json-project-json.d.ts

@@ -163,6 +163,64 @@ export type Spreadable<T> = T & {
  * permits `'...'`, which target merging resolves away.
  */
 export type TargetUltracacheSettings = Spreadable<TaskUltracacheSettings>;
+export interface ReadyWhenOptions {
+    /**
+     * Milliseconds to wait for readiness before failing dependents that wait
+     * for it. Default is 600000 (10 minutes).
+     */
+    timeout?: number;
+    /**
+     * Milliseconds between probe attempts. Default is 250. Unused by
+     * `logMatches` and `signal`.
+     */
+    interval?: number;
+}
+/**
+ * Readiness probe of a continuous target. Exactly one of `url`, `port`,
+ * `command`, `logMatches` or `signal` must be set. Strings may use the `{workspaceRoot}`,
+ * `{projectRoot}`, `{projectName}`, `{options.*}` and `{env.*}` placeholders,
+ * resolved against the options and environment the task runs with. A
+ * placeholder can list fallbacks, as in `{options.port ?? env.PORT ?? 4200}`.
+ */
+export type ReadyWhen = ({
+    /**
+     * Ready when an HTTP or HTTPS GET gets a status from 200 to 403. A
+     * redirect counts as ready and is not followed.
+     */
+    url: string;
+} & ReadyWhenOptions) | ({
+    /**
+     * Ready when a TCP connection to the port succeeds. A string can be a
+     * port number, `"auto"`, or a placeholder such as `{options.port}`.
+     * With `0` or `"auto"` the server picks its port, so Nx runs no check
+     * and the target counts as ready once it starts.
+     */
+    port: number | string;
+    /**
+     * Host to connect to. By default 127.0.0.1 and ::1 are both tried.
+     */
+    host?: string;
+} & ReadyWhenOptions) | ({
+    /**
+     * Ready when the command, run through the shell at the workspace root,
+     * exits with code 0. It runs with the env the task runs with, and the
+     * task's options as JSON in `NX_TASK_OPTIONS`.
+     */
+    command: string;
+} & ReadyWhenOptions) | ({
+    /**
+     * Ready when every one of these substrings has appeared in the task's
+     * output.
+     */
+    logMatches: string | string[];
+} & ReadyWhenOptions) | {
+    /**
+     * Ready when the task reports it with `emitReadySignal` from
+     * `@nx/devkit`.
+     */
+    signal: true;
+    timeout?: number;
+};
 export interface TargetDependencyConfig {
     /**
      * A list of projects that have `target`.
@@ -187,22 +245,45 @@ export interface TargetDependencyConfig {
      * Whether to forward task options to the dependency target.
      */
     options?: 'ignore' | 'forward';
+    /**
+     * Set to `false` to keep a continuous dependency's inputs out of this
+     * target's hash. It still runs first. Has no effect on other dependencies.
+     */
+    inputs?: boolean;
+    /**
+     * When the dependency is a continuous task, whether this target waits for
+     * it to have started (default) or to be ready per its `readyWhen`.
+     * Ignored when the dependency is not continuous or declares no `readyWhen`.
+     */
+    waitFor?: 'started' | 'ready';
 }
+/**
+ * `always`: the files the input resolves to stay in the hash even when the task
+ * is hashed from its ultracache recording.
+ * `dependencies` with `projects`: the selected projects' dependencies (as `^input`
+ * resolves for each), not the projects themselves.
+ */
 export type InputDefinition = {
     input: string;
     projects: string | string[];
+    dependencies?: boolean;
+    always?: boolean;
 } | {
     input: string;
     dependencies: true;
+    always?: boolean;
 } | {
     input: string;
+    always?: boolean;
 } | {
     fileset: string;
     includeIgnored?: boolean;
+    always?: boolean;
 } | {
     fileset: string;
     dependencies: true;
     includeIgnored?: boolean;
+    always?: boolean;
 } | {
     runtime: string;
 } | {
@@ -277,6 +358,13 @@ export interface TargetConfiguration<T = any> {
      * Whether this target runs continuously
      */
     continuous?: boolean;
+    /**
+     * How Nx detects that this continuous target is ready. Only honored when
+     * `continuous` is true; dependents opt in with `waitFor: 'ready'` on their
+     * `dependsOn` entry. `null` turns off a check inherited from a plugin or
+     * `targetDefaults`.
+     */
+    readyWhen?: ReadyWhen | null;
     /**
      * List of generators to run before the target to ensure the workspace
      * is up to date.