@wyw-in-js/transform 2.0.0-alpha.1 → 2.0.1

package/types/utils/EventEmitter.js

@@ -18,6 +18,13 @@ export class EventEmitter {
         this.enabled = enabled;
     }
     action(actonType, idx, entrypointRef, fn) {
+        // Fast path: when the emitter is disabled (the dummy used by the
+        // production transform path) skip start/finish bookkeeping and the
+        // Promise hookup. action() is on the hot path for every step of every
+        // action — its per-call overhead is small but ubiquitous.
+        if (!this.enabled) {
+            return fn();
+        }
         const id = this.onAction('start', performance.now(), actonType, idx, entrypointRef);
         try {
             const result = fn();
@@ -38,6 +45,12 @@ export class EventEmitter {
         this.onEntrypointEvent(sequenceId, performance.now(), event);
     }
     perf(method, fn) {
+        // Fast path: see action() above. perf() wraps ~28s of cumulative time
+        // in the production-path CPU profile; the wrapper overhead per call is
+        // small but everywhere.
+        if (!this.enabled) {
+            return fn();
+        }
         const spanId = this.perfSpanId;
         this.perfSpanId += 1;
         const startedAt = performance.now();

package/types/utils/applyOxcProcessors/applyOxcProcessors.d.ts

@@ -4,5 +4,6 @@ import { EventEmitter } from '../EventEmitter';
 import type { ApplyOxcProcessorsResult } from './types';
 export declare const applyOxcProcessors: (code: string, fileContext: IFileContext, options: Pick<StrictOptions, "classNameSlug" | "displayName" | "eval" | "extensions" | "staticBindings" | "tagResolver"> & {
     eventEmitter?: EventEmitter;
+    preserveSideEffectImportOrderLocals?: Set<string>;
     preserveSideEffectImportLocals?: Set<string>;
 }, callback: (processor: BaseProcessor) => void, cleanupUnused?: boolean) => ApplyOxcProcessorsResult;

package/types/utils/applyOxcProcessors/applyOxcProcessors.js

@@ -157,7 +157,9 @@ export const applyOxcProcessors = (code, fileContext, options, callback, cleanup
     const codeWithAddedImports = insertAddedImports(replacedCode, program, addedImports);
     return {
         code: cleanupUnused
-            ? eventEmitter.perf('transform:preeval:processTemplate:cleanup', () => removeUnusedAfterReplacement(codeWithAddedImports, filename, removableImportLocals, new Set([...removableExpressionRefs, ...extracted.dependencyNames]), options.preserveSideEffectImportLocals ?? new Set()))
+            ? eventEmitter.perf('transform:preeval:processTemplate:cleanup', () => removeUnusedAfterReplacement(codeWithAddedImports, filename, removableImportLocals, new Set([...removableExpressionRefs, ...extracted.dependencyNames]), options.preserveSideEffectImportLocals ?? new Set(), options.preserveSideEffectImportOrderLocals ??
+                options.preserveSideEffectImportLocals ??
+                new Set()))
             : codeWithAddedImports,
         processorClassNamesByLocal,
         processors,

package/types/utils/applyOxcProcessors/cleanupRemovals.d.ts

@@ -8,9 +8,9 @@ export declare function expandImportRemovalRange(code: string, start: number, en
 export declare const collectUnusedScopedDeclarationRemovals: (code: string, bindings: Map<string, ScopedBindingInfo>, initialRemovableNames: Set<string>) => Replacement[];
 export declare const expandImportSpecifierRemovalRange: (code: string, start: number, end: number) => Replacement;
 export declare const mergeEmptyRemovalRanges: (removals: Replacement[]) => Replacement[];
-export declare const collectUnusedImportRemovals: (code: string, program: Program, referencedNames: Set<string>, removableNames: Set<string>, preserveSideEffectImportLocals: Set<string>) => Replacement[];
+export declare const collectUnusedImportRemovals: (code: string, program: Program, referencedNames: Set<string>, removableNames: Set<string>, preserveSideEffectImportLocals: Set<string>, preserveSideEffectImportOrderLocals?: Set<string>) => Replacement[];
 export declare const collectUnusedTopLevelDeclarationRemovals: (code: string, program: Program, referencedNames: Set<string>, removableNames: Set<string>) => Replacement[];
 export declare const collectUnusedGeneratedHelperDeclarationRemovals: (code: string, program: Program, referencedNames: Set<string>) => Replacement[];
 export declare const collectTopLevelExpressionStatementRemovals: (code: string, statements: TopLevelStatementInfo[], topLevelBindings: Set<string>, removableExpressionRefs: Set<string>) => Replacement[];
 export declare const collectEmptyTopLevelBlockRemovals: (code: string, program: Program) => Replacement[];
-export declare const removeUnusedAfterReplacement: (code: string, filename: string, initialRemovableNames: Set<string>, removableExpressionRefs: Set<string>, preserveSideEffectImportLocals: Set<string>) => string;
+export declare const removeUnusedAfterReplacement: (code: string, filename: string, initialRemovableNames: Set<string>, removableExpressionRefs: Set<string>, preserveSideEffectImportLocals: Set<string>, preserveSideEffectImportOrderLocals?: Set<string>) => string;

package/types/utils/applyOxcProcessors/cleanupRemovals.js

@@ -335,28 +335,42 @@ export const mergeEmptyRemovalRanges = (removals) => {
     });
     return merged;
 };
-export const collectUnusedImportRemovals = (code, program, referencedNames, removableNames, preserveSideEffectImportLocals) => {
+export const collectUnusedImportRemovals = (code, program, referencedNames, removableNames, preserveSideEffectImportLocals, preserveSideEffectImportOrderLocals = preserveSideEffectImportLocals) => {
     const removals = [];
+    const importSourceByLocal = new Map();
+    const removedSideEffectImportRanges = [];
+    const keptImportRangesBySource = new Map();
     program.body.forEach((statement) => {
         if (statement.type !== 'ImportDeclaration') {
             return;
         }
         const localNames = collectImportLocalNames(statement);
+        const source = code.slice(statement.source.start, statement.source.end);
+        const orderedLocalNames = localNames.filter((localName) => preserveSideEffectImportOrderLocals.has(localName));
+        const sideEffectLocalNames = localNames.filter((localName) => preserveSideEffectImportLocals.has(localName));
+        [...orderedLocalNames, ...sideEffectLocalNames].forEach((localName) => {
+            importSourceByLocal.set(localName, source);
+        });
         const removableLocalNames = localNames.filter((localName) => removableNames.has(localName));
         if (removableLocalNames.length > 0 &&
             removableLocalNames.length === localNames.length &&
             removableLocalNames.every((localName) => !referencedNames.has(localName))) {
             if (removableLocalNames.some((localName) => preserveSideEffectImportLocals.has(localName))) {
-                removals.push({
+                removedSideEffectImportRanges.push({
                     end: statement.end,
                     start: statement.start,
-                    value: `import ${code.slice(statement.source.start, statement.source.end)};`,
                 });
                 return;
             }
             removals.push(expandImportRemovalRange(code, statement.start, statement.end));
             return;
         }
+        if (orderedLocalNames.length > 0 && !keptImportRangesBySource.has(source)) {
+            keptImportRangesBySource.set(source, {
+                end: statement.end,
+                start: statement.start,
+            });
+        }
         const { specifiers } = statement;
         if (!Array.isArray(specifiers) || specifiers.length <= 1) {
             return;
@@ -373,6 +387,67 @@ export const collectUnusedImportRemovals = (code, program, referencedNames, remo
             }
         });
     });
+    if (removedSideEffectImportRanges.length > 0) {
+        const seenSources = new Set();
+        const removedRanges = removedSideEffectImportRanges.sort((a, b) => a.start - b.start);
+        const [firstRemoved, ...restRemoved] = removedRanges;
+        const pendingImports = [];
+        let insertionAfterLastKept = null;
+        let usedFirstRemovedRange = false;
+        const flushBefore = (position) => {
+            if (pendingImports.length === 0) {
+                return;
+            }
+            removals.push({
+                end: position,
+                start: position,
+                value: `${pendingImports.join('\n')}\n`,
+            });
+            pendingImports.length = 0;
+        };
+        [...preserveSideEffectImportOrderLocals].forEach((localName) => {
+            const source = importSourceByLocal.get(localName);
+            if (!source) {
+                return;
+            }
+            const keptRange = keptImportRangesBySource.get(source);
+            if (keptRange) {
+                flushBefore(keptRange.start);
+                insertionAfterLastKept = keptRange.end;
+                if (preserveSideEffectImportLocals.has(localName)) {
+                    seenSources.add(source);
+                }
+                return;
+            }
+            if (!preserveSideEffectImportLocals.has(localName) ||
+                seenSources.has(source)) {
+                return;
+            }
+            seenSources.add(source);
+            pendingImports.push(`import ${source};`);
+        });
+        if (pendingImports.length > 0) {
+            if (insertionAfterLastKept !== null) {
+                removals.push({
+                    end: insertionAfterLastKept,
+                    start: insertionAfterLastKept,
+                    value: `\n${pendingImports.join('\n')}`,
+                });
+            }
+            else if (firstRemoved) {
+                usedFirstRemovedRange = true;
+                removals.push({
+                    end: firstRemoved.end,
+                    start: firstRemoved.start,
+                    value: pendingImports.join('\n'),
+                });
+            }
+        }
+        removals.push(...(usedFirstRemovedRange ? restRemoved : removedRanges).map((range) => ({
+            ...range,
+            value: '',
+        })));
+    }
     return removals;
 };
 export const collectUnusedTopLevelDeclarationRemovals = (code, program, referencedNames, removableNames) => {
@@ -441,21 +516,20 @@ export const collectEmptyTopLevelBlockRemovals = (code, program) => {
     });
     return removals;
 };
-export const removeUnusedAfterReplacement = (code, filename, initialRemovableNames, removableExpressionRefs, preserveSideEffectImportLocals) => {
+export const removeUnusedAfterReplacement = (code, filename, initialRemovableNames, removableExpressionRefs, preserveSideEffectImportLocals, preserveSideEffectImportOrderLocals = preserveSideEffectImportLocals) => {
     let current = code;
+    let program = null;
     const cumulativeRemovableNames = new Set(initialRemovableNames);
-    const applyIfParsable = (next) => {
-        try {
-            parseOxc(next, filename);
-            return next;
-        }
-        catch {
-            return current;
-        }
-    };
+    // Incremental cleanup loop: validate-by-parsing the next iteration's
+    // candidate code AND reuse that parse as the next iter's `program` input,
+    // instead of re-parsing at the top of the next iter. Saves one parse per
+    // loop revolution (N+1 parses for an N-iter loop instead of 2N).
+    // Also short-circuits a round earlier when no removals were collected.
     for (let idx = 0; idx < 5; idx += 1) {
         const previous = current;
-        const program = parseOxc(current, filename);
+        if (program === null) {
+            program = parseOxc(current, filename);
+        }
         const statements = collectTopLevelStatementInfos(program);
         const removableNames = collectRemovableNamesFromStatements(statements, cumulativeRemovableNames);
         removableNames.forEach((name) => cumulativeRemovableNames.add(name));
@@ -466,14 +540,25 @@ export const removeUnusedAfterReplacement = (code, filename, initialRemovableNam
             ...collectUnusedScopedDeclarationRemovals(current, scopedBindings, cumulativeRemovableNames),
             ...collectUnusedTopLevelDeclarationRemovals(current, program, referencedNames, cumulativeRemovableNames),
             ...collectUnusedGeneratedHelperDeclarationRemovals(current, program, referencedNames),
-            ...collectUnusedImportRemovals(current, program, referencedNames, cumulativeRemovableNames, preserveSideEffectImportLocals),
+            ...collectUnusedImportRemovals(current, program, referencedNames, cumulativeRemovableNames, preserveSideEffectImportLocals, preserveSideEffectImportOrderLocals),
             ...collectTopLevelExpressionStatementRemovals(current, statements, topLevelBindings, removableExpressionRefs),
             ...collectEmptyTopLevelBlockRemovals(current, program),
         ]);
-        current =
-            removals.length > 0
-                ? applyIfParsable(applyOxcReplacements(current, removals))
-                : current;
+        if (removals.length === 0) {
+            // Convergence: next iter would parse the same code and see the same
+            // removable set. Skip the round of walks + parse.
+            return current;
+        }
+        const next = applyOxcReplacements(current, removals);
+        try {
+            // Validate + capture the AST for the next iteration in one parse.
+            program = parseOxc(next, filename);
+            current = next;
+        }
+        catch {
+            // Pathological removal — drop this iteration and return prior state.
+            return current;
+        }
         if (current === previous) {
             return current;
         }

package/types/utils/collectOxcExportsAndImports.js

@@ -894,6 +894,14 @@ const getChildren = (node) => {
     return result;
 };
 const precollectRequireSources = (node, state) => {
+    // Cheap text precheck at the Program entry: if the file body has no
+    // 'require(' substring there can be no CommonJS require() init to collect.
+    // Skip the full AST walk — meaningful saving on ESM-only modules in large
+    // monorepos. Done at Program-level only so nested recursion doesn't pay
+    // the indexOf cost per node.
+    if (node.type === 'Program' && state.code.indexOf('require(') === -1) {
+        return;
+    }
     if (node.type === 'VariableDeclarator' && node.id.type === 'Identifier') {
         const source = node.init ? sourceFromRequireSyntax(node.init) : null;
         if (source) {

package/types/utils/collectOxcRuntime/types.d.ts

@@ -2,6 +2,7 @@ import type { StrictOptions } from '@wyw-in-js/shared';
 import type { RawSourceMap } from 'source-map';
 import type { WYWTransformMetadata } from '../TransformMetadata';
 export type OxcCollectOptions = Pick<StrictOptions, 'classNameSlug' | 'displayName' | 'eval' | 'extensions' | 'tagResolver' | 'variableNameConfig'> & {
+    preserveSideEffectImportOrderLocals?: Set<string>;
     preserveSideEffectImportLocals?: Set<string>;
 };
 export type OxcCollectResult = {

package/types/utils/collectOxcTemplateDependencies/expressionExtraction.js

@@ -326,10 +326,12 @@ const extractExpression = (expression, ctx, evaluate) => {
         else {
             hasNonStaticLocalReference = true;
         }
-        assertHoistable(binding, ctx);
-        addHoistedDeclaration(binding, ctx);
-        if (!binding.isRoot && binding.declarator?.id.type === 'Identifier') {
-            identifierReplacements.set(name, getHoistedBindingName(binding, ctx));
+        if (!isProcessorManagedLocal) {
+            assertHoistable(binding, ctx);
+            addHoistedDeclaration(binding, ctx);
+            if (!binding.isRoot && binding.declarator?.id.type === 'Identifier') {
+                identifierReplacements.set(name, getHoistedBindingName(binding, ctx));
+            }
         }
     });
     // Merge literal-const inlines (e.g. `const A = 32` -> "32") with

package/types/utils/oxc/ast.js

@@ -2,36 +2,60 @@ export const isOxcNode = (value) => !!value &&
     typeof value === 'object' &&
     'type' in value &&
     typeof value.type === 'string';
+// Cache visitor-key lists per node.type. oxc-parser AST nodes have a stable
+// shape per `type` — optional children are present as null/undefined, not
+// omitted — so Object.keys() returns the same key set for every instance of
+// the same kind. First instance pays the discovery cost; the rest do an
+// indexed lookup. getOxcNodeChildren is invoked tens of millions of times
+// on a cold build of a large monorepo, so this matters a lot.
+//
+// An instance-level WeakMap cache of the resulting Node[] was tried and
+// regressed wall time ~20% (WeakMap.get/set per call beat the recompute
+// savings for small children arrays + pinned arrays into older generations
+// and increased GC pressure). Per-type key cache only.
+const META_KEYS = new Set([
+    'comments',
+    'end',
+    'errors',
+    'parent',
+    'range',
+    'span',
+    'start',
+    'type',
+]);
+const VISITOR_KEYS_BY_TYPE = new Map();
+const visitorKeysFor = (node) => {
+    let keys = VISITOR_KEYS_BY_TYPE.get(node.type);
+    if (keys === undefined) {
+        keys = Object.keys(node).filter((key) => !META_KEYS.has(key));
+        VISITOR_KEYS_BY_TYPE.set(node.type, keys);
+    }
+    return keys;
+};
 export const getOxcNodeChildren = (node) => {
     const result = [];
     const record = node;
-    Object.keys(record).forEach((key) => {
-        if (key === 'comments' ||
-            key === 'end' ||
-            key === 'errors' ||
-            key === 'parent' ||
-            key === 'range' ||
-            key === 'span' ||
-            key === 'start' ||
-            key === 'type') {
-            return;
-        }
-        const value = record[key];
+    const keys = visitorKeysFor(record);
+    for (let i = 0; i < keys.length; i += 1) {
+        const value = record[keys[i]];
         if (isOxcNode(value)) {
             result.push(value);
-            return;
         }
-        if (Array.isArray(value)) {
-            value.forEach((item) => {
+        else if (Array.isArray(value)) {
+            for (let j = 0; j < value.length; j += 1) {
+                const item = value[j];
                 if (isOxcNode(item)) {
                     result.push(item);
                 }
-            });
+            }
         }
-    });
+    }
     return result;
 };
 export const walkOxc = (node, enter, parent = null) => {
     enter(node, parent);
-    getOxcNodeChildren(node).forEach((child) => walkOxc(child, enter, node));
+    const children = getOxcNodeChildren(node);
+    for (let i = 0; i < children.length; i += 1) {
+        walkOxc(children[i], enter, node);
+    }
 };

package/types/utils/oxcPreevalTransforms.js

@@ -1,6 +1,7 @@
 /* eslint-disable no-restricted-syntax,no-continue */
 import { collectOxcExportsAndImports } from './collectOxcExportsAndImports';
 import { EventEmitter } from './EventEmitter';
+import { getOxcNodeChildren } from './oxc/ast';
 import { parseOxcProgramCached } from './parseOxc';
 const ssrCheckFields = new Set([
     'document',
@@ -104,28 +105,11 @@ const isNode = (value) => !!value &&
     typeof value === 'object' &&
     'type' in value &&
     typeof value.type === 'string';
-const getChildren = (node) => {
-    const result = [];
-    const record = node;
-    Object.keys(record).forEach((key) => {
-        if (key === 'type' || key === 'start' || key === 'end' || key === 'range') {
-            return;
-        }
-        const value = record[key];
-        if (isNode(value)) {
-            result.push(value);
-            return;
-        }
-        if (Array.isArray(value)) {
-            value.forEach((item) => {
-                if (isNode(item)) {
-                    result.push(item);
-                }
-            });
-        }
-    });
-    return result;
-};
+// Reuses the per-node.type visitor-key cache in utils/oxc/ast.ts. This file's
+// getChildren shape historically diverged from the canonical one (a smaller
+// metadata-key skip set), but the produced children list is identical in
+// practice because oxc-parser nodes don't carry the extra metadata fields.
+const getChildren = getOxcNodeChildren;
 const parseOxc = (code, filename) => {
     return parseOxcProgramCached(filename, code, 'unambiguous');
 };
@@ -348,66 +332,95 @@ const predeclareScopeNames = (node, scope) => {
         });
     }
     const visitScopeDescendants = (child) => {
-        if (child.type === 'VariableDeclarator') {
-            collectBindingNames(child.id).forEach((name) => {
-                scope.names.add(name);
-            });
-        }
-        else if (child.type === 'FunctionDeclaration' && child.id) {
-            scope.names.add(child.id.name);
-        }
-        else if (child.type === 'ClassDeclaration' && child.id) {
-            scope.names.add(child.id.name);
-        }
-        else if (child.type === 'ImportDefaultSpecifier' ||
-            child.type === 'ImportNamespaceSpecifier' ||
-            child.type === 'ImportSpecifier') {
-            scope.names.add(child.local.name);
+        switch (child.type) {
+            case 'VariableDeclarator': {
+                const names = collectBindingNames(child.id);
+                for (let i = 0; i < names.length; i += 1) {
+                    scope.names.add(names[i]);
+                }
+                break;
+            }
+            case 'FunctionDeclaration':
+            case 'ClassDeclaration':
+                if (child.id) {
+                    scope.names.add(child.id.name);
+                }
+                break;
+            case 'ImportDefaultSpecifier':
+            case 'ImportNamespaceSpecifier':
+            case 'ImportSpecifier':
+                scope.names.add(child.local.name);
+                break;
+            default:
+                break;
         }
         if (createsScope(child)) {
             return;
         }
-        getChildren(child).forEach(visitScopeDescendants);
+        const children = getChildren(child);
+        for (let i = 0; i < children.length; i += 1) {
+            visitScopeDescendants(children[i]);
+        }
     };
-    getChildren(node).forEach(visitScopeDescendants);
+    const rootChildren = getChildren(node);
+    for (let i = 0; i < rootChildren.length; i += 1) {
+        visitScopeDescendants(rootChildren[i]);
+    }
 };
 const declareBindings = (node, scope) => {
-    if (node.type === 'VariableDeclarator') {
-        const names = collectBindingNames(node.id);
-        names.forEach((name) => {
-            scope.names.add(name);
-            scope.bindings.set(name, null);
-        });
-        if (node.id.type === 'Identifier' && node.init) {
-            scope.bindings.set(node.id.name, node.init);
-        }
-        return;
-    }
-    if (node.type === 'FunctionDeclaration' && node.id) {
-        scope.names.add(node.id.name);
-        scope.bindings.set(node.id.name, null);
-    }
-    if (node.type === 'ClassDeclaration' && node.id) {
-        scope.names.add(node.id.name);
-        scope.bindings.set(node.id.name, null);
-        return;
-    }
-    if (node.type === 'ImportDefaultSpecifier' ||
-        node.type === 'ImportNamespaceSpecifier' ||
-        node.type === 'ImportSpecifier') {
-        scope.names.add(node.local.name);
-        scope.bindings.set(node.local.name, null);
-        return;
-    }
-    if (node.type === 'FunctionDeclaration' ||
-        node.type === 'FunctionExpression' ||
-        node.type === 'ArrowFunctionExpression') {
-        node.params.forEach((param) => {
-            collectBindingNames(param).forEach((name) => {
+    // Called for every visited AST node, so the dispatch is hot. A switch lets
+    // V8 generate a jump table on node.type; the previous chained `if`s walked
+    // each branch's string-compare for every non-matching node.
+    switch (node.type) {
+        case 'VariableDeclarator': {
+            const names = collectBindingNames(node.id);
+            for (let i = 0; i < names.length; i += 1) {
+                const name = names[i];
                 scope.names.add(name);
                 scope.bindings.set(name, null);
-            });
-        });
+            }
+            if (node.id.type === 'Identifier' && node.init) {
+                scope.bindings.set(node.id.name, node.init);
+            }
+            return;
+        }
+        case 'ClassDeclaration': {
+            if (node.id) {
+                scope.names.add(node.id.name);
+                scope.bindings.set(node.id.name, null);
+            }
+            return;
+        }
+        case 'ImportDefaultSpecifier':
+        case 'ImportNamespaceSpecifier':
+        case 'ImportSpecifier': {
+            scope.names.add(node.local.name);
+            scope.bindings.set(node.local.name, null);
+            return;
+        }
+        case 'FunctionDeclaration': {
+            if (node.id) {
+                scope.names.add(node.id.name);
+                scope.bindings.set(node.id.name, null);
+            }
+            // Fall through to declare params.
+        }
+        // eslint-disable-next-line no-fallthrough
+        case 'FunctionExpression':
+        case 'ArrowFunctionExpression': {
+            const { params } = node;
+            for (let i = 0; i < params.length; i += 1) {
+                const names = collectBindingNames(params[i]);
+                for (let j = 0; j < names.length; j += 1) {
+                    const name = names[j];
+                    scope.names.add(name);
+                    scope.bindings.set(name, null);
+                }
+            }
+            break;
+        }
+        default:
+            break;
     }
 };
 const visit = (node, scope, enter, parent = null, ancestors = []) => {
@@ -418,7 +431,17 @@ const visit = (node, scope, enter, parent = null, ancestors = []) => {
     }
     declareBindings(node, currentScope);
     enter(node, currentScope, parent, ancestors);
-    getChildren(node).forEach((child) => visit(child, currentScope, enter, node, [...ancestors, node]));
+    // Push onto a shared ancestors stack instead of allocating `[...ancestors,
+    // node]` per child step (O(n × depth) extra allocation on deep ASTs).
+    // Every consumer of `ancestors` in this file reads it synchronously inside
+    // the enter callback; future callers that need to retain the reference
+    // must .slice() it themselves.
+    ancestors.push(node);
+    const children = getChildren(node);
+    for (let i = 0; i < children.length; i += 1) {
+        visit(children[i], currentScope, enter, node, ancestors);
+    }
+    ancestors.pop();
 };
 export const replaceImportMetaEnvWithOxc = (code, filename) => {
     if (!importMetaEnvRe.test(code)) {

package/types/utils/parseOxc.js

@@ -1,5 +1,10 @@
 import { parseSync } from 'oxc-parser';
-const MAX_PARSE_CACHE_ENTRIES = 200;
+// 200 evicts under sustained pressure on large monorepos — the
+// removeUnusedAfterReplacement cleanup loop reparses on every iteration
+// (new content -> new key) and applyOxcProcessors reparses after extraction.
+// 1000 is still bounded (~50-100 MB worst case for an enormous build) and
+// keeps every entry hot across the actions for a single file.
+const MAX_PARSE_CACHE_ENTRIES = 1000;
 const parseCache = new Map();
 const getAstType = (filename) => filename.endsWith('.ts') || filename.endsWith('.tsx') ? 'ts' : 'js';
 const makeCacheKey = (filename, code, sourceType) => `${sourceType}\0${filename}\0${code}`;