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

package/dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults.md

@@ -8,9 +8,9 @@ This migration copies `cache` onto each executor key that applies to a target wh
 
 An executor key applies to every target that resolves through it, so the migration updates a key only when it can establish that caching is right for all of them. It leaves the key unchanged when the key already declares `cache`, when it declares `continuous: true`, when every entry on the key is filtered so none of them always applies, when a target through it is continuous or is a long-running target such as `serve`, `dev`, or `start`, when the executor's own schema marks its targets continuous, or when a target through it has no target name key enabling `cache`. It never updates the `nx:run-commands` or `nx:run-script` keys, because targets written with `command` and targets derived from `package.json` scripts resolve through those keys without naming them.
 
-Where the migration makes no change, Nx still decides at run time, per target rather than per key: a target whose target name key enables `cache`, and whose resolved configuration still leaves `cache` undefined, gets it back and is reported as a deprecated fallback. Because that test is applied to the resolved target rather than to the key, it also covers the cases where a key looks decided but is not for this project — an executor key whose entries are all filtered, or whose only `cache` declaration is filtered out here. It equally covers the targets left behind because a sibling target through the same key does not opt in, and the targets reaching the `nx:run-commands` and `nx:run-script` keys. Three cases get no fallback and no warning. A continuous or long-running target, because caching it is invalid. A target whose resolved configuration already sets `cache`. And a target whose target name key was discarded as incompatible, because its entry named an executor the target does not use — before Nx 23 that target was cacheable, since cacheability was matched on target name alone and the entry's `executor` was never read. Restoring it here would mean setting `cache` with no executor key to point the user at and no migration able to retire the behavior, so it is deliberately left alone. Set `cache` on those targets directly.
+Where the migration makes no change, the targets resolving through that key are not cached. Nx 24 reads `cache` from the key that wins resolution and nothing else, so `cache` on a target name key has no effect once an executor key applies. That leaves the keys the migration skips, the keys whose only `cache` declaration is filtered, the targets passed over because a sibling target through the same key does not opt in, and the targets reaching the `nx:run-commands` and `nx:run-script` keys. Set `cache` on the key those targets resolve through, or on the targets themselves.
 
-Targets are read from each project's `project.json` and from the `nx.targets` block of its `package.json`. Targets inferred by a plugin, and targets derived from `package.json` scripts, are not visible to the migration — the latter is why the `nx:run-script` key is never updated. A key that looks safe here may still serve an inferred target. Set `cache` on the executor key by hand only after checking that no target reaching it is continuous; Nx rejects a target that is both cacheable and continuous. Nx names both keys in a run-time warning. That warning is emitted during project graph construction, so while the daemon is running it goes to `.nx/workspace-data/d/daemon.log` rather than the terminal; CI runs, where the daemon is disabled, print it normally.
+Targets are read from each project's `project.json` and from the `nx.targets` block of its `package.json`. Targets inferred by a plugin, and targets derived from `package.json` scripts, are not visible to the migration — the latter is why the `nx:run-script` key is never updated. A key that looks safe here may still serve an inferred target. Set `cache` on the executor key by hand only after checking that no target reaching it is continuous; Nx rejects a target that is both cacheable and continuous.
 
 #### Sample code changes
 

package/dist/src/migrations/update-24-0-0/enable-legacy-affected.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from '../../generators/tree';
+export default function enableLegacyAffected(tree: Tree): Promise<{
+    skipAgentic: boolean;
+}>;

package/dist/src/migrations/update-24-0-0/enable-legacy-affected.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = enableLegacyAffected;
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
+const nx_json_1 = require("../../generators/utils/nx-json");
+async function enableLegacyAffected(tree) {
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    if (!nxJson || nxJson.affected?.legacy !== undefined) {
+        return { skipAgentic: true };
+    }
+    nxJson.affected = { ...nxJson.affected, legacy: true };
+    (0, nx_json_1.updateNxJson)(tree, nxJson);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
+    return { skipAgentic: true };
+}

package/dist/src/migrations/update-24-0-0/enable-legacy-affected.md

@@ -0,0 +1,30 @@
+#### Keep legacy `nx affected` selection
+
+In Nx 24, `nx affected -t` selects only the tasks whose inputs a change reaches, instead of every task of each affected project.
+This migration sets `affected.legacy` to `true` in `nx.json`, so existing workspaces keep selecting whole projects after upgrading.
+
+To switch to task selection, remove the setting or set it to `false`.
+The `NX_LEGACY_AFFECTED` environment variable overrides the setting for a single run: `false` selects tasks and `true` selects projects.
+
+The migration skips workspaces that already set `affected.legacy`.
+
+#### Sample code changes
+
+##### Before
+
+```json title="nx.json"
+{
+  "defaultBase": "main"
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "defaultBase": "main",
+  "affected": {
+    "legacy": true
+  }
+}
+```

package/dist/src/migrations/update-24-0-0/find-custom-hashers.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationReturnObject } from '../../config/misc-interfaces';
+import type { Tree } from '../../generators/tree';
+export default function findCustomHashers(tree: Tree): Promise<MigrationReturnObject>;

package/dist/src/migrations/update-24-0-0/find-custom-hashers.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = findCustomHashers;
+const glob_1 = require("../../generators/utils/glob");
+const json_1 = require("../../utils/json");
+const path_1 = require("../../utils/path");
+const node_path_1 = require("node:path");
+const DOCS_URL = 'https://nx.dev/docs/kb/local-executors#replace-a-custom-hasher-with-inputs';
+async function findCustomHashers(tree) {
+    const hits = new Set();
+    const malformed = new Set();
+    const unparseable = [];
+    const visited = new Set();
+    for (const packageJsonPath of await (0, glob_1.globAsync)(tree, ['**/package.json'])) {
+        if (packageJsonPath.split('/').includes('node_modules')) {
+            continue;
+        }
+        const content = tree.read(packageJsonPath, 'utf-8');
+        if (!content.includes('"executors"') && !content.includes('"builders"')) {
+            continue;
+        }
+        const packageJson = tryParse(content);
+        if (!packageJson) {
+            unparseable.push(packageJsonPath);
+            continue;
+        }
+        const packageRoot = node_path_1.posix.dirname(packageJsonPath);
+        // A nameless local plugin is referenced by its relative path.
+        const pluginName = packageJson.name ?? (packageRoot === '.' ? '.' : `./${packageRoot}`);
+        for (const field of [packageJson.executors, packageJson.builders]) {
+            if (typeof field !== 'string') {
+                continue;
+            }
+            const executorsJsonPath = (0, path_1.joinPathFragments)(packageRoot, field);
+            if (visited.has(executorsJsonPath) || !tree.exists(executorsJsonPath)) {
+                continue;
+            }
+            visited.add(executorsJsonPath);
+            const executorsJson = tryParse(tree.read(executorsJsonPath, 'utf-8'));
+            if (!executorsJson) {
+                unparseable.push(executorsJsonPath);
+                continue;
+            }
+            const entries = [];
+            for (const map of [executorsJson.executors, executorsJson.builders]) {
+                if (map === undefined) {
+                    continue;
+                }
+                if (!isPlainObject(map)) {
+                    unparseable.push(executorsJsonPath);
+                    break;
+                }
+                entries.push(...Object.entries(map));
+            }
+            for (const [name, entry] of entries) {
+                if (typeof entry === 'string') {
+                    continue;
+                }
+                if (!isPlainObject(entry) || !isValidHasher(entry.hasher)) {
+                    malformed.add(`Entry "${name}" in "${executorsJsonPath}" is not a valid executor entry. Check it by hand for a "hasher".`);
+                    continue;
+                }
+                if (entry.hasher === undefined) {
+                    continue;
+                }
+                const hasherPath = (0, path_1.joinPathFragments)(node_path_1.posix.dirname(executorsJsonPath), entry.hasher);
+                hits.add(`Executor "${pluginName}:${name}" declares a custom hasher at "${hasherPath}" in "${executorsJsonPath}".`);
+            }
+        }
+    }
+    if (hits.size === 0 && malformed.size === 0 && unparseable.length === 0) {
+        return { skipAgentic: true };
+    }
+    const manualNotes = [
+        ...malformed,
+        ...unparseable.map((path) => `Could not parse "${path}". Check it by hand for executors that declare a "hasher".`),
+    ];
+    return {
+        nextSteps: [
+            `Custom hashers are deprecated and will be removed in Nx 25. Replace each one with target inputs, then remove "hasher" from executors.json. See ${DOCS_URL}`,
+            ...hits,
+            ...manualNotes,
+        ],
+        agentContext: [...hits, ...manualNotes],
+    };
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isValidHasher(hasher) {
+    return hasher === undefined || typeof hasher === 'string';
+}
+function tryParse(content) {
+    try {
+        return (0, json_1.parseJson)(content);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/migrations/update-24-0-0/find-custom-hashers.md

@@ -0,0 +1,63 @@
+#### Move custom executor hashers to target inputs
+
+Custom hashers are deprecated in Nx 24 and will be removed in Nx 25.
+A custom hasher is the `hasher` property of an executor in `executors.json`, pointing at a module that computes the task hash in code.
+Target `inputs` replace them.
+
+This migration finds every local plugin in the workspace whose `executors.json` (or `builders.json`) declares a `hasher`.
+It doesn't edit any files.
+When it finds one, it lists the executor, the hasher module, and the `executors.json` file in the migration's next steps.
+It also lists files and executor entries it can't read, so you can check those by hand.
+Under `nx migrate` with an AI agent, the agent reads each hasher and writes `inputs` that hash the same things.
+A target that declares its own `inputs` doesn't inherit them from `targetDefaults`, so the agent checks every target that uses the executor and adds the inputs where they're missing.
+It removes the `hasher` only once every one of those targets is covered.
+If something the hasher hashes can't be expressed as an input, the agent leaves the hasher in place and tells you why.
+
+Packages installed in `node_modules` aren't scanned.
+If a third-party plugin you use declares a hasher, Nx warns about it when it hashes one of its tasks.
+
+#### Sample code changes
+
+Given a local plugin whose `echo` executor hashes the project, its dependencies, and the `API_URL` environment variable:
+
+##### Before
+
+```json title="tools/my-plugin/executors.json"
+{
+  "executors": {
+    "echo": {
+      "implementation": "./src/executors/echo/executor",
+      "hasher": "./src/executors/echo/hasher",
+      "schema": "./src/executors/echo/schema.json"
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "targetDefaults": {
+    "@acme/my-plugin:echo": {
+      "inputs": ["default", "^default", { "env": "API_URL" }]
+    }
+  }
+}
+```
+
+```json title="tools/my-plugin/executors.json"
+{
+  "executors": {
+    "echo": {
+      "implementation": "./src/executors/echo/executor",
+      "schema": "./src/executors/echo/schema.json"
+    }
+  }
+}
+```
+
+#### Reference
+
+- [Replace a custom hasher with inputs](https://nx.dev/docs/kb/local-executors#replace-a-custom-hasher-with-inputs)
+- [Inputs reference](https://nx.dev/docs/reference/inputs)

package/dist/src/migrations/update-24-0-0/move-custom-hashers-to-inputs.md

@@ -0,0 +1,146 @@
+# Move custom executor hashers to target inputs
+
+Custom hashers (the `hasher` property of an executor in `executors.json`) are
+deprecated in Nx 24 and removed in Nx 25. Each one should become target `inputs`
+that hash the same things, so the targets keep caching correctly once the hasher
+is gone.
+
+The generator half of this migration only scans. It edits no files, and it lists
+every executor that declares a hasher in the `impl.agentContext` field of the
+step's `nx_migrate_prompt` block, one line each, with the executor name, the
+hasher path, and the `executors.json` path. Lines starting with
+`Could not parse` name files the scan skipped, and lines starting with `Entry`
+name executor entries it could not read.
+
+Do not touch executors that declare no hasher, executors installed from
+`node_modules`, or any other caching configuration.
+
+## First, check whether there is anything to do
+
+Confirm this before changing anything. If it fails, make no changes and stop:
+
+1. `impl.agentContext` lists at least one executor that declares a custom
+   hasher, or at least one file or entry it could not read. Read each of those
+   yourself; if it declares no `hasher`, drop it from the list.
+
+## Step 1: Read what each hasher hashes
+
+Open the hasher module named in `impl.agentContext`. Work out every value it
+feeds into the hash it returns:
+
+- `context.hasher.hashTask(task, ...)` alone is Nx default hashing.
+- Files it reads, globs it walks, or other projects it hashes.
+- Environment variables it reads.
+- Commands it runs, or data it fetches (a remote API, a registry lookup).
+
+## Step 2: Write equivalent inputs
+
+Map each value to an input:
+
+| What the hasher hashes                                | Input                                                   |
+| ----------------------------------------------------- | ------------------------------------------------------- |
+| The project and its dependencies (Nx default hashing) | `"default"` and `"^default"`                            |
+| Files of specific other projects                      | `{ "input": "default", "projects": ["shared-config"] }` |
+| A subset of the files in the project                  | `{ "fileset": "{projectRoot}/src/**/*.graphql" }`       |
+| A file outside any project                            | `{ "fileset": "{workspaceRoot}/schema.json" }`          |
+| An environment variable                               | `{ "env": "API_URL" }`                                  |
+| The output of a command, such as a tool version       | `{ "runtime": "node --version" }`                       |
+
+If the workspace defines named inputs such as `production`, prefer them over
+`default` where the hasher excluded test files.
+
+### Find every target that uses the executor
+
+Write the resolved project graph and list every target whose `executor` is the
+executor name (`"@acme/my-plugin:echo"`):
+
+```shell
+npx nx graph --file=tmp/custom-hashers-graph.json
+```
+
+Each target in `graph.nodes.<project>.data.targets` there is fully resolved: it
+already reflects `targetDefaults` (including filtered array entries), inferred
+targets, and project-level overrides. Record each consuming target's resolved
+`inputs`. Every one of them must end up covered.
+
+### Place the inputs
+
+A target that declares its own `inputs` replaces the `inputs` from
+`targetDefaults` rather than merging with them. So a `targetDefaults` edit alone
+does not reach a target that already declares `inputs`.
+
+1. Set the inputs in `nx.json` `targetDefaults` under the executor name. If that
+   key already exists, add `inputs` to it, and merge with any `inputs` it already
+   declares rather than replacing them. If its value is an array of filtered
+   entries, add the inputs to every entry that applies to a consuming target.
+2. For every consuming target that declares its own `inputs`, add the
+   replacement inputs to that target as well, keeping the inputs it already has.
+   It is declared in `project.json`, in the `nx.targets` block of
+   `package.json`, or by the plugin that infers the target. For an inferred
+   target, set `inputs` in `project.json` to the full resolved list plus the
+   replacement inputs.
+3. Write the graph again and confirm that every consuming target's resolved
+   `inputs` now contains every replacement input. Fix any that do not.
+
+**Before:**
+
+```json
+// tools/my-plugin/executors.json
+{
+  "executors": {
+    "echo": {
+      "implementation": "./src/executors/echo/executor",
+      "hasher": "./src/executors/echo/hasher",
+      "schema": "./src/executors/echo/schema.json"
+    }
+  }
+}
+```
+
+**After:**
+
+```json
+// nx.json
+{
+  "targetDefaults": {
+    "@acme/my-plugin:echo": {
+      "inputs": ["default", "^default", { "env": "API_URL" }]
+    }
+  }
+}
+```
+
+```json
+// tools/my-plugin/executors.json
+{
+  "executors": {
+    "echo": {
+      "implementation": "./src/executors/echo/executor",
+      "schema": "./src/executors/echo/schema.json"
+    }
+  }
+}
+```
+
+## Step 3: Remove the hasher only when the inputs cover it
+
+Remove `hasher` from `executors.json` and delete the hasher module (and its
+spec) only once the resolved inputs of every consuming target cover everything
+the hasher hashed.
+
+If a value has no file, environment variable, or project to point at, such as
+data fetched from a remote service, use a `runtime` input whose command prints
+that value. If no command can reproduce it, leave the hasher in place and tell
+the user which value blocks the move and why.
+
+## Post-Migration Validation
+
+1. `npx nx show target <project>:<target>` for every consuming target found in
+   Step 2. Confirm each one lists the replacement inputs. After the hasher is
+   removed, `npx nx show target <project>:<target> inputs` also shows the files
+   and values those inputs resolve to.
+2. `npx nx run-many -t <target>` twice for the targets that used the executor.
+   The second run should be a cache hit. Change a file the hasher used to hash
+   and confirm the next run is a cache miss.
+3. `npx nx run-many -t build,test,lint -p <plugin project>` if you deleted hasher
+   files. Fix failures caused by this migration and re-run until green.

package/dist/src/migrations/update-24-0-0/rename-ultracache-ignore-options.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationReturnObject } from '../../config/misc-interfaces';
+import type { Tree } from '../../generators/tree';
+export default function update(tree: Tree): Promise<MigrationReturnObject>;

package/dist/src/migrations/update-24-0-0/rename-ultracache-ignore-options.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+const RENAMED_ULTRACACHE_KEYS = new Map([
+    ['ignoredReads', 'ignoreReads'],
+    ['ignoredWrites', 'ignoreWrites'],
+]);
+const WORKFLOWS_DIR = '.nx/workflows';
+const CONFIG_EXTENSIONS = ['yaml', 'yml'];
+const OLD_CONFIG_PATH = /(\.nx\/workflows\/)sandboxing-config\.(ya?ml)/g;
+// Matches a block-style key at the start of a line or after a sequence dash,
+// optionally quoted. Comments and values are left alone.
+const OLD_YAML_KEY = /^(\s*(?:-\s+)?)(['"]?)exclude-(reads|writes)\2(\s*:)/gm;
+async function update(tree) {
+    const manual = [];
+    for (const [name, project] of (0, project_configuration_1.getProjects)(tree)) {
+        let changed = false;
+        for (const target of Object.values(project.targets ?? {})) {
+            changed = renameUltracacheKeys(target) || changed;
+        }
+        const rewritten = rewriteConfigPaths(project);
+        if (changed || rewritten !== project) {
+            (0, project_configuration_1.updateProjectConfiguration)(tree, name, rewritten);
+        }
+    }
+    const nxJson = (0, project_configuration_1.readNxJson)(tree);
+    if (nxJson) {
+        let changed = false;
+        for (const value of Object.values(nxJson.targetDefaults ?? {})) {
+            for (const entry of targetDefaultEntries(value)) {
+                changed = renameUltracacheKeys(entry) || changed;
+            }
+        }
+        const rewritten = rewriteConfigPaths(nxJson);
+        if (changed || rewritten !== nxJson) {
+            (0, project_configuration_1.updateNxJson)(tree, rewritten);
+        }
+    }
+    manual.push(...renameWorkspaceConfig(tree));
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
+    if (manual.length === 0) {
+        return { skipAgentic: true };
+    }
+    return { nextSteps: manual, agentContext: manual };
+}
+function targetDefaultEntries(value) {
+    return Array.isArray(value) ? value : [value];
+}
+function renameUltracacheKeys(target) {
+    const ultracache = target?.ultracache;
+    if (!ultracache ||
+        typeof ultracache !== 'object' ||
+        !Object.keys(ultracache).some((key) => RENAMED_ULTRACACHE_KEYS.has(key))) {
+        return false;
+    }
+    const renamed = {};
+    for (const [key, value] of Object.entries(ultracache)) {
+        const newKey = RENAMED_ULTRACACHE_KEYS.get(key) ?? key;
+        renamed[newKey] = mergePatterns(renamed[newKey], value);
+    }
+    target.ultracache = renamed;
+    return true;
+}
+// A target may already declare the new key beside the old one; keep both sets.
+function mergePatterns(existing, incoming) {
+    if (existing === undefined) {
+        return incoming;
+    }
+    if (!Array.isArray(existing) || !Array.isArray(incoming)) {
+        return incoming;
+    }
+    return [...existing, ...incoming.filter((p) => !existing.includes(p))];
+}
+// Returns the same reference when nothing changed.
+function rewriteConfigPaths(value) {
+    if (typeof value === 'string') {
+        const replaced = value.replace(OLD_CONFIG_PATH, '$1ultracache-config.$2');
+        return (replaced === value ? value : replaced);
+    }
+    if (Array.isArray(value)) {
+        const mapped = value.map(rewriteConfigPaths);
+        return (mapped.some((v, i) => v !== value[i]) ? mapped : value);
+    }
+    if (value && typeof value === 'object') {
+        let changed = false;
+        const mapped = {};
+        for (const [key, v] of Object.entries(value)) {
+            mapped[key] = rewriteConfigPaths(v);
+            changed ||= mapped[key] !== v;
+        }
+        return (changed ? mapped : value);
+    }
+    return value;
+}
+function renameWorkspaceConfig(tree) {
+    const existingNew = CONFIG_EXTENSIONS.map((ext) => `${WORKFLOWS_DIR}/ultracache-config.${ext}`).filter((path) => tree.exists(path));
+    const manual = [];
+    for (const ext of CONFIG_EXTENSIONS) {
+        const oldPath = `${WORKFLOWS_DIR}/sandboxing-config.${ext}`;
+        if (!tree.exists(oldPath)) {
+            continue;
+        }
+        if (existingNew.length > 0) {
+            manual.push(`Both "${oldPath}" and "${existingNew[0]}" exist. Nx Cloud reads only "${existingNew[0]}", so merge the patterns from "${oldPath}" into it and delete "${oldPath}".`);
+            continue;
+        }
+        const newPath = `${WORKFLOWS_DIR}/ultracache-config.${ext}`;
+        tree.rename(oldPath, newPath);
+        existingNew.push(newPath);
+    }
+    for (const path of existingNew) {
+        const content = tree.read(path, 'utf-8') ?? '';
+        const updated = content.replace(OLD_YAML_KEY, '$1$2ignore-$3$2$4');
+        if (updated !== content) {
+            tree.write(path, updated);
+        }
+        if (hasOldYamlKey(updated)) {
+            manual.push(`"${path}" still uses "exclude-reads" or "exclude-writes" in a form the migration could not rewrite. Rename them to "ignore-reads" and "ignore-writes".`);
+        }
+    }
+    return manual;
+}
+function hasOldYamlKey(content) {
+    return content
+        .split('\n')
+        .map((line) => line.replace(/#.*$/, ''))
+        .some((line) => /['"]?exclude-(reads|writes)['"]?\s*:/.test(line));
+}

package/dist/src/migrations/update-24-0-0/rename-ultracache-ignore-options.md

@@ -0,0 +1,62 @@
+#### Rename ultracache ignore options
+
+Nx 24 renames the `ultracache` target options `ignoredReads` and `ignoredWrites` to `ignoreReads` and `ignoreWrites`.
+The workspace-wide exclusions file moves from `.nx/workflows/sandboxing-config.yaml` to `.nx/workflows/ultracache-config.yaml`, and its `exclude-reads` and `exclude-writes` keys become `ignore-reads` and `ignore-writes`.
+
+This migration renames the options in every target in `project.json` files, in the `nx` block of `package.json` files, and in `targetDefaults` in `nx.json`.
+When a target sets both the old and the new option, it combines their patterns under the new one.
+It renames `.nx/workflows/sandboxing-config.yaml` (or `.yml`) and the keys inside it, including those in `task-exclusions` entries.
+It also updates any `inputs` or `namedInputs` entry that points at the old file.
+
+If `.nx/workflows/ultracache-config.yaml` already exists, the migration leaves both files in place and lists them in its next steps so you can merge them by hand.
+It does the same when the file writes those keys in a form it can't rewrite, such as an inline `{ }` map.
+
+#### Sample code changes
+
+##### Before
+
+```json title="apps/app/project.json"
+{
+  "targets": {
+    "build": {
+      "ultracache": {
+        "ignoredReads": ["tmp/**"],
+        "ignoredWrites": ["**/.cache/**"]
+      }
+    }
+  }
+}
+```
+
+```yaml title=".nx/workflows/sandboxing-config.yaml"
+exclude-reads:
+  - 'dist/**'
+task-exclusions:
+  - target: lint
+    exclude-writes:
+      - .eslintcache/**
+```
+
+##### After
+
+```json title="apps/app/project.json"
+{
+  "targets": {
+    "build": {
+      "ultracache": {
+        "ignoreReads": ["tmp/**"],
+        "ignoreWrites": ["**/.cache/**"]
+      }
+    }
+  }
+}
+```
+
+```yaml title=".nx/workflows/ultracache-config.yaml"
+ignore-reads:
+  - 'dist/**'
+task-exclusions:
+  - target: lint
+    ignore-writes:
+      - .eslintcache/**
+```

package/dist/src/native/assert-supported-platform.js

@@ -12,7 +12,7 @@ function assertSupportedPlatform() {
         if (process.platform == 'win32' ||
             process.platform == 'darwin' ||
             process.platform == 'linux' ||
-            process.platform == 'freebsd' || process.platform == 'openharmony') {
+            process.platform == 'freebsd') {
             title = 'Missing Platform Dependency';
             bodyLines = [
                 `The Nx CLI could not find or load the native binary for your supported platform (${process.platform}-${process.arch}).`,