nx 23.3.0 → 24.0.0-beta.1

package/dist/src/utils/owned-private-dir.js

@@ -2,14 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectoryRefusedError = void 0;
 exports.describeRefusal = describeRefusal;
-exports.remedyFor = remedyFor;
 exports.canonicalDir = canonicalDir;
 exports.isSafeSharedRoot = isSafeSharedRoot;
-exports.isPeerWritable = isPeerWritable;
 exports.ensureSafeSharedRoot = ensureSafeSharedRoot;
 exports.isOwnedRealDirectory = isOwnedRealDirectory;
 exports.getUserSegment = getUserSegment;
 exports.ensureOwnedPrivateDir = ensureOwnedPrivateDir;
+/**
+ * Directory guards for Nx's runtime state: create a directory only when it is
+ * ours and unreachable by other users on this machine.
+ *
+ * `native/utils/owned_dir.rs` implements the same rules and must change with
+ * this file. This copy exists because the native binding loader has to place
+ * and lock down the `.node` before Rust can be called, and `cache-directory.ts`,
+ * `git-utils.ts` and `nx-tmp-dir.ts` share it. Node builtins only, for the
+ * loader's sake.
+ */
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
@@ -56,42 +64,6 @@ function describeRefusal(r) {
         }
     }
 }
-/** Single-quoted for a shell, so a path with a space or quote survives a paste. */
-const shellQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
-/** What the user can do about a refusal, or `undefined` when there is nothing. */
-function remedyFor(r) {
-    switch (r.kind) {
-        case 'not-a-directory':
-            return r.symlink
-                ? `${r.dir} is a symlink where Nx expects a directory. If you did not create it, treat it as hostile: remove the link itself (not what it points at) and run the command again.`
-                : undefined;
-        case 'foreign-owner':
-            return `${r.dir} belongs to another user on this machine, so Nx cannot keep its own directory there. Set NX_SOCKET_DIR to a short directory your user owns, or move it aside — which you can do yourself if you own the directory it sits in, and otherwise needs an administrator.`;
-        case 'not-tightenable':
-            // Both producers reach here having already established that the directory
-            // is ours, so `chmod` is the user's to run. Names no cause: one producer
-            // is a mount that discards the mode, the other is any `chmod` failure.
-            return `${r.dir} is reachable by other users (mode ${asMode(r.mode)}) and Nx could not restrict it. Run \`chmod 0700 ${shellQuote(r.dir)}\` and try again; if the mode does not stick, set NX_SOCKET_DIR to a short directory on a filesystem that keeps POSIX permissions.`;
-        case 'foreign-shared-container':
-            // Unreachable today: `isSafeSharedRoot` denies with this kind only when
-            // `stats.uid !== 0`, so a root-owned container never reaches here.
-            if (r.uid === 0) {
-                return undefined;
-            }
-            const q = shellQuote(r.dir);
-            return `${r.dir} belongs to another user on this machine, so Nx cannot keep a private directory beneath it. Ask an administrator to hand it to root with \`sudo chown root ${q} && sudo chmod 1777 ${q}\`; every user can then keep their own directory under it.`;
-        case 'not-created':
-        case 'not-inspectable':
-        case 'peer-writable-not-sticky':
-            return undefined;
-        default: {
-            // Matches `describeRefusal`'s arm, so a new kind cannot ship with a
-            // sentence and no advice — which is how `not-tightenable` went unadvised.
-            const unhandled = r;
-            return undefined;
-        }
-    }
-}
 /** One refusal as an `Error`, so several can travel in an `AggregateError`. */
 class DirectoryRefusedError extends Error {
     constructor(refusal) {
@@ -207,30 +179,6 @@ function isSafeSharedRoot(dir) {
         return deny({ kind: 'not-inspectable', dir, code: e?.code });
     }
 }
-/**
- * Whether other users on this machine can write into `dir`. Gates whether a
- * refusal message may cite other users, so it must not over-report: `false` on
- * Windows, where libuv synthesizes `st_mode` from the READONLY attribute and
- * reports an ordinary per-account directory as `0666`, and `false` on a path
- * that cannot be inspected.
- *
- * `statSync`, not `lstatSync`: the question is about the directory that will be
- * used, not the link pointing at it. Link modes mislead in both directions —
- * Linux creates symlinks `0777`, macOS applies the umask. Nothing here decides
- * whether a path is accepted, so following the link costs nothing the guards
- * do not already re-check.
- */
-function isPeerWritable(dir) {
-    if (process.platform === 'win32') {
-        return false;
-    }
-    try {
-        return !!((0, node_fs_1.statSync)(dir).mode & 0o022);
-    }
-    catch {
-        return false;
-    }
-}
 /**
  * Create a shared container as sticky + world-writable if it does not exist,
  * and report whether the resulting path is safe for the current user.

package/dist/src/utils/perf-hooks.d.ts

@@ -1,3 +1,4 @@
+// tsc doesn't emit hand-written .d.ts files; assets.json copies this one into dist.
 import type { EventParameters } from '../analytics/analytics';
 
 export interface TrackedDetail extends EventParameters {

package/dist/src/utils/plugins/core-plugins.js

@@ -80,7 +80,7 @@ exports.CORE_PLUGINS = [
     },
     {
         name: '@nx/remix',
-        capabilities: 'executors,generators',
+        capabilities: 'generators',
     },
     {
         name: '@nx/rollup',

package/dist/src/utils/spawn-without-terminal.d.ts

@@ -0,0 +1,27 @@
+import { type ChildProcess, type SpawnOptions } from 'child_process';
+/**
+ * Runs `command` in a shell that cannot reach the terminal nx shares with
+ * another program, so a prompt fails instead of waiting for keys that program
+ * reads. On POSIX the shell leads a new session with no controlling terminal,
+ * and loses every environment variable that names nx's terminal. Windows
+ * spawns it as usual, and with no stdio inherited it gets no console, so the
+ * terminal's Ctrl+C misses it there too. Whoever shares the terminal forwards
+ * signals with `signalCommandsWithoutTerminal`, and an nx that exits first
+ * kills each command whose output is still open.
+ */
+export declare function spawnWithoutTerminal(command: string, options: Omit<SpawnOptions, 'shell' | 'detached'>): ChildProcess;
+/**
+ * Sends `signal` to every command started by `spawnWithoutTerminal` whose
+ * output is still open: to its process group on POSIX, and on a SIGKILL also to
+ * the processes still descending from its shell, since a parent killed outright
+ * cannot stop the ones it started in groups of their own. Windows has no
+ * process groups, so there those descendants are terminated, whatever the
+ * signal.
+ */
+export declare function signalCommandsWithoutTerminal(signal: NodeJS.Signals): void;
+/**
+ * `env` without the variables whose value is the path of one of `terminals`
+ * (device ids). A process outside the new session, such as gpg-agent reading
+ * `GPG_TTY`, would otherwise open that terminal itself.
+ */
+export declare function withoutTerminalPaths(env: NodeJS.ProcessEnv, terminals: ReadonlySet<number>): NodeJS.ProcessEnv;

package/dist/src/utils/spawn-without-terminal.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnWithoutTerminal = spawnWithoutTerminal;
+exports.signalCommandsWithoutTerminal = signalCommandsWithoutTerminal;
+exports.withoutTerminalPaths = withoutTerminalPaths;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const tty_1 = require("tty");
+// The commands spawned below whose output is still open, by pid. On POSIX each
+// one leads its own process group.
+const commands = new Map();
+/**
+ * Runs `command` in a shell that cannot reach the terminal nx shares with
+ * another program, so a prompt fails instead of waiting for keys that program
+ * reads. On POSIX the shell leads a new session with no controlling terminal,
+ * and loses every environment variable that names nx's terminal. Windows
+ * spawns it as usual, and with no stdio inherited it gets no console, so the
+ * terminal's Ctrl+C misses it there too. Whoever shares the terminal forwards
+ * signals with `signalCommandsWithoutTerminal`, and an nx that exits first
+ * kills each command whose output is still open.
+ */
+function spawnWithoutTerminal(command, options) {
+    const child = (0, child_process_1.spawn)(command, {
+        ...options,
+        shell: true,
+        windowsHide: true,
+        detached: process.platform !== 'win32',
+        ...(process.platform !== 'win32' && {
+            env: withoutTerminalPaths(options.env ?? process.env, stdioTerminals()),
+        }),
+    });
+    const pid = child.pid;
+    if (pid !== undefined) {
+        if (commands.size === 0)
+            process.on('exit', killCommands);
+        commands.set(pid, child);
+        child.once('close', () => {
+            commands.delete(pid);
+            if (commands.size === 0)
+                process.removeListener('exit', killCommands);
+        });
+    }
+    return child;
+}
+/**
+ * Sends `signal` to every command started by `spawnWithoutTerminal` whose
+ * output is still open: to its process group on POSIX, and on a SIGKILL also to
+ * the processes still descending from its shell, since a parent killed outright
+ * cannot stop the ones it started in groups of their own. Windows has no
+ * process groups, so there those descendants are terminated, whatever the
+ * signal.
+ */
+function signalCommandsWithoutTerminal(signal) {
+    for (const [pid, child] of commands) {
+        // Tree first: killing the group reparents its members' children.
+        if (process.platform === 'win32' || signal === 'SIGKILL') {
+            killTree(child, pid, signal);
+        }
+        if (process.platform !== 'win32') {
+            try {
+                process.kill(-pid, signal);
+            }
+            catch {
+                // The command already ended; its `close` is on the way.
+            }
+        }
+    }
+}
+// Only while the shell lives: once it has exited, its pid can be reused.
+function killTree(child, pid, signal) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    try {
+        const { killProcessTree } = require('../native');
+        killProcessTree(pid, signal);
+    }
+    catch {
+        // No native killer in this build; on POSIX the group signal still goes out.
+    }
+}
+function killCommands() {
+    signalCommandsWithoutTerminal('SIGKILL');
+}
+function stdioTerminals() {
+    const devices = new Set();
+    for (const fd of [0, 1, 2]) {
+        if ((0, tty_1.isatty)(fd))
+            devices.add((0, fs_1.fstatSync)(fd).rdev);
+    }
+    return devices;
+}
+/**
+ * `env` without the variables whose value is the path of one of `terminals`
+ * (device ids). A process outside the new session, such as gpg-agent reading
+ * `GPG_TTY`, would otherwise open that terminal itself.
+ */
+function withoutTerminalPaths(env, terminals) {
+    return Object.fromEntries(Object.entries(env).filter(([, value]) => !namesTerminal(value, terminals)));
+}
+function namesTerminal(value, terminals) {
+    if (!value?.startsWith('/dev/'))
+        return false;
+    try {
+        const stat = (0, fs_1.statSync)(value);
+        return stat.isCharacterDevice() && terminals.has(stat.rdev);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/utils/string-similarity.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Computes the Levenshtein edit distance between two strings, i.e. the minimum
+ * number of single-character insertions, deletions, or substitutions required
+ * to turn `a` into `b`.
+ */
+export declare function levenshteinDistance(a: string, b: string): number;
+/**
+ * Ranks every candidate by how closely it resembles `input`, from closest to
+ * furthest, tie-broken alphabetically so the order is deterministic. Each entry
+ * keeps its computed distance so callers can reuse it (e.g. to both pick the
+ * closest match and order a list) without recomputing.
+ */
+export declare function rankByDistance(input: string, candidates: readonly string[]): {
+    candidate: string;
+    distance: number;
+}[];
+/**
+ * Whether a candidate at edit `distance` from `input` is close enough to be a
+ * useful suggestion. Exposed so callers that already have a distance (e.g. from
+ * `rankByDistance`) can gate on it without recomputing.
+ */
+export declare function isWithinSuggestionThreshold(input: string, candidate: string, distance: number): boolean;
+/**
+ * Ranks the candidates that are similar enough to `input` to be worth
+ * suggesting, closest first (ties broken alphabetically). Each entry keeps its
+ * distance so callers can compare suggestions found for different forms of the
+ * same input without recomputing.
+ */
+export declare function rankSuggestions(input: string, candidates: readonly string[]): {
+    candidate: string;
+    distance: number;
+}[];
+/**
+ * Returns up to `limit` candidates that most closely resemble `input`, sorted
+ * from closest to furthest. Candidates that are not similar enough to be a
+ * useful suggestion are excluded.
+ */
+export declare function findClosestMatches(input: string, candidates: readonly string[], limit?: number): string[];

package/dist/src/utils/string-similarity.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.levenshteinDistance = levenshteinDistance;
+exports.rankByDistance = rankByDistance;
+exports.isWithinSuggestionThreshold = isWithinSuggestionThreshold;
+exports.rankSuggestions = rankSuggestions;
+exports.findClosestMatches = findClosestMatches;
+/**
+ * Computes the Levenshtein edit distance between two strings, i.e. the minimum
+ * number of single-character insertions, deletions, or substitutions required
+ * to turn `a` into `b`.
+ */
+function levenshteinDistance(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    if (a.length === 0) {
+        return b.length;
+    }
+    if (b.length === 0) {
+        return a.length;
+    }
+    let previousRow = Array.from({ length: b.length + 1 }, (_, i) => i);
+    let currentRow = new Array(b.length + 1);
+    for (let i = 0; i < a.length; i++) {
+        currentRow[0] = i + 1;
+        for (let j = 0; j < b.length; j++) {
+            const cost = a[i] === b[j] ? 0 : 1;
+            currentRow[j + 1] = Math.min(currentRow[j] + 1, // insertion
+            previousRow[j + 1] + 1, // deletion
+            previousRow[j] + cost // substitution
+            );
+        }
+        [previousRow, currentRow] = [currentRow, previousRow];
+    }
+    return previousRow[b.length];
+}
+/**
+ * Ranks every candidate by how closely it resembles `input`, from closest to
+ * furthest, tie-broken alphabetically so the order is deterministic. Each entry
+ * keeps its computed distance so callers can reuse it (e.g. to both pick the
+ * closest match and order a list) without recomputing.
+ */
+function rankByDistance(input, candidates) {
+    return candidates
+        .map((candidate) => ({
+        candidate,
+        distance: levenshteinDistance(input, candidate),
+    }))
+        .sort((a, b) => a.distance - b.distance || a.candidate.localeCompare(b.candidate));
+}
+/**
+ * The number of edits tolerated before `candidate` stops being a useful
+ * suggestion for `input`.
+ *
+ * The tolerance scales with length so longer words allow for more typos, but it
+ * scales with the length of the part that actually *differs* — the shared
+ * prefix and suffix are stripped first. Scaling on the raw length lets text the
+ * user typed correctly buy a bigger budget for the part they got wrong, which
+ * matters because these inputs are joined `project:target[:configuration]`
+ * specifiers: `zzz:build` and `api:build` are 3 edits apart, but the shared
+ * `:build` inflates the raw-length budget to 4 and a project name with no
+ * character in common gets suggested.
+ *
+ * Stripping a common prefix and suffix does not change the Levenshtein
+ * distance, so a caller's precomputed `distance` remains directly comparable.
+ */
+function suggestionThreshold(input, candidate) {
+    const shortest = Math.min(input.length, candidate.length);
+    let prefix = 0;
+    while (prefix < shortest && input[prefix] === candidate[prefix]) {
+        prefix++;
+    }
+    let suffix = 0;
+    while (suffix < shortest - prefix &&
+        input[input.length - 1 - suffix] ===
+            candidate[candidate.length - 1 - suffix]) {
+        suffix++;
+    }
+    return Math.max(2, Math.ceil((input.length - prefix - suffix) * 0.4));
+}
+/**
+ * Whether a candidate at edit `distance` from `input` is close enough to be a
+ * useful suggestion. Exposed so callers that already have a distance (e.g. from
+ * `rankByDistance`) can gate on it without recomputing.
+ */
+function isWithinSuggestionThreshold(input, candidate, distance) {
+    return distance <= suggestionThreshold(input, candidate);
+}
+/**
+ * Ranks the candidates that are similar enough to `input` to be worth
+ * suggesting, closest first (ties broken alphabetically). Each entry keeps its
+ * distance so callers can compare suggestions found for different forms of the
+ * same input without recomputing.
+ */
+function rankSuggestions(input, candidates) {
+    return rankByDistance(input, candidates).filter(({ candidate, distance }) => isWithinSuggestionThreshold(input, candidate, distance));
+}
+/**
+ * Returns up to `limit` candidates that most closely resemble `input`, sorted
+ * from closest to furthest. Candidates that are not similar enough to be a
+ * useful suggestion are excluded.
+ */
+function findClosestMatches(input, candidates, limit = 3) {
+    return rankSuggestions(input, candidates)
+        .slice(0, limit)
+        .map(({ candidate }) => candidate);
+}

package/migrations.json

@@ -190,6 +190,13 @@
       "description": "Sets \"cache\" on some executor-based target defaults whose caching was previously enabled by a target name default, maintaining compatibility with how cacheability resolved before Nx 23. Keys the migration cannot decide are left alone and keep working through a deprecated runtime fallback.",
       "implementation": "./dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults",
       "documentation": "./dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults.md"
+    },
+    "24-0-0-move-custom-hashers-to-inputs": {
+      "version": "24.0.0-beta.0",
+      "description": "Finds local executors that declare a custom hasher, which is deprecated and will be removed in Nx 25. Rewriting a hasher as target inputs means reading what its code hashes, so the rewrite is driven by an AI prompt; the generator only reports each hasher.",
+      "implementation": "./dist/src/migrations/update-24-0-0/find-custom-hashers",
+      "prompt": "./dist/src/migrations/update-24-0-0/move-custom-hashers-to-inputs.md",
+      "documentation": "./dist/src/migrations/update-24-0-0/find-custom-hashers.md"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "23.3.0",
+  "version": "24.0.0-beta.1",
   "private": false,
   "type": "commonjs",
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
@@ -66,7 +66,6 @@
     "bl": "4.1.0",
     "brace-expansion": "5.0.12",
     "buffer": "5.7.1",
-    "bundle-name": "4.1.0",
     "chalk": "4.1.2",
     "cli-cursor": "3.1.0",
     "cli-spinners": "2.6.1",
@@ -74,10 +73,7 @@
     "clone": "1.0.4",
     "color-convert": "2.0.1",
     "color-name": "1.1.4",
-    "default-browser": "5.2.1",
-    "default-browser-id": "5.0.0",
     "defaults": "1.0.4",
-    "define-lazy-prop": "3.0.0",
     "dotenv": "16.4.7",
     "dotenv-expand": "12.0.3",
     "ejs": "5.0.1",
@@ -95,12 +91,9 @@
     "ieee754": "1.2.1",
     "ignore": "7.0.6",
     "inherits": "2.0.4",
-    "is-docker": "3.0.0",
     "is-fullwidth-code-point": "3.0.0",
-    "is-inside-container": "1.0.0",
     "is-interactive": "1.0.0",
     "is-unicode-supported": "0.1.0",
-    "is-wsl": "3.1.0",
     "isexe": "2.0.0",
     "json5": "2.2.3",
     "jsonc-parser": "3.3.1",
@@ -112,7 +105,6 @@
     "npm-run-path": "4.0.1",
     "once": "1.4.0",
     "onetime": "5.1.2",
-    "open": "10.1.0",
     "ora": "5.4.1",
     "path-key": "3.1.1",
     "picocolors": "1.1.1",
@@ -120,7 +112,6 @@
     "require-directory": "2.1.1",
     "resolve.exports": "2.0.3",
     "restore-cursor": "3.1.0",
-    "run-applescript": "7.0.0",
     "safe-buffer": "5.2.1",
     "semver": "7.8.5",
     "signal-exit": "3.0.7",
@@ -159,16 +150,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "23.3.0",
-    "@nx/nx-darwin-x64": "23.3.0",
-    "@nx/nx-freebsd-x64": "23.3.0",
-    "@nx/nx-linux-arm-gnueabihf": "23.3.0",
-    "@nx/nx-linux-arm64-gnu": "23.3.0",
-    "@nx/nx-linux-arm64-musl": "23.3.0",
-    "@nx/nx-linux-x64-gnu": "23.3.0",
-    "@nx/nx-linux-x64-musl": "23.3.0",
-    "@nx/nx-win32-arm64-msvc": "23.3.0",
-    "@nx/nx-win32-x64-msvc": "23.3.0"
+    "@nx/nx-darwin-arm64": "24.0.0-beta.1",
+    "@nx/nx-darwin-x64": "24.0.0-beta.1",
+    "@nx/nx-freebsd-x64": "24.0.0-beta.1",
+    "@nx/nx-linux-arm-gnueabihf": "24.0.0-beta.1",
+    "@nx/nx-linux-arm64-gnu": "24.0.0-beta.1",
+    "@nx/nx-linux-arm64-musl": "24.0.0-beta.1",
+    "@nx/nx-linux-x64-gnu": "24.0.0-beta.1",
+    "@nx/nx-linux-x64-musl": "24.0.0-beta.1",
+    "@nx/nx-win32-arm64-msvc": "24.0.0-beta.1",
+    "@nx/nx-win32-x64-msvc": "24.0.0-beta.1"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/readme-template.md

@@ -1,7 +1,7 @@
-<p style="text-align: center;">
+<p align="center">
   <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
-    <img alt="Nx - Smart Repos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-logo-light.svg">
+    <img alt="Nx Logo" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-logo.svg" width="140">
   </picture>
 </p>
 

package/schemas/nx-schema.json

@@ -615,6 +615,59 @@
     }
   },
   "definitions": {
+    "readyWhen": {
+      "description": "How Nx detects that this continuous target is ready. Dependents opt in with \"waitFor\": \"ready\" on their dependsOn entry. Strings may use the {workspaceRoot}, {projectRoot}, {projectName} and {options.*} placeholders, resolved against the options the task runs with.",
+      "type": "object",
+      "properties": {
+        "url": {
+          "type": "string",
+          "description": "Ready when an HTTP or HTTPS GET gets a status from 200 to 403. A redirect counts as ready and is not followed"
+        },
+        "port": {
+          "type": ["integer", "string"],
+          "minimum": 1,
+          "maximum": 65535,
+          "description": "Ready when a TCP connection to this port succeeds. A string must resolve to a port number through a placeholder such as {options.port}"
+        },
+        "host": {
+          "type": "string",
+          "description": "Host to connect to with port. By default 127.0.0.1 and ::1 are both tried"
+        },
+        "command": {
+          "type": "string",
+          "description": "Ready when this command, run through the shell at the workspace root, exits with code 0"
+        },
+        "logMatches": {
+          "description": "Ready when every one of these substrings has appeared in the task's output",
+          "oneOf": [
+            { "type": "string" },
+            {
+              "type": "array",
+              "items": { "type": "string" },
+              "minItems": 1
+            }
+          ]
+        },
+        "timeout": {
+          "type": "integer",
+          "minimum": 1,
+          "default": 60000,
+          "description": "Milliseconds to wait for readiness before failing dependents that wait for it"
+        },
+        "interval": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Milliseconds between probe attempts. By default attempts back off from 100 to 1000 milliseconds. Unused by logMatches"
+        }
+      },
+      "oneOf": [
+        { "required": ["url"] },
+        { "required": ["port"] },
+        { "required": ["command"] },
+        { "required": ["logMatches"] }
+      ],
+      "additionalProperties": false
+    },
     "ownersPattern": {
       "type": "object",
       "properties": {
@@ -912,6 +965,9 @@
         "continuous": {
           "$ref": "#/definitions/targetDefaultsConfig/properties/continuous"
         },
+        "readyWhen": {
+          "$ref": "#/definitions/targetDefaultsConfig/properties/readyWhen"
+        },
         "parallelism": {
           "$ref": "#/definitions/targetDefaultsConfig/properties/parallelism"
         },
@@ -975,6 +1031,9 @@
           "default": false,
           "description": "Whether this target runs continuously until stopped"
         },
+        "readyWhen": {
+          "$ref": "#/definitions/readyWhen"
+        },
         "parallelism": {
           "type": "boolean",
           "default": true,
@@ -1021,6 +1080,17 @@
                     "description": "Configuration for params handling.",
                     "enum": ["ignore", "forward"],
                     "default": "ignore"
+                  },
+                  "inputs": {
+                    "type": "boolean",
+                    "description": "Set to false to keep a continuous dependency's inputs out of this target's hash and affected calculation. Has no effect on dependencies that are not continuous.",
+                    "default": true
+                  },
+                  "waitFor": {
+                    "type": "string",
+                    "description": "For a continuous dependency, whether to wait until it has started or until it is ready per its readyWhen. Ignored when the dependency is not continuous or has no readyWhen.",
+                    "enum": ["started", "ready"],
+                    "default": "started"
                   }
                 },
                 "oneOf": [