@depup/nx 23.1.2-depup.1 → 23.2.0-depup.0

package/dist/src/utils/chunkify.js

@@ -3,22 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.chunkify = chunkify;
 exports.getMaxArgLength = getMaxArgLength;
 const TERMINAL_SIZE = getMaxArgLength();
-function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500) {
+function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500, 
+/**
+ * How long each entry will be once it reaches the command line. Callers that
+ * quote or escape afterwards pass that transformation's length here, so the
+ * chunk is sized against what is actually spawned rather than the raw string.
+ */
+measure = (item) => item.length) {
     const chunks = [];
     let currentChunk = [];
     let currentChunkLength = 0;
     for (const file of target) {
+        const length = measure(file);
         if (
         // Prevent empty chunk if first file path is longer than maxChunkLength
         currentChunk.length &&
             // +1 accounts for the space between file names
-            currentChunkLength + file.length + 1 >= maxChunkLength) {
+            currentChunkLength + length + 1 >= maxChunkLength) {
             chunks.push(currentChunk);
             currentChunk = [];
             currentChunkLength = 0;
         }
         currentChunk.push(file);
-        currentChunkLength += file.length + 1;
+        currentChunkLength += length + 1;
     }
     chunks.push(currentChunk);
     return chunks;

package/dist/src/utils/consume-messages-from-socket.d.ts

@@ -1,9 +1,44 @@
-export declare const MESSAGE_END_SEQ: string;
-export declare function consumeMessagesFromSocket(callback: (message: string) => void): (data: any) => void;
-export declare function isJsonMessage(message: string): boolean;
+import type { Socket } from 'net';
+export declare const MESSAGE_HEADER_PREFIX = "NX_MSG_";
 /**
- * Parse a message that was produced by `serialize()` in
- * `daemon/socket-utils.ts`. Auto-detects JSON vs. v8-serialized payloads using
- * `isJsonMessage()` and decodes the binary path via `v8.deserialize`.
+ * Ceiling on a single message, in bytes. Payloads are buffered outside the V8
+ * heap, so `--max-old-space-size` does not bound them and a peer that declares
+ * a huge length would otherwise be allowed to stream until the machine gives
+ * out. The default is four times the ~0.5GiB string ceiling that used to cap
+ * every message, so it clears any payload that previously worked or was meant
+ * to. Set `NX_MAX_MESSAGE_SIZE` to another byte count to change it, or to 0 to
+ * remove the ceiling. The daemon reads it from the env it was spawned with —
+ * clients do not reflect it (see DAEMON_ENV_VARS_EXCLUSIONS) — so changing it
+ * needs a daemon restart (`nx reset`).
  */
-export declare function parseMessage<T = unknown>(message: string): T;
+export declare const DEFAULT_MAX_MESSAGE_SIZE: number;
+export declare function getMaxMessageSize(): number;
+export declare function frameHeader(payloadLength: number): Buffer;
+/**
+ * Writes a length-prefixed message. The header and payload are written
+ * separately so a large payload is never copied to prepend its header.
+ */
+export declare function writeMessage(socket: Socket, payload: Buffer, callback?: (err?: Error) => void): void;
+export declare class MessageFramingError extends Error {
+    constructor(message: string);
+}
+export declare function consumeMessagesFromSocket(callback: (message: Buffer) => void, onError?: (error: MessageFramingError) => void): (data: Buffer) => void;
+/**
+ * v8-serialized payloads always begin with the 0xFF version header, which no
+ * JSON document can start with.
+ */
+export declare function isJsonMessage(message: Buffer): boolean;
+/**
+ * Render part of a message for an error message. A v8 payload is binary rather
+ * than utf8 text — its 0xFF header alone can never decode — so it is rendered
+ * as hex instead of as U+FFFD-riddled mojibake.
+ */
+export declare function describeMessage(message: Buffer, { maxBytes, from }?: DescribeMessageOptions): string;
+export interface DescribeMessageOptions {
+    maxBytes?: number;
+    from?: 'start' | 'end';
+}
+/**
+ * Parse a message produced by `serialize()` in `daemon/socket-utils.ts`.
+ */
+export declare function parseMessage<T = unknown>(message: Buffer): T;

package/dist/src/utils/consume-messages-from-socket.js

@@ -1,56 +1,291 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MESSAGE_END_SEQ = void 0;
+exports.MessageFramingError = exports.DEFAULT_MAX_MESSAGE_SIZE = exports.MESSAGE_HEADER_PREFIX = void 0;
+exports.getMaxMessageSize = getMaxMessageSize;
+exports.frameHeader = frameHeader;
+exports.writeMessage = writeMessage;
 exports.consumeMessagesFromSocket = consumeMessagesFromSocket;
 exports.isJsonMessage = isJsonMessage;
+exports.describeMessage = describeMessage;
 exports.parseMessage = parseMessage;
-const string_decoder_1 = require("string_decoder");
 const v8_1 = require("v8");
-const VERY_END_CODE = 4;
-exports.MESSAGE_END_SEQ = 'NX_MSG_END' + String.fromCharCode(VERY_END_CODE);
-function consumeMessagesFromSocket(callback) {
-    let message = '';
-    const decoder = new string_decoder_1.StringDecoder('utf8');
-    return (data) => {
-        const chunk = decoder.write(data);
-        message += chunk;
-        // Check if accumulated message ends with MESSAGE_END_SEQ (not just the chunk)
-        // This handles TCP packet fragmentation where MESSAGE_END_SEQ may be split across packets
-        if (chunk.codePointAt(chunk.length - 1) === VERY_END_CODE &&
-            message.endsWith(exports.MESSAGE_END_SEQ)) {
-            // Remove the trailing MESSAGE_END_SEQ
-            const fullMessage = message.substring(0, message.length - exports.MESSAGE_END_SEQ.length);
-            // Server may send multiple messages in one chunk, so splitting by MESSAGE_END_SEQ
-            const messages = fullMessage.split(exports.MESSAGE_END_SEQ);
-            for (const splitMessage of messages) {
-                if (splitMessage) {
-                    callback(splitMessage);
+exports.MESSAGE_HEADER_PREFIX = 'NX_MSG_';
+const MESSAGE_HEADER_TERMINATOR = ':'.charCodeAt(0);
+const MESSAGE_HEADER_PREFIX_BYTES = Buffer.from(exports.MESSAGE_HEADER_PREFIX, 'ascii');
+// `Number.MAX_SAFE_INTEGER` is 16 digits, so a longer run of digits than that
+// is a desynchronized stream rather than a very large message.
+const MAX_HEADER_LENGTH = exports.MESSAGE_HEADER_PREFIX.length + 16 + 1;
+/**
+ * Ceiling on a single message, in bytes. Payloads are buffered outside the V8
+ * heap, so `--max-old-space-size` does not bound them and a peer that declares
+ * a huge length would otherwise be allowed to stream until the machine gives
+ * out. The default is four times the ~0.5GiB string ceiling that used to cap
+ * every message, so it clears any payload that previously worked or was meant
+ * to. Set `NX_MAX_MESSAGE_SIZE` to another byte count to change it, or to 0 to
+ * remove the ceiling. The daemon reads it from the env it was spawned with —
+ * clients do not reflect it (see DAEMON_ENV_VARS_EXCLUSIONS) — so changing it
+ * needs a daemon restart (`nx reset`).
+ */
+exports.DEFAULT_MAX_MESSAGE_SIZE = 2 * 1024 * 1024 * 1024;
+function getMaxMessageSize() {
+    const configured = process.env.NX_MAX_MESSAGE_SIZE;
+    if (configured === undefined || configured === '') {
+        return exports.DEFAULT_MAX_MESSAGE_SIZE;
+    }
+    const parsed = Number(configured);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        console.warn(`NX_MAX_MESSAGE_SIZE must be a non-negative number of bytes, but was "${configured}". Using the default of ${exports.DEFAULT_MAX_MESSAGE_SIZE}.`);
+        return exports.DEFAULT_MAX_MESSAGE_SIZE;
+    }
+    return parsed;
+}
+/**
+ * `nx reset` only helps while a daemon is enabled: it and its plugin workers keep the
+ * limit they were spawned with, and the var is excluded from the daemon env hash so
+ * changing it restarts nothing. Every other reader re-reads the env per invocation.
+ * Required lazily because the daemon client imports this module.
+ */
+function daemonHoldsItsOwnLimit() {
+    try {
+        return require('../daemon/client/client').daemonClient.enabled();
+    }
+    catch {
+        return true;
+    }
+}
+const ZERO = '0'.charCodeAt(0);
+const NINE = '9'.charCodeAt(0);
+function frameHeader(payloadLength) {
+    return Buffer.from(`${exports.MESSAGE_HEADER_PREFIX}${payloadLength}:`, 'ascii');
+}
+/**
+ * Writes a length-prefixed message. The header and payload are written
+ * separately so a large payload is never copied to prepend its header.
+ */
+function writeMessage(socket, payload, callback) {
+    socket.write(frameHeader(payload.length));
+    socket.write(payload, callback);
+}
+class MessageFramingError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MessageFramingError';
+        Object.setPrototypeOf(this, MessageFramingError.prototype);
+    }
+}
+exports.MessageFramingError = MessageFramingError;
+function consumeMessagesFromSocket(callback, onError = (error) => {
+    console.error(error.message);
+}) {
+    let chunks = [];
+    let buffered = 0;
+    let expectedPayloadLength = null;
+    let broken = false;
+    // Read once per socket so a test or a caller can change it between
+    // connections without paying the lookup on every frame.
+    const maxMessageSize = getMaxMessageSize();
+    const fail = (message) => {
+        broken = true;
+        chunks = [];
+        buffered = 0;
+        expectedPayloadLength = null;
+        onError(new MessageFramingError(message));
+    };
+    // Copies at most `length` leading bytes without collapsing the chunk list.
+    const peek = (length) => {
+        const size = Math.min(length, buffered);
+        if (chunks.length === 1) {
+            return chunks[0].subarray(0, size);
+        }
+        const out = Buffer.allocUnsafe(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+            if (offset >= size)
+                break;
+            offset += chunk.copy(out, offset, 0, Math.min(chunk.length, size - offset));
+        }
+        return out;
+    };
+    const take = (length) => {
+        if (length === 0) {
+            return Buffer.alloc(0);
+        }
+        // A socket chunk usually carries several whole messages, so slice the
+        // leading one out in place rather than allocating and copying for each.
+        // The payload is parsed by the callback before the next read, so sharing
+        // the chunk's memory does not retain it.
+        if (chunks[0].length === length) {
+            buffered -= length;
+            return chunks.shift();
+        }
+        if (chunks[0].length > length) {
+            const out = chunks[0].subarray(0, length);
+            chunks[0] = chunks[0].subarray(length);
+            buffered -= length;
+            return out;
+        }
+        const out = Buffer.allocUnsafe(length);
+        let offset = 0;
+        while (offset < length) {
+            const chunk = chunks[0];
+            const needed = length - offset;
+            if (chunk.length <= needed) {
+                chunk.copy(out, offset);
+                offset += chunk.length;
+                chunks.shift();
+            }
+            else {
+                chunk.copy(out, offset, 0, needed);
+                chunks[0] = chunk.subarray(needed);
+                offset = length;
+            }
+        }
+        buffered -= length;
+        return out;
+    };
+    const discard = (length) => {
+        let remaining = length;
+        while (remaining > 0) {
+            const chunk = chunks[0];
+            if (chunk.length <= remaining) {
+                remaining -= chunk.length;
+                chunks.shift();
+            }
+            else {
+                chunks[0] = chunk.subarray(remaining);
+                remaining = 0;
+            }
+        }
+        buffered -= length;
+    };
+    // Returns the payload length, or null when the header is still incomplete.
+    const readHeader = () => {
+        const head = peek(MAX_HEADER_LENGTH);
+        for (let i = 0; i < MESSAGE_HEADER_PREFIX_BYTES.length; i++) {
+            if (i >= head.length)
+                return null;
+            if (head[i] !== MESSAGE_HEADER_PREFIX_BYTES[i]) {
+                fail(`Expected a message to begin with '${exports.MESSAGE_HEADER_PREFIX}' but received ` +
+                    `${JSON.stringify(head.toString('utf8', 0, 32))}. The stream is out of sync.`);
+                return null;
+            }
+        }
+        let digits = 0;
+        let value = 0;
+        for (let i = MESSAGE_HEADER_PREFIX_BYTES.length; i < head.length; i++) {
+            const byte = head[i];
+            if (byte === MESSAGE_HEADER_TERMINATOR) {
+                if (digits === 0) {
+                    fail(`Message header carried no length.`);
+                    return null;
+                }
+                if (maxMessageSize > 0 && value > maxMessageSize) {
+                    fail(`Message of ${value} bytes exceeds the ${maxMessageSize} byte limit. ` +
+                        `Set NX_MAX_MESSAGE_SIZE to raise it, or to 0 to remove it.` +
+                        (daemonHoldsItsOwnLimit()
+                            ? ` Then run \`nx reset\`, since a running daemon and the plugin workers it spawns keep the limit they started with.`
+                            : ''));
+                    return null;
                 }
+                discard(i + 1);
+                return value;
             }
-            message = '';
+            if (byte < ZERO || byte > NINE) {
+                fail(`Message header contained a non-digit length. The stream is out of sync.`);
+                return null;
+            }
+            value = value * 10 + (byte - ZERO);
+            digits++;
+        }
+        if (head.length >= MAX_HEADER_LENGTH) {
+            fail(`Message header exceeded ${MAX_HEADER_LENGTH} bytes without a ':'.`);
+        }
+        return null;
+    };
+    return (data) => {
+        if (broken) {
+            return;
+        }
+        chunks.push(data);
+        buffered += data.length;
+        while (!broken) {
+            if (expectedPayloadLength === null) {
+                const length = readHeader();
+                if (length === null)
+                    break;
+                expectedPayloadLength = length;
+            }
+            if (expectedPayloadLength === 0) {
+                fail('Message header declared a zero-length payload.');
+                break;
+            }
+            if (buffered < expectedPayloadLength)
+                break;
+            const payload = take(expectedPayloadLength);
+            expectedPayloadLength = null;
+            callback(payload);
         }
-        // If message doesn't end with MESSAGE_END_SEQ, keep accumulating chunks
     };
 }
+/**
+ * v8-serialized payloads always begin with the 0xFF version header, which no
+ * JSON document can start with.
+ */
 function isJsonMessage(message) {
-    return (
-    // json objects
-    ['[', '{'].some((prefix) => message.startsWith(prefix)) ||
-        // booleans
-        message === 'true' ||
-        message === 'false' ||
-        // strings
-        (message.startsWith('"') && message.endsWith('"')) ||
-        // numbers
-        /^[0-9]+(\.?[0-9]+)?$/.test(message));
+    return message.length === 0 || message[0] !== 0xff;
+}
+/**
+ * Widest slice of `window` that holds only whole utf8 characters. Cutting at an
+ * arbitrary byte leaves a partial sequence, and a partial sequence decodes to
+ * U+FFFD, which is the corruption `describeMessage` exists to avoid. A slice
+ * taken from the end can also begin mid-character, so both edges are trimmed.
+ */
+function trimToCharBoundary(window, from) {
+    const isContinuation = (byte) => (byte & 0xc0) === 0x80;
+    if (from === 'end') {
+        let offset = 0;
+        while (offset < window.length && isContinuation(window[offset])) {
+            offset++;
+        }
+        return window.subarray(offset);
+    }
+    let lead = window.length - 1;
+    while (lead >= 0 && isContinuation(window[lead])) {
+        lead--;
+    }
+    if (lead < 0) {
+        return window.subarray(0, 0);
+    }
+    const byte = window[lead];
+    const width = byte >= 0xf0 ? 4 : byte >= 0xe0 ? 3 : byte >= 0xc0 ? 2 : 1;
+    // Keep the trailing sequence only when the cut did not land inside it.
+    return lead + width <= window.length ? window : window.subarray(0, lead);
+}
+/**
+ * Render part of a message for an error message. A v8 payload is binary rather
+ * than utf8 text — its 0xFF header alone can never decode — so it is rendered
+ * as hex instead of as U+FFFD-riddled mojibake.
+ */
+function describeMessage(message, { maxBytes = 300, from = 'start' } = {}) {
+    const json = isJsonMessage(message);
+    const window = from === 'end'
+        ? message.subarray(Math.max(0, message.length - maxBytes))
+        : message.subarray(0, maxBytes);
+    const slice = json ? trimToCharBoundary(window, from) : window;
+    const elided = message.length - slice.length;
+    return [
+        `${json ? 'json' : 'v8'}, ${message.length} bytes` +
+            (elided > 0
+                ? `, ${from === 'end' ? 'last' : 'first'} ${slice.length} shown`
+                : ''),
+        json ? slice.toString('utf8') : slice.toString('hex'),
+    ].join('\n');
 }
 /**
- * Parse a message that was produced by `serialize()` in
- * `daemon/socket-utils.ts`. Auto-detects JSON vs. v8-serialized payloads using
- * `isJsonMessage()` and decodes the binary path via `v8.deserialize`.
+ * Parse a message produced by `serialize()` in `daemon/socket-utils.ts`.
  */
 function parseMessage(message) {
     return isJsonMessage(message)
-        ? JSON.parse(message)
-        : (0, v8_1.deserialize)(Buffer.from(message, 'binary'));
+        ? JSON.parse(message.toString('utf8'))
+        : (0, v8_1.deserialize)(message);
 }

package/dist/src/utils/db-connection.js

@@ -7,25 +7,17 @@ const cache_directory_1 = require("./cache-directory");
 const workspace_root_1 = require("./workspace-root");
 const dbConnectionMap = new Map();
 /**
- * Shared workspace-data directory, resolved once per process.
- * In a git worktree this points to the main repo's workspace-data dir
- * so all worktrees share the same DB.
+ * Where the shared DB lives, resolved once per process.
+ *
+ * The DB is the only thing that uses the shared `workspace-data` directory --
+ * daemon logs and the `disabled` marker stay in the checkout's own, because
+ * they describe that checkout. Sharing is not decided here: this DB indexes the
+ * cache directory's contents, so the two have to land in the same scope or a
+ * cache hit resolves to artifacts that were never written here.
  */
 let _sharedDir;
 function sharedWorkspaceDataDirectory(root) {
-    if (_sharedDir)
-        return _sharedDir;
-    try {
-        const mainRoot = (0, native_1.getMainWorktreeRoot)(root);
-        if (mainRoot) {
-            _sharedDir = (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(mainRoot);
-            return _sharedDir;
-        }
-    }
-    catch {
-        // Fall back to local workspace data if worktree detection fails
-    }
-    _sharedDir = (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(root);
+    _sharedDir ??= (0, cache_directory_1.sharedDataDirectory)(root, 'workspace-data');
     return _sharedDir;
 }
 function getDbConnection(opts = {}) {

package/dist/src/utils/exit-codes.d.ts

@@ -13,3 +13,12 @@ export declare const EXPECTED_TERMINATION_SIGNALS: Set<number>;
  * Handles both Linux exact-match and macOS strsignal formats (e.g. "Terminated by Hangup: 1").
  */
 export declare function messageToCode(message: string): number;
+/**
+ * Ends the process the way an interrupted process ends: by SIGINT, not by
+ * exiting with its conventional code.
+ *
+ * A shell reports 130 either way, but a parent using waitpid sees
+ * `signal: 'SIGINT'` rather than `code: 130`, which is what tools wrapping nx
+ * check to tell "the user pressed Ctrl+C" from "the command failed".
+ */
+export declare function exitAsInterrupted(): never;

package/dist/src/utils/exit-codes.js

@@ -4,6 +4,7 @@ exports.EXPECTED_TERMINATION_SIGNALS = void 0;
 exports.signalToCode = signalToCode;
 exports.codeToSignal = codeToSignal;
 exports.messageToCode = messageToCode;
+exports.exitAsInterrupted = exitAsInterrupted;
 /**
  * Translates NodeJS signals to numeric exit code
  * @param signal
@@ -73,3 +74,21 @@ function messageToCode(message) {
         return 1;
     }
 }
+/**
+ * Ends the process the way an interrupted process ends: by SIGINT, not by
+ * exiting with its conventional code.
+ *
+ * A shell reports 130 either way, but a parent using waitpid sees
+ * `signal: 'SIGINT'` rather than `code: 130`, which is what tools wrapping nx
+ * check to tell "the user pressed Ctrl+C" from "the command failed".
+ */
+function exitAsInterrupted() {
+    // Windows has no signal disposition to inherit - `process.kill` there
+    // terminates with an arbitrary code - so keep the 128+SIGINT convention.
+    if (process.platform !== 'win32') {
+        // Any listener would swallow this; the default action is what terminates.
+        process.removeAllListeners('SIGINT');
+        process.kill(process.pid, 'SIGINT');
+    }
+    process.exit(130);
+}

package/dist/src/utils/formatters/index.d.ts

@@ -0,0 +1,13 @@
+import type { Tree } from '../../generators/tree';
+/**
+ * Adding a member here does NOT reliably break compilation: the repo builds
+ * with `strict: false`, so a `switch` that omits one is not an error. The
+ * `never` assertions and type-keyed tables that do catch it fail immediately
+ * inside `packages/nx`, but the ones in devkit and `@nx/js` read the type from
+ * its emitted declarations, so those only fail once it has been rebuilt.
+ */
+export type FormatterType = 'prettier' | 'oxfmt';
+/** Test-only: the warn-once flag is module state and would leak between cases. */
+export declare function resetFormatterWarningsForTesting(): void;
+export declare function detectFormatter(root: string): FormatterType | null;
+export declare function detectFormatterInTree(tree: Tree): FormatterType | null;

package/dist/src/utils/formatters/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetFormatterWarningsForTesting = resetFormatterWarningsForTesting;
+exports.detectFormatter = detectFormatter;
+exports.detectFormatterInTree = detectFormatterInTree;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const json_1 = require("../../generators/utils/json");
+const fileutils_1 = require("../fileutils");
+const oxfmt_1 = require("./oxfmt");
+const prettier_1 = require("./prettier");
+const logger_1 = require("../logger");
+// Once per process: detection runs on every one of 200+ `formatFiles` call sites.
+let warnedBothConfigured = false;
+function warnBothConfigured() {
+    warnedBothConfigured = true;
+    logger_1.logger.warn('Both an oxfmt and a prettier config were found. Nx is formatting with ' +
+        'oxfmt. Delete the config you are not using to make the choice ' +
+        'explicit: https://nx.dev/docs/reference/code-formatting');
+}
+/** Test-only: the warn-once flag is module state and would leak between cases. */
+function resetFormatterWarningsForTesting() {
+    warnedBothConfigured = false;
+}
+function detectFormatter(root) {
+    if ((0, oxfmt_1.isUsingOxfmt)(root)) {
+        // Flag first, so the lookup stops repeating once we have warned.
+        if (!warnedBothConfigured && (0, prettier_1.isUsingPrettier)(root)) {
+            warnBothConfigured();
+        }
+        return 'oxfmt';
+    }
+    if ((0, prettier_1.isUsingPrettier)(root)) {
+        return 'prettier';
+    }
+    // Neither is configured. Both formatters run on their defaults, so a
+    // dependency declared in the root package.json is the only statement of
+    // intent an unconfigured workspace gives. #30426 ruled out treating prettier
+    // as *resolvable in node_modules*, which a declared dependency is not.
+    const packageJsonPath = (0, node_path_1.join)(root, 'package.json');
+    if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+        return detectFormatterFromDependencies((0, fileutils_1.readJsonFile)(packageJsonPath));
+    }
+    return null;
+}
+function detectFormatterInTree(tree) {
+    if ((0, oxfmt_1.isUsingOxfmtInTree)(tree)) {
+        if (!warnedBothConfigured && (0, prettier_1.isUsingPrettierInTree)(tree)) {
+            warnBothConfigured();
+        }
+        return 'oxfmt';
+    }
+    if ((0, prettier_1.isUsingPrettierInTree)(tree)) {
+        return 'prettier';
+    }
+    // See detectFormatter: a declared dependency is the fallback for both.
+    if (tree.exists('package.json')) {
+        return detectFormatterFromDependencies((0, json_1.readJson)(tree, 'package.json'));
+    }
+    return null;
+}
+/** oxfmt first, matching the precedence the config files already have. */
+function detectFormatterFromDependencies(packageJson) {
+    if (hasDependency(packageJson, 'oxfmt')) {
+        return 'oxfmt';
+    }
+    if (hasDependency(packageJson, 'prettier')) {
+        return 'prettier';
+    }
+    return null;
+}
+function hasDependency(packageJson, name) {
+    return Boolean(packageJson.dependencies?.[name] ?? packageJson.devDependencies?.[name]);
+}

package/dist/src/utils/formatters/oxfmt.d.ts

@@ -0,0 +1,32 @@
+import type { Tree } from '../../generators/tree';
+/**
+ * Config filenames oxfmt *discovers* - narrower than the set `-c` accepts.
+ * Measured against 0.60.0: `oxfmt.config.{js,cjs,mjs,cts}` load when named
+ * but are never searched for, so treating one as config would format on
+ * options oxfmt ignores. No precedence order - oxfmt fails with
+ * "Both '<a>' and '<b>' found in <dir>" when a directory holds two.
+ */
+export declare const oxfmtConfigFiles: string[];
+export declare function isUsingOxfmt(root: string): boolean;
+export declare function isUsingOxfmtInTree(tree: Tree): boolean;
+export declare function getOxfmtBinPath(): string;
+export declare function writeWithOxfmt(patterns: string[], cwd?: string): void;
+export declare function checkWithOxfmt(patterns: string[]): Promise<string[]>;
+/**
+ * Nothing is written to disk: staging files inside the workspace would race the
+ * daemon's watcher and the project graph mid-generator.
+ *
+ * A path is absent from the result when oxfmt has no parser for it, an ignore
+ * file covers it, or it is already formatted. One unparseable file fails only
+ * itself; the rest of the batch still applies.
+ */
+export declare function formatFilesWithOxfmt(files: {
+    path: string;
+    content: string;
+}[], workspaceRoot: string, seedConfig?: {
+    name: string;
+    content: string;
+}, rootConfigNames?: readonly string[], read?: (relativePath: string) => string | null | undefined): Promise<{
+    formatted: Map<string, string>;
+    errors?: string[];
+}>;