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

package/types/module.d.ts

@@ -34,6 +34,9 @@ type ResolvedImport = {
     only: string[];
     external?: boolean;
 };
+type NativeFallbackOptions = {
+    warnOnFallback: boolean;
+};
 export declare class Module {
     #private;
     private services;
@@ -84,7 +87,7 @@ export declare class Module {
     private applyImportOverrides;
     private getModuleForResolved;
     private resolveWithConditions;
-    resolveWithNodeFallback: (id: string, importer: Entrypoint | IEvaluatedEntrypoint, kind: EvalResolverKind) => ResolvedImport;
+    resolveWithNativeFallback: (id: string, importer: Entrypoint | IEvaluatedEntrypoint, kind: EvalResolverKind, { warnOnFallback }?: NativeFallbackOptions) => ResolvedImport;
     private requireWithFallback;
     protected createChild(entrypoint: Entrypoint): Module;
     private loadByImportLoaders;

package/types/module.js

@@ -22,6 +22,7 @@ import { Entrypoint } from './transform/Entrypoint';
 import { getStack, isSuperSet, mergeOnly, } from './transform/Entrypoint.helpers';
 import { isUnprocessedEntrypointError } from './transform/actions/UnprocessedEntrypointError';
 import { applyImportOverrideToOnly, getImportOverride, resolveMockSpecifier, toImportKey, } from './utils/importOverrides';
+import { resolveWithNativeResolver } from './utils/nativeResolver';
 import { parseRequest, stripQueryAndHash } from './utils/parseRequest';
 import { resolveFilenameWithConditions } from './utils/resolveWithConditions';
 import { createVmContext } from './vm/createVmContext';
@@ -93,7 +94,7 @@ const nodeRequire = createRequire(import.meta.url);
 const NOOP = () => { };
 const TROUBLESHOOTING_URL = 'https://wyw-in-js.dev/troubleshooting';
 const defaultEvalOptions = {
-    mode: 'strict',
+    errors: 'strict',
     require: 'warn-and-run',
     resolver: 'bundler',
 };
@@ -551,7 +552,7 @@ export class Module {
         const resolved = await this.resolveImport(specifier, importer, kind);
         const evalOptions = getEvalOptions(this.services);
         if (!resolved) {
-            if (evalOptions.mode === 'loose') {
+            if (evalOptions.errors === 'loose') {
                 return this.createSyntheticModule(specifier, { default: undefined });
             }
             throw new Error([
@@ -585,7 +586,7 @@ export class Module {
                 return null;
             }
         }
-        if (evalOptions.resolver !== 'node') {
+        const resolveBundlerDependency = () => {
             const dependency = getImporterDependency(importer, specifier);
             if (dependency?.resolved) {
                 return {
@@ -594,9 +595,34 @@ export class Module {
                     only: dependency.only,
                 };
             }
+            return null;
+        };
+        if (evalOptions.resolver === 'hybrid') {
+            try {
+                return this.resolveWithNativeFallback(specifier, importer, kind, {
+                    warnOnFallback: false,
+                });
+            }
+            catch {
+                // Hybrid mode lets the bundler resolver handle aliases, virtual IDs,
+                // and other specifiers that the native resolver cannot resolve.
+            }
+        }
+        if (evalOptions.resolver === 'native') {
+            return this.resolveWithNativeFallback(specifier, importer, kind, {
+                warnOnFallback: false,
+            });
         }
-        if (evalOptions.resolver === 'node' || evalOptions.require !== 'off') {
-            return this.resolveWithNodeFallback(specifier, importer, kind);
+        if (evalOptions.resolver === 'bundler' ||
+            evalOptions.resolver === 'hybrid') {
+            const dependency = resolveBundlerDependency();
+            if (dependency)
+                return dependency;
+        }
+        if (evalOptions.resolver === 'bundler' && evalOptions.require !== 'off') {
+            return this.resolveWithNativeFallback(specifier, importer, kind, {
+                warnOnFallback: true,
+            });
         }
         return null;
     }
@@ -609,7 +635,9 @@ export class Module {
                 only: dependency.only,
             }, importer);
         }
-        return this.resolveWithNodeFallback(specifier, importer, 'require');
+        return this.resolveWithNativeFallback(specifier, importer, 'require', {
+            warnOnFallback: true,
+        });
     }
     applyImportOverrides(resolved, importer) {
         const { root } = this.services.options;
@@ -706,48 +734,65 @@ export class Module {
             throw error;
         }
     }
-    resolveWithNodeFallback = (id, importer, kind) => {
-        if (!this.ignored) {
-            this.debug('❌ import has not been resolved during prepare stage. Fallback to Node.js resolver');
+    resolveWithNativeFallback = (id, importer, kind, { warnOnFallback } = { warnOnFallback: true }) => {
+        if (!this.ignored && warnOnFallback) {
+            this.debug('❌ import has not been resolved during prepare stage. Fallback to native resolver');
         }
         const extensions = this.moduleImpl._extensions;
         const added = [];
         try {
-            // Check for supported extensions
-            this.extensions.forEach((ext) => {
-                if (ext === '.cjs' || ext === '.mjs') {
-                    return;
-                }
-                if (ext in extensions) {
-                    return;
-                }
-                // When an extension is not supported, add it
-                // And keep track of it to clean it up after resolving
-                // Use noop for the transform function since we handle it
-                extensions[ext] = NOOP;
-                added.push(ext);
-            });
             const filename = importer.name;
             const strippedId = stripQueryAndHash(id);
-            const parent = {
-                id: filename,
-                filename,
-                paths: this.moduleImpl._nodeModulePaths(path.dirname(filename)),
-            };
-            const { conditionNames } = this.services.options.pluginOptions;
-            const conditions = conditionNames?.length
-                ? expandConditions(conditionNames)
-                : undefined;
-            let resolved = this.resolveWithConditions(strippedId, parent, conditions);
-            const isFileSpecifier = strippedId.startsWith('.') || path.isAbsolute(strippedId);
-            if (isFileSpecifier &&
-                path.extname(strippedId) === '' &&
-                resolved.endsWith('.cjs') &&
-                fs.existsSync(`${resolved.slice(0, -4)}.js`)) {
-                // When both `.cjs` and `.js` exist for an extensionless specifier, the
-                // resolver may pick `.cjs` depending on the environment/extensions.
-                // Prefer `.js` to keep resolved paths stable (e.g. importOverrides keys).
-                resolved = `${resolved.slice(0, -4)}.js`;
+            const { conditionNames, oxcOptions } = this.services.options.pluginOptions;
+            let resolved;
+            try {
+                if (this.moduleImpl === DefaultModuleImplementation) {
+                    resolved = resolveWithNativeResolver({
+                        conditionNames,
+                        extensions: this.extensions,
+                        importer: filename,
+                        kind,
+                        oxcOptions,
+                        specifier: id,
+                    });
+                }
+                else {
+                    // Preserve the test-only custom module implementation hook.
+                    this.extensions.forEach((ext) => {
+                        if (ext === '.cjs' || ext === '.mjs')
+                            return;
+                        if (ext in extensions)
+                            return;
+                        extensions[ext] = NOOP;
+                        added.push(ext);
+                    });
+                    const parent = {
+                        id: filename,
+                        filename,
+                        paths: this.moduleImpl._nodeModulePaths(path.dirname(filename)),
+                    };
+                    const conditions = conditionNames?.length
+                        ? expandConditions(conditionNames)
+                        : undefined;
+                    resolved = this.resolveWithConditions(strippedId, parent, conditions);
+                    const isFileSpecifier = strippedId.startsWith('.') || path.isAbsolute(strippedId);
+                    if (isFileSpecifier &&
+                        path.extname(strippedId) === '' &&
+                        resolved.endsWith('.cjs') &&
+                        fs.existsSync(`${resolved.slice(0, -4)}.js`)) {
+                        resolved = `${resolved.slice(0, -4)}.js`;
+                    }
+                }
+            }
+            catch (error) {
+                throw new Error([
+                    `[wyw-in-js] Native resolver failed during eval.`,
+                    ``,
+                    `importer: ${filename}`,
+                    `source:   ${id}`,
+                    ``,
+                    `error: ${error instanceof Error ? error.message : String(error)}`,
+                ].join('\n'));
             }
             const { root } = this.services.options;
             const keyInfo = toImportKey({
@@ -758,8 +803,12 @@ export class Module {
             const override = getImportOverride(this.services.options.pluginOptions.importOverrides, keyInfo.key);
             const evalOptions = getEvalOptions(this.services);
             const basePolicy = evalOptions.require === 'warn-and-run' ? 'warn' : 'error';
-            let policy = override?.unknown ?? (override?.mock ? 'allow' : basePolicy);
-            if (evalOptions.require === 'off' && policy !== 'error') {
+            let policy = warnOnFallback
+                ? override?.unknown ?? (override?.mock ? 'allow' : basePolicy)
+                : 'allow';
+            if (warnOnFallback &&
+                evalOptions.require === 'off' &&
+                policy !== 'error') {
                 policy = 'error';
             }
             const shouldWarn = !this.ignored && policy === 'warn';
@@ -780,7 +829,7 @@ export class Module {
             }
             if (policy === 'error') {
                 throw new Error([
-                    `[wyw-in-js] Unknown import reached during eval (Node resolver fallback)`,
+                    `[wyw-in-js] Unknown import reached during eval (native resolver fallback)`,
                     ``,
                     `importer: ${filename}`,
                     `source:   ${id}`,
@@ -802,7 +851,7 @@ export class Module {
             if (shouldWarn && !warnedUnknownImports.has(keyInfo.key)) {
                 warnedUnknownImports.add(keyInfo.key);
                 const warningMessage = [
-                    `[wyw-in-js] Unknown import reached during eval (Node resolver fallback)`,
+                    `[wyw-in-js] Unknown import reached during eval (native resolver fallback)`,
                     ``,
                     `importer: ${filename}`,
                     `source:   ${id}`,
@@ -844,14 +893,14 @@ export class Module {
     requireWithFallback(id, importer, nonLiteral = false) {
         const evalOptions = getEvalOptions(this.services);
         if (nonLiteral || typeof id !== 'string') {
-            if (evalOptions.mode === 'strict') {
+            if (evalOptions.errors === 'strict') {
                 throw new Error(`[wyw-in-js] Non-literal require() is not supported during eval.\n` +
                     `importer: ${importer.name}\n` +
                     `hint: make it a string literal or mock the import via importOverrides.`);
             }
             emitEvalWarning(this.services, {
                 code: 'require-error',
-                message: '[wyw-in-js] Non-literal require() reached during eval (loose mode).',
+                message: '[wyw-in-js] Non-literal require() reached during eval (eval.errors: "loose").',
                 importer: importer.name,
             });
             return {};

package/types/transform/Entrypoint.types.d.ts

@@ -26,10 +26,13 @@ export interface IPreevalResult {
     dependencyNames?: string[];
     evalCode?: string;
     metadata: WYWTransformMetadata | null;
+    processorClassNames?: Record<string, string>;
     staticSideEffectImportLocals?: string[];
     staticDependencies?: string[];
     staticNullWYWMetaExtendsHelpers?: string[];
+    staticValuesApplied?: boolean;
     staticValueCache?: Map<string, unknown>;
+    runtimeOnlyStaticValueNames?: string[];
     staticValueCandidates?: Array<{
         imports: Array<{
             imported: 'default' | string;

package/types/transform/generators/resolveImports.d.ts

@@ -1,4 +1,5 @@
 import type { AsyncScenarioForAction, IResolveImportsAction, SyncScenarioForAction } from '../types';
+type AsyncResolve = (what: string, importer: string, stack: string[]) => Promise<string | null>;
 /**
  * Synchronously resolves specified imports with a provided resolver.
  */
@@ -6,4 +7,5 @@ export declare function syncResolveImports(this: IResolveImportsAction, resolve:
 /**
  * Asynchronously resolves specified imports with a provided resolver.
  */
-export declare function asyncResolveImports(this: IResolveImportsAction, resolve: (what: string, importer: string, stack: string[]) => Promise<string | null>): AsyncScenarioForAction<IResolveImportsAction>;
+export declare function asyncResolveImports(this: IResolveImportsAction, resolve: AsyncResolve): AsyncScenarioForAction<IResolveImportsAction>;
+export {};

package/types/transform/generators/resolveImports.js

@@ -1,7 +1,54 @@
-/* eslint-disable no-continue,no-await-in-loop,require-yield */
 import { getFileIdx } from '../../utils/getFileIdx';
 import { getStack, isSuperSet, mergeOnly } from '../Entrypoint.helpers';
 import { applyImportOverrideToOnly, getImportOverride, resolveMockSpecifier, toImportKey, } from '../../utils/importOverrides';
+import { resolveWithNativeResolver } from '../../utils/nativeResolver';
+const DEFAULT_EVAL_OPTIONS = {
+    errors: 'strict',
+    require: 'warn-and-run',
+    resolver: 'bundler',
+};
+const getEvalOptions = (services) => ({
+    ...DEFAULT_EVAL_OPTIONS,
+    ...(services.options.pluginOptions.eval ?? {}),
+});
+const resolveWithConfiguredEvalResolver = async (services, source, importer, stack, resolve) => {
+    const evalOptions = getEvalOptions(services);
+    if (evalOptions.customResolver) {
+        const customResolved = await evalOptions.customResolver(source, importer, 'import');
+        if (customResolved) {
+            return customResolved.external ? null : customResolved.id;
+        }
+        if (evalOptions.resolver === 'custom') {
+            return null;
+        }
+    }
+    if (evalOptions.resolver === 'hybrid') {
+        try {
+            return resolveWithNativeResolver({
+                conditionNames: services.options.pluginOptions.conditionNames,
+                extensions: services.options.pluginOptions.extensions,
+                importer,
+                kind: 'import',
+                oxcOptions: services.options.pluginOptions.oxcOptions,
+                specifier: source,
+            });
+        }
+        catch {
+            return resolve(source, importer, stack);
+        }
+    }
+    if (evalOptions.resolver === 'native') {
+        return resolveWithNativeResolver({
+            conditionNames: services.options.pluginOptions.conditionNames,
+            extensions: services.options.pluginOptions.extensions,
+            importer,
+            kind: 'import',
+            oxcOptions: services.options.pluginOptions.oxcOptions,
+            specifier: source,
+        });
+    }
+    return resolve(source, importer, stack);
+};
 function applyImportOverrides(services, entrypoint, resolvedImports) {
     const overrides = services.options.pluginOptions.importOverrides;
     if (!overrides || Object.keys(overrides).length === 0) {
@@ -120,7 +167,7 @@ export async function* asyncResolveImports(resolve) {
     const getResolveTask = async (source, only) => {
         let resolved = null;
         try {
-            resolved = await resolve(source, entrypoint.name, getStack(entrypoint));
+            resolved = await resolveWithConfiguredEvalResolver(this.services, source, entrypoint.name, getStack(entrypoint), resolve);
         }
         catch (err) {
             log('[async-resolve] ❌ cannot resolve %s in %s: %O', source, entrypoint.name, err);

package/types/transform/generators/resolveStaticOxcValues/cache.d.ts

@@ -0,0 +1,25 @@
+import { runOxcPreevalStage } from '../../../utils/oxcPreevalStage';
+import type { ITransformAction } from '../../types';
+import type { StaticExportCacheEntry, StaticExportResult, StaticFileAnalysis, StaticFileHashCacheEntry, StaticMetadataPreevalCacheEntry } from './types';
+export declare const staticFileAnalysisCaches: WeakMap<object, Map<string, StaticFileAnalysis>>;
+export declare const staticFileHashCaches: WeakMap<object, Map<string, StaticFileHashCacheEntry>>;
+export declare const staticExportResultCaches: WeakMap<object, Map<string, StaticExportCacheEntry>>;
+export declare const staticMetadataPreevalCaches: WeakMap<object, Map<string, StaticMetadataPreevalCacheEntry>>;
+export declare const hashStaticContent: (content: string | Buffer) => string;
+export declare const getWeakCacheMap: <TValue>(caches: WeakMap<object, Map<string, TValue>>, key: object) => Map<string, TValue>;
+export declare const isStaticResolveCacheEnabled: () => boolean;
+export declare const staticCachePrefix: (action: ITransformAction) => string;
+export declare const staticFileAnalysisCache: (action: ITransformAction) => Map<string, StaticFileAnalysis>;
+export declare const staticFileHashCache: (action: ITransformAction) => Map<string, StaticFileHashCacheEntry>;
+export declare const staticExportResultCache: (action: ITransformAction) => Map<string, StaticExportCacheEntry>;
+export declare const staticMetadataPreevalCache: (action: ITransformAction) => Map<string, StaticMetadataPreevalCacheEntry>;
+export declare const staticFileAnalysisCacheKey: (action: ITransformAction, filename: string, codeHash: string) => string;
+export declare const staticExportCacheKey: (action: ITransformAction, filename: string, exportedName: string, codeHash: string) => string;
+export declare const staticMetadataPreevalCacheKey: (action: ITransformAction, filename: string, codeHash: string) => string;
+export declare const getStaticFileContentHash: (action: ITransformAction, dependency: string) => string | null;
+export declare const collectStaticDependencyHashes: (action: ITransformAction, dependencies: string[]) => Map<string, string> | null;
+export declare const areStaticDependencyHashesCurrent: (action: ITransformAction, dependencyHashes: Map<string, string>) => boolean;
+export declare const getStaticExportCachedResult: (action: ITransformAction, filename: string, exportedName: string, codeHash: string) => StaticExportResult | null | undefined;
+export declare const setStaticExportCachedResult: (action: ITransformAction, filename: string, exportedName: string, codeHash: string, result: StaticExportResult | null) => void;
+export declare const getStaticFileAnalysis: (action: ITransformAction, filename: string) => StaticFileAnalysis | null;
+export declare const getStaticMetadataPreevalResult: (action: ITransformAction, filename: string, code: string, codeHash: string) => ReturnType<typeof runOxcPreevalStage> | null;

package/types/transform/generators/resolveStaticOxcValues/cache.js

@@ -0,0 +1,182 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { createHash } from 'crypto';
+import { readFileSync, statSync } from 'fs';
+import { isAbsolute } from 'path';
+import { oxcShaker } from '../../../shaker';
+import { runOxcPreevalStage } from '../../../utils/oxcPreevalStage';
+import { stripQueryAndHash } from '../../../utils/parseRequest';
+import { isEnvDisabled, parseProgram } from './environment';
+import { STATIC_EXPORT_MAX_NULL_ATTEMPTS } from './types';
+export const staticFileAnalysisCaches = new WeakMap();
+export const staticFileHashCaches = new WeakMap();
+export const staticExportResultCaches = new WeakMap();
+export const staticMetadataPreevalCaches = new WeakMap();
+export const hashStaticContent = (content) => createHash('sha256').update(content).digest('hex');
+export const getWeakCacheMap = (caches, key) => {
+    let cache = caches.get(key);
+    if (!cache) {
+        cache = new Map();
+        caches.set(key, cache);
+    }
+    return cache;
+};
+export const isStaticResolveCacheEnabled = () => {
+    const envValue = process.env.WYW_STATIC_RESOLVE_CACHE?.trim().toLowerCase();
+    if (envValue) {
+        return !isEnvDisabled(envValue);
+    }
+    return true;
+};
+export const staticCachePrefix = (action) => `${action.services.cache.getKeySalt() ?? ''}\0${action.services.options.root ?? ''}`;
+export const staticFileAnalysisCache = (action) => getWeakCacheMap(staticFileAnalysisCaches, action.services.cache);
+export const staticFileHashCache = (action) => getWeakCacheMap(staticFileHashCaches, action.services.cache);
+export const staticExportResultCache = (action) => getWeakCacheMap(staticExportResultCaches, action.services.cache);
+export const staticMetadataPreevalCache = (action) => getWeakCacheMap(staticMetadataPreevalCaches, action.services.cache);
+export const staticFileAnalysisCacheKey = (action, filename, codeHash) => `${staticCachePrefix(action)}\0${filename}\0${codeHash}`;
+export const staticExportCacheKey = (action, filename, exportedName, codeHash) => `${staticCachePrefix(action)}\0${filename}\0${exportedName}\0${codeHash}`;
+export const staticMetadataPreevalCacheKey = (action, filename, codeHash) => `${staticCachePrefix(action)}\0${filename}\0${codeHash}`;
+export const getStaticFileContentHash = (action, dependency) => {
+    const filename = stripQueryAndHash(dependency);
+    if (!isAbsolute(filename)) {
+        return null;
+    }
+    let stat;
+    try {
+        stat = statSync(filename);
+    }
+    catch {
+        return null;
+    }
+    if (!stat.isFile()) {
+        return null;
+    }
+    const cache = staticFileHashCache(action);
+    const cached = cache.get(filename);
+    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+        return cached.hash;
+    }
+    let hash;
+    try {
+        hash = hashStaticContent(readFileSync(filename));
+    }
+    catch {
+        return null;
+    }
+    cache.set(filename, {
+        hash,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+    });
+    return hash;
+};
+export const collectStaticDependencyHashes = (action, dependencies) => {
+    const hashes = new Map();
+    for (const dependency of dependencies) {
+        const hash = getStaticFileContentHash(action, dependency);
+        if (!hash) {
+            return null;
+        }
+        hashes.set(stripQueryAndHash(dependency), hash);
+    }
+    return hashes;
+};
+export const areStaticDependencyHashesCurrent = (action, dependencyHashes) => {
+    for (const [dependency, expectedHash] of dependencyHashes) {
+        if (getStaticFileContentHash(action, dependency) !== expectedHash) {
+            return false;
+        }
+    }
+    return true;
+};
+export const getStaticExportCachedResult = (action, filename, exportedName, codeHash) => {
+    if (!isStaticResolveCacheEnabled()) {
+        return undefined;
+    }
+    const cache = staticExportResultCache(action);
+    const cacheKey = staticExportCacheKey(action, filename, exportedName, codeHash);
+    const cached = cache.get(cacheKey);
+    if (!cached) {
+        return undefined;
+    }
+    if (cached.result === null) {
+        // Bounded retry: until the attempt counter has been bumped enough times
+        // that we accept the null as stable, treat it as a cache miss so the
+        // caller re-walks. The counter is updated in setStaticExportCachedResult.
+        if (cached.attempts < STATIC_EXPORT_MAX_NULL_ATTEMPTS) {
+            return undefined;
+        }
+        return null;
+    }
+    if (areStaticDependencyHashesCurrent(action, cached.dependencyHashes)) {
+        return cached.result;
+    }
+    cache.delete(cacheKey);
+    return undefined;
+};
+export const setStaticExportCachedResult = (action, filename, exportedName, codeHash, result) => {
+    if (!isStaticResolveCacheEnabled()) {
+        return;
+    }
+    const cache = staticExportResultCache(action);
+    const cacheKey = staticExportCacheKey(action, filename, exportedName, codeHash);
+    if (!result) {
+        const existing = cache.get(cacheKey);
+        const attempts = existing && existing.result === null ? existing.attempts + 1 : 1;
+        cache.set(cacheKey, { attempts, result: null });
+        return;
+    }
+    const dependencyHashes = collectStaticDependencyHashes(action, result.dependencies);
+    if (!dependencyHashes) {
+        return;
+    }
+    cache.set(cacheKey, {
+        dependencyHashes,
+        result,
+    });
+};
+export const getStaticFileAnalysis = (action, filename) => {
+    const loadedAndParsed = action.services.loadAndParseFn(action.services, filename, undefined, action.services.log);
+    if (loadedAndParsed.evaluator === 'ignored' ||
+        loadedAndParsed.evaluator !== oxcShaker) {
+        return null;
+    }
+    const { code } = loadedAndParsed;
+    const codeHash = hashStaticContent(code);
+    const cache = staticFileAnalysisCache(action);
+    const cacheKey = staticFileAnalysisCacheKey(action, filename, codeHash);
+    const cached = cache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const analysis = {
+        code,
+        codeHash,
+        program: parseProgram(code, filename),
+    };
+    cache.set(cacheKey, analysis);
+    return analysis;
+};
+export const getStaticMetadataPreevalResult = (action, filename, code, codeHash) => {
+    const cache = staticMetadataPreevalCache(action);
+    const cacheKey = staticMetadataPreevalCacheKey(action, filename, codeHash);
+    const cached = cache.get(cacheKey);
+    if (cached) {
+        return cached.result;
+    }
+    const root = action.services.options.root ?? process.cwd();
+    try {
+        const result = action.services.eventEmitter.perf('transform:preeval:staticMetadata', () => runOxcPreevalStage(code, {
+            filename,
+            root,
+        }, {
+            ...action.services.options.pluginOptions,
+            eventEmitter: action.services.eventEmitter,
+        }));
+        cache.set(cacheKey, { result });
+        return result;
+    }
+    catch {
+        cache.set(cacheKey, { result: null });
+        return null;
+    }
+};

package/types/transform/generators/resolveStaticOxcValues/candidateResolver.d.ts

@@ -0,0 +1,5 @@
+import { type OxcStaticValueCandidate } from '../../../utils/collectOxcTemplateDependencies';
+import type { ITransformAction, SyncScenarioFor } from '../../types';
+import type { StaticExportResult } from './types';
+export declare function resolveCandidateValue(action: ITransformAction, candidate: OxcStaticValueCandidate, filename: string, memo: Map<string, StaticExportResult | null>): SyncScenarioFor<StaticExportResult | null>;
+export declare function resolveOpaqueRuntimeCandidateValue(action: ITransformAction, candidate: OxcStaticValueCandidate, filename: string): SyncScenarioFor<StaticExportResult | null>;