Overview - Nx

Nx

7 days30 days

Latest CI Pipeline Executions

Failed
33734
8d77a7e0 perf(module-federation): optimize performance and reduce code duplication Performance improvements: - Cache readRootPackageJson() to avoid repeated file reads - Hoist readTsPathMappings() call in dependencies.ts to avoid repeated lookups - Memoize getDependentPackagesForProject() with WeakMap for automatic invalidation - Pre-compute libFolder values in module replacement plugin to avoid hot-path computations Code deduplication: - Extract shared proxy server utility (removes ~120 lines of duplicate code) - Extract createRemoteUrlResolver() (removes ~80 lines of duplicate code) - Consolidate parseStaticRemotesConfig/parseStaticSsrRemotesConfig into shared core function Files changed: - New: utils/proxy-server.ts - shared proxy server implementation - New: utils/remote-url.ts - shared remote URL resolver - Modified: utils/package-json.ts - added caching - Modified: utils/dependencies.ts - hoisted tsConfig, added memoization - Modified: utils/share.ts - pre-computed libFolder - Modified: utils/parse-static-remotes-config.ts - consolidated functions - Modified: webpack/utils.ts, rspack/utils.ts, angular/utils.ts - use shared utilities - Modified: start-remote-proxies.ts, start-ssr-remote-proxies.ts - use shared proxy utility
2 hours ago by adwait1290
Succeeded
master
badc998c fix(core): share visited Set across affected graph traversal (#33756) ## Current Behavior In `filterAffectedProjects`, a **new visited Set is created for each touched project**: ```typescript ctx.touchedProjects.forEach((p) => { addAffectedNodes(p, reversed, result, new Set()); // NEW Set per project! }); ctx.touchedProjects.forEach((p) => { addAffectedDependencies(p, reversed, result, new Set()); // NEW Set per project! }); ``` This defeats the purpose of the visited Set for deduplication. If projects A and B both depend on shared project C, then C gets visited **twice**. ## Expected Behavior Share a single visited Set across all touched projects: ```typescript const visitedNodes = new Set<string>(); const visitedDeps = new Set<string>(); for (const p of ctx.touchedProjects) { addAffectedNodes(p, reversed, result, visitedNodes); // SHARED Set } for (const p of ctx.touchedProjects) { addAffectedDependencies(p, reversed, result, visitedDeps); // SHARED Set } ``` ## Performance Impact ``` Before (separate Sets): After (shared Sets): ┌─────────────────────────┐ ┌─────────────────────────┐ │ touchedProjects: [A,B] │ │ touchedProjects: [A,B] │ └───────────┬─────────────┘ └───────────┬─────────────┘ │ │ ┌───────┴───────┐ ┌───────┴───────┐ ▼ ▼ ▼ ▼ ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐ │ A │ │ B │ │ A │ │ B │ │visited│ │visited│ │ │ │ │ │= {} │ │= {} │ │ shared visitedNodes │ └───┬───┘ └───┬───┘ └───┬───┘ └───┬───┘ │ │ │ │ ▼ ▼ ▼ ▼ ┌───────┐ ┌───────┐ ┌───────────────────────┐ │visit C│ │visit C│ │ visit C (ONCE) │ │(dup!) │ │(dup!) │ │ skip C from B │ └───────┘ └───────┘ └───────────────────────┘ Complexity: Complexity: O(touched × shared_deps) O(total_nodes) ``` **Example**: With 50 touched projects sharing 100 common dependencies: - Before: 50 × 100 = 5,000 node visits - After: ~150 node visits (each node visited once) ## Why Accept This PR 1. **Bug-like behavior**: The current code defeats the purpose of the visited Set 2. **Significant impact**: Affects every `nx affected` command 3. **Zero risk**: Same traversal logic, just shared deduplication 4. **Common scenario**: Monorepos often have shared dependencies (utils, types, etc.) ## Related Issue(s) Contributes to #32265 ## Merge Dependencies This PR has no dependencies and can be merged independently. --- Co-authored-by: Leosvel Pérez Espinosa <leosvel.perez.espinosa@gmail.com>
3 hours ago by adwait1290
Succeeded
master
badc998c fix(core): share visited Set across affected graph traversal (#33756) ## Current Behavior In `filterAffectedProjects`, a **new visited Set is created for each touched project**: ```typescript ctx.touchedProjects.forEach((p) => { addAffectedNodes(p, reversed, result, new Set()); // NEW Set per project! }); ctx.touchedProjects.forEach((p) => { addAffectedDependencies(p, reversed, result, new Set()); // NEW Set per project! }); ``` This defeats the purpose of the visited Set for deduplication. If projects A and B both depend on shared project C, then C gets visited **twice**. ## Expected Behavior Share a single visited Set across all touched projects: ```typescript const visitedNodes = new Set<string>(); const visitedDeps = new Set<string>(); for (const p of ctx.touchedProjects) { addAffectedNodes(p, reversed, result, visitedNodes); // SHARED Set } for (const p of ctx.touchedProjects) { addAffectedDependencies(p, reversed, result, visitedDeps); // SHARED Set } ``` ## Performance Impact ``` Before (separate Sets): After (shared Sets): ┌─────────────────────────┐ ┌─────────────────────────┐ │ touchedProjects: [A,B] │ │ touchedProjects: [A,B] │ └───────────┬─────────────┘ └───────────┬─────────────┘ │ │ ┌───────┴───────┐ ┌───────┴───────┐ ▼ ▼ ▼ ▼ ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐ │ A │ │ B │ │ A │ │ B │ │visited│ │visited│ │ │ │ │ │= {} │ │= {} │ │ shared visitedNodes │ └───┬───┘ └───┬───┘ └───┬───┘ └───┬───┘ │ │ │ │ ▼ ▼ ▼ ▼ ┌───────┐ ┌───────┐ ┌───────────────────────┐ │visit C│ │visit C│ │ visit C (ONCE) │ │(dup!) │ │(dup!) │ │ skip C from B │ └───────┘ └───────┘ └───────────────────────┘ Complexity: Complexity: O(touched × shared_deps) O(total_nodes) ``` **Example**: With 50 touched projects sharing 100 common dependencies: - Before: 50 × 100 = 5,000 node visits - After: ~150 node visits (each node visited once) ## Why Accept This PR 1. **Bug-like behavior**: The current code defeats the purpose of the visited Set 2. **Significant impact**: Affects every `nx affected` command 3. **Zero risk**: Same traversal logic, just shared deduplication 4. **Common scenario**: Monorepos often have shared dependencies (utils, types, etc.) ## Related Issue(s) Contributes to #32265 ## Merge Dependencies This PR has no dependencies and can be merged independently. --- Co-authored-by: Leosvel Pérez Espinosa <leosvel.perez.espinosa@gmail.com>
4 hours ago by adwait1290
Canceled
master
badc998c fix(core): share visited Set across affected graph traversal (#33756) ## Current Behavior In `filterAffectedProjects`, a **new visited Set is created for each touched project**: ```typescript ctx.touchedProjects.forEach((p) => { addAffectedNodes(p, reversed, result, new Set()); // NEW Set per project! }); ctx.touchedProjects.forEach((p) => { addAffectedDependencies(p, reversed, result, new Set()); // NEW Set per project! }); ``` This defeats the purpose of the visited Set for deduplication. If projects A and B both depend on shared project C, then C gets visited **twice**. ## Expected Behavior Share a single visited Set across all touched projects: ```typescript const visitedNodes = new Set<string>(); const visitedDeps = new Set<string>(); for (const p of ctx.touchedProjects) { addAffectedNodes(p, reversed, result, visitedNodes); // SHARED Set } for (const p of ctx.touchedProjects) { addAffectedDependencies(p, reversed, result, visitedDeps); // SHARED Set } ``` ## Performance Impact ``` Before (separate Sets): After (shared Sets): ┌─────────────────────────┐ ┌─────────────────────────┐ │ touchedProjects: [A,B] │ │ touchedProjects: [A,B] │ └───────────┬─────────────┘ └───────────┬─────────────┘ │ │ ┌───────┴───────┐ ┌───────┴───────┐ ▼ ▼ ▼ ▼ ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐ │ A │ │ B │ │ A │ │ B │ │visited│ │visited│ │ │ │ │ │= {} │ │= {} │ │ shared visitedNodes │ └───┬───┘ └───┬───┘ └───┬───┘ └───┬───┘ │ │ │ │ ▼ ▼ ▼ ▼ ┌───────┐ ┌───────┐ ┌───────────────────────┐ │visit C│ │visit C│ │ visit C (ONCE) │ │(dup!) │ │(dup!) │ │ skip C from B │ └───────┘ └───────┘ └───────────────────────┘ Complexity: Complexity: O(touched × shared_deps) O(total_nodes) ``` **Example**: With 50 touched projects sharing 100 common dependencies: - Before: 50 × 100 = 5,000 node visits - After: ~150 node visits (each node visited once) ## Why Accept This PR 1. **Bug-like behavior**: The current code defeats the purpose of the visited Set 2. **Significant impact**: Affects every `nx affected` command 3. **Zero risk**: Same traversal logic, just shared deduplication 4. **Common scenario**: Monorepos often have shared dependencies (utils, types, etc.) ## Related Issue(s) Contributes to #32265 ## Merge Dependencies This PR has no dependencies and can be merged independently. --- Co-authored-by: Leosvel Pérez Espinosa <leosvel.perez.espinosa@gmail.com>
5 hours ago by adwait1290
Succeeded
master
58a69f99 fix(core): optimize pnpm lockfile parsing with pre-built indexes (#33750) ## Current Behavior When parsing pnpm lockfiles to build the project graph: ### matchPropValue function - Uses separate `Object.values()` + `Object.keys()` iterations - Two passes over the same data to find a value and get its key ### Hoisted Dependencies Lookup - For each package, calls `Object.keys(hoistedDeps).find(k => k.startsWith(...))` - O(n) search performed m times = O(n*m) total ## Expected Behavior ### Single-pass Iteration ``` BEFORE: matchPropValue ┌─────────────────────────────────────────────────────────────┐ │ const index = Object.values(record).findIndex(v === key) │ │ if (index > -1) │ │ return Object.keys(record)[index] ← Another iteration! │ │ │ │ = 2 iterations over the same data │ └─────────────────────────────────────────────────────────────┘ AFTER: Object.entries() single pass ┌─────────────────────────────────────────────────────────────┐ │ for (const [name, version] of Object.entries(record)) { │ │ if (version === key) return name ← Early exit │ │ } │ │ │ │ = 1 iteration with early exit on match │ └─────────────────────────────────────────────────────────────┘ ``` ### Pre-built Index for Hoisted Dependencies ``` BEFORE: O(n*m) Hoisted Lookup ┌─────────────────────────────────────────────────────────────┐ │ for each package (n packages): │ │ Object.keys(hoistedDeps).find(k => k.startsWith(...)) │ │ ← O(m) search where m = hoisted deps │ │ │ │ Total: O(n * m) │ │ │ │ Example: 500 packages × 200 hoisted deps │ │ = 100,000 string comparisons │ └─────────────────────────────────────────────────────────────┘ AFTER: Pre-built Index Map O(n+m) ┌─────────────────────────────────────────────────────────────┐ │ Build hoistedKeysByPackage Map once: O(m) │ │ Map<packageName, hoistedKey> │ │ │ │ for each package (n packages): │ │ hoistedKeysByPackage.get(packageName) O(1) │ │ │ │ Total: O(n + m) │ │ │ │ Example: 500 packages + 200 hoisted deps │ │ = 700 operations (vs 100,000) │ └─────────────────────────────────────────────────────────────┘ ``` ## Impact For large pnpm monorepos: | Metric | Before | After | Improvement | |--------|--------|-------|-------------| | matchPropValue iterations | 2 | 1 | 50% fewer iterations | | Hoisted lookup complexity | O(n×m) | O(n+m) | ~100x for large repos | | String comparisons | n×m | n+m | Dramatic reduction | ## Related Issue(s) Contributes to #32669, #32254 ## Merge Dependencies This PR has no dependencies and can be merged independently. **Must be merged BEFORE:** #33751 ---
5 hours ago by adwait1290
Succeeded
33750
4156b4f2 chore: address review - make hoistedKeysByPackage non-optional, simplify usage
5 hours ago by adwait1290
Canceled
33750
4156b4f2 chore: address review - make hoistedKeysByPackage non-optional, simplify usage
7 hours ago by adwait1290
Failed
33756
13f58594 perf(core): share visited Set across affected graph traversal Previously, filterAffectedProjects created a NEW visited Set for each touched project, defeating the purpose of deduplication. If projects A and B both depend on shared project C, C would be visited twice. Now uses shared visited Sets across all touched projects, reducing redundant traversal from O(touchedProjects × sharedDeps) to O(nodes).
23 hours ago by adwait1290
Failed
33737
400d8336 perf(core): optimize task graph cycle detection and formatting Improve performance of task graph operations from O(n³) to O(n): 1. Task graph cycle detection (task-graph-utils.ts): - Replace Array.includes() with Set.has() for O(1) path lookup - Use mutable Set/Array pair to avoid creating new arrays per recursion - Collect cyclic deps before removal to avoid mutation during iteration - Affects: findCycle(), findCycles(), makeAcyclic() 2. Task formatting (formatting-utils.ts): - Convert projectNames and targets arrays to Sets upfront - Replace O(n) Array.includes() with O(1) Set.has() in forEach loop - Add type annotations to Sets for clarity Performance impact: - Cycle detection: O(n³) → O(n) where n = number of tasks - Formatting: O(n*m) → O(n+m) where n = tasks, m = projects - For 100+ task monorepos: 10-50x improvement in cycle detection
23 hours ago by adwait1290
Failed
33756
13f58594 perf(core): share visited Set across affected graph traversal Previously, filterAffectedProjects created a NEW visited Set for each touched project, defeating the purpose of deduplication. If projects A and B both depend on shared project C, C would be visited twice. Now uses shared visited Sets across all touched projects, reducing redundant traversal from O(touchedProjects × sharedDeps) to O(nodes).
1 day ago by adwait1290
Failed
master
68783a9c fix(module-federation): normalize workspace protocol versions in requiredVersion (#33733) ## Current Behavior When using pnpm with workspace protocol (`workspace:*`, `workspace:^`, etc.), module federation sets `requiredVersion` to the raw protocol string (e.g., `workspace:*`) instead of resolving it to the actual semver version from the library's package.json. This causes issues like: - `requiredVersion: "workspace:*"` which is not a valid semver - Module federation failing to properly share workspace libraries - Warnings about unable to find required versions Example of the broken output: ```json { "version": "*", "singleton": true, "requiredVersion": "^*" } ``` ## Expected Behavior When a workspace protocol version is detected, it should be resolved to the actual version from the library's package.json: ```json { "version": "2.0.0", "singleton": true, "requiredVersion": "2.0.0" } ``` ## Changes Made 1. **Added helper functions** in `share.ts`: - `isWorkspaceProtocolVersion()` - Detects workspace protocol versions (`workspace:*`, `workspace:^`, `*`, `file:`) - `normalizeWorkspaceProtocolVersion()` - Resolves protocol versions to actual semver by looking up the library's package.json 2. **Applied normalization in `shareWorkspaceLibraries()`**: - After getting version from `getDependencyVersionFromPackageJson`, normalize it if it's a workspace protocol - Simplified the `workspaceLibrariesAsDeps` loop by using the helper function (removed duplicated logic) 3. **Updated `getNpmPackageSharedConfig()`**: - Added a check to warn and return undefined when workspace protocol versions are passed - Helps users understand that workspace libraries should be configured properly 4. **Added comprehensive tests** (13 new tests): - 6 tests for workspace protocol version normalization in `shareWorkspaceLibraries` - 7 tests for `getNpmPackageSharedConfig` handling workspace protocol versions ## Related Issue(s) Fixes #31397 ## Merge Dependencies This PR has no dependencies and can be merged independently. **Must be merged BEFORE:** #33734 ---
1 day ago by adwait1290
Failed
master
68783a9c fix(module-federation): normalize workspace protocol versions in requiredVersion (#33733) ## Current Behavior When using pnpm with workspace protocol (`workspace:*`, `workspace:^`, etc.), module federation sets `requiredVersion` to the raw protocol string (e.g., `workspace:*`) instead of resolving it to the actual semver version from the library's package.json. This causes issues like: - `requiredVersion: "workspace:*"` which is not a valid semver - Module federation failing to properly share workspace libraries - Warnings about unable to find required versions Example of the broken output: ```json { "version": "*", "singleton": true, "requiredVersion": "^*" } ``` ## Expected Behavior When a workspace protocol version is detected, it should be resolved to the actual version from the library's package.json: ```json { "version": "2.0.0", "singleton": true, "requiredVersion": "2.0.0" } ``` ## Changes Made 1. **Added helper functions** in `share.ts`: - `isWorkspaceProtocolVersion()` - Detects workspace protocol versions (`workspace:*`, `workspace:^`, `*`, `file:`) - `normalizeWorkspaceProtocolVersion()` - Resolves protocol versions to actual semver by looking up the library's package.json 2. **Applied normalization in `shareWorkspaceLibraries()`**: - After getting version from `getDependencyVersionFromPackageJson`, normalize it if it's a workspace protocol - Simplified the `workspaceLibrariesAsDeps` loop by using the helper function (removed duplicated logic) 3. **Updated `getNpmPackageSharedConfig()`**: - Added a check to warn and return undefined when workspace protocol versions are passed - Helps users understand that workspace libraries should be configured properly 4. **Added comprehensive tests** (13 new tests): - 6 tests for workspace protocol version normalization in `shareWorkspaceLibraries` - 7 tests for `getNpmPackageSharedConfig` handling workspace protocol versions ## Related Issue(s) Fixes #31397 ## Merge Dependencies This PR has no dependencies and can be merged independently. **Must be merged BEFORE:** #33734 ---
1 day ago by adwait1290
Failed
33737
400d8336 perf(core): optimize task graph cycle detection and formatting Improve performance of task graph operations from O(n³) to O(n): 1. Task graph cycle detection (task-graph-utils.ts): - Replace Array.includes() with Set.has() for O(1) path lookup - Use mutable Set/Array pair to avoid creating new arrays per recursion - Collect cyclic deps before removal to avoid mutation during iteration - Affects: findCycle(), findCycles(), makeAcyclic() 2. Task formatting (formatting-utils.ts): - Convert projectNames and targets arrays to Sets upfront - Replace O(n) Array.includes() with O(1) Set.has() in forEach loop - Add type annotations to Sets for clarity Performance impact: - Cycle detection: O(n³) → O(n) where n = number of tasks - Formatting: O(n*m) → O(n+m) where n = tasks, m = projects - For 100+ task monorepos: 10-50x improvement in cycle detection
1 day ago by adwait1290
Failed
master
68783a9c fix(module-federation): normalize workspace protocol versions in requiredVersion (#33733) ## Current Behavior When using pnpm with workspace protocol (`workspace:*`, `workspace:^`, etc.), module federation sets `requiredVersion` to the raw protocol string (e.g., `workspace:*`) instead of resolving it to the actual semver version from the library's package.json. This causes issues like: - `requiredVersion: "workspace:*"` which is not a valid semver - Module federation failing to properly share workspace libraries - Warnings about unable to find required versions Example of the broken output: ```json { "version": "*", "singleton": true, "requiredVersion": "^*" } ``` ## Expected Behavior When a workspace protocol version is detected, it should be resolved to the actual version from the library's package.json: ```json { "version": "2.0.0", "singleton": true, "requiredVersion": "2.0.0" } ``` ## Changes Made 1. **Added helper functions** in `share.ts`: - `isWorkspaceProtocolVersion()` - Detects workspace protocol versions (`workspace:*`, `workspace:^`, `*`, `file:`) - `normalizeWorkspaceProtocolVersion()` - Resolves protocol versions to actual semver by looking up the library's package.json 2. **Applied normalization in `shareWorkspaceLibraries()`**: - After getting version from `getDependencyVersionFromPackageJson`, normalize it if it's a workspace protocol - Simplified the `workspaceLibrariesAsDeps` loop by using the helper function (removed duplicated logic) 3. **Updated `getNpmPackageSharedConfig()`**: - Added a check to warn and return undefined when workspace protocol versions are passed - Helps users understand that workspace libraries should be configured properly 4. **Added comprehensive tests** (13 new tests): - 6 tests for workspace protocol version normalization in `shareWorkspaceLibraries` - 7 tests for `getNpmPackageSharedConfig` handling workspace protocol versions ## Related Issue(s) Fixes #31397 ## Merge Dependencies This PR has no dependencies and can be merged independently. **Must be merged BEFORE:** #33734 ---
1 day ago by adwait1290
Failed
33737
400d8336 perf(core): optimize task graph cycle detection and formatting Improve performance of task graph operations from O(n³) to O(n): 1. Task graph cycle detection (task-graph-utils.ts): - Replace Array.includes() with Set.has() for O(1) path lookup - Use mutable Set/Array pair to avoid creating new arrays per recursion - Collect cyclic deps before removal to avoid mutation during iteration - Affects: findCycle(), findCycles(), makeAcyclic() 2. Task formatting (formatting-utils.ts): - Convert projectNames and targets arrays to Sets upfront - Replace O(n) Array.includes() with O(1) Set.has() in forEach loop - Add type annotations to Sets for clarity Performance impact: - Cycle detection: O(n³) → O(n) where n = number of tasks - Formatting: O(n*m) → O(n+m) where n = tasks, m = projects - For 100+ task monorepos: 10-50x improvement in cycle detection
1 day ago by adwait1290
Failed
33736
753c3adc perf(core): optimize project graph cache validation Improve performance of `shouldRecomputeWholeGraph` which runs on every Nx command that touches the project graph. Changes: 1. Add pre-computed hashes to FileMapCache for pathMappings, nxJsonPlugins, and pluginsConfig - computed once when cache is written, compared on read 2. Replace JSON.stringify comparison with hash comparison using native hasher 3. Maintain backward compatibility with legacy caches (fallback to old logic) 4. Replace JSON.parse(JSON.stringify) deep clone with structuredClone Performance impact: - Cache validation: O(1) hash comparison vs O(n) JSON.stringify per item - Deep clone: structuredClone is 2-3x faster than JSON round-trip - Hot path: runs on every `nx build`, `nx test`, `nx run`, etc. The native hasher uses xxhash which is significantly faster than JSON.stringify for comparison purposes.
1 day ago by adwait1290
Failed
33737
400d8336 perf(core): optimize task graph cycle detection and formatting Improve performance of task graph operations from O(n³) to O(n): 1. Task graph cycle detection (task-graph-utils.ts): - Replace Array.includes() with Set.has() for O(1) path lookup - Use mutable Set/Array pair to avoid creating new arrays per recursion - Collect cyclic deps before removal to avoid mutation during iteration - Affects: findCycle(), findCycles(), makeAcyclic() 2. Task formatting (formatting-utils.ts): - Convert projectNames and targets arrays to Sets upfront - Replace O(n) Array.includes() with O(1) Set.has() in forEach loop - Add type annotations to Sets for clarity Performance impact: - Cycle detection: O(n³) → O(n) where n = number of tasks - Formatting: O(n*m) → O(n+m) where n = tasks, m = projects - For 100+ task monorepos: 10-50x improvement in cycle detection
1 day ago by adwait1290
Succeeded
33733
d43db9c1 fix(module-federation): normalize workspace protocol versions in requiredVersion When using pnpm with workspace protocol (workspace:*, workspace:^, etc.), module federation was setting requiredVersion to the raw protocol string instead of resolving it to the actual version from the library's package.json. This change: - Adds helper functions to detect and normalize workspace protocol versions - Applies normalization in shareWorkspaceLibraries() after getting versions - Adds warning in getNpmPackageSharedConfig() for workspace protocol versions - Adds comprehensive tests for the new functionality Fixes #31397
1 day ago by adwait1290
Failed
33738
5edc9bc3 perf(core): optimize daemon server hot paths Optimize sync-generators.ts: - Replace O(n²) .every() check with Set for O(1) lookup in processConflictingGenerators - Remove intermediate Set creation in collectAndScheduleSyncGenerators Optimize outputs-tracking.ts: - Reduce dirname() calls by 50% (calculate once per iteration instead of twice) - Add early exit for disabled check before expensive normalization - Make normalizeOutputs synchronous (underlying FFI call is sync) - Replace new Date().getTime() with Date.now() for consistency
2 days ago by adwait1290
Failed
33738
5edc9bc3 perf(core): optimize daemon server hot paths Optimize sync-generators.ts: - Replace O(n²) .every() check with Set for O(1) lookup in processConflictingGenerators - Remove intermediate Set creation in collectAndScheduleSyncGenerators Optimize outputs-tracking.ts: - Reduce dirname() calls by 50% (calculate once per iteration instead of twice) - Add early exit for disabled check before expensive normalization - Make normalizeOutputs synchronous (underlying FFI call is sync) - Replace new Date().getTime() with Date.now() for consistency
2 days ago by adwait1290