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

package/types/transform/generators/processImports.js

@@ -1,7 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processImports = processImports;
-const importOverrides_1 = require("../../utils/importOverrides");
+/* eslint-disable no-continue */
+import { hasCachedWywPrevalExport, } from '../../utils/hasCachedWywPrevalExport';
+import { toImportKey } from '../../utils/importOverrides';
+import { stripQueryAndHash } from '../../utils/parseRequest';
+import { isSuperSet, mergeOnly } from '../Entrypoint.helpers';
 const warnedSlowImportsByServices = new WeakMap();
 function emitWarning(services, message) {
     if (services.emitWarning) {
@@ -22,10 +23,18 @@ function getWarnedSlowImports(services) {
 function isWarningEnabled(value) {
     return Boolean(value) && value !== '0' && value !== 'false';
 }
-/**
- * Creates new entrypoints and emits processEntrypoint for each resolved import
- */
-function* processImports() {
+function hasLoop(name, parent, processed = []) {
+    if (parent.name === name || processed.includes(parent.name)) {
+        return true;
+    }
+    for (const nextParent of parent.parents) {
+        if (hasLoop(name, nextParent, [...processed, parent.name])) {
+            return true;
+        }
+    }
+    return false;
+}
+export function* processImports() {
     const slowImportWarningsEnabled = isWarningEnabled(process.env.WYW_WARN_SLOW_IMPORTS);
     const slowImportThresholdMs = (() => {
         const raw = process.env.WYW_WARN_SLOW_IMPORTS_MS;
@@ -40,13 +49,44 @@ function* processImports() {
         ? getWarnedSlowImports(this.services)
         : null;
     const { root } = this.services.options;
+    const prepareStageRequiresEvaluatedDeps = this.entrypoint.only.includes('__wywPreval');
+    const skippedParentDependencySources = new Set(this.data.skipParentDependencyTracking ?? []);
     for (const dependency of this.data.resolved) {
         const { resolved, only } = dependency;
         if (!resolved) {
             continue;
         }
-        this.entrypoint.addDependency(dependency);
-        const nextEntrypoint = this.entrypoint.createChild(resolved, only);
+        const cached = this.services.cache.get('entrypoints', resolved);
+        const shouldRequireWywPreval = prepareStageRequiresEvaluatedDeps &&
+            (!cached?.evaluated ||
+                cached.ignored ||
+                hasCachedWywPrevalExport(this.services, resolved, cached));
+        const requiredOnly = shouldRequireWywPreval
+            ? mergeOnly(only, ['__wywPreval'])
+            : only;
+        if (!skippedParentDependencySources.has(dependency.source)) {
+            this.entrypoint.addDependency({
+                ...dependency,
+                only: requiredOnly,
+            });
+        }
+        const canReuseTransformedDependency = !prepareStageRequiresEvaluatedDeps &&
+            Boolean(cached && !cached.evaluated && cached.transformed);
+        if (cached &&
+            (cached.evaluated || canReuseTransformedDependency) &&
+            isSuperSet(cached.only, requiredOnly) &&
+            !hasLoop(resolved, this.entrypoint) &&
+            !this.services.cache.checkFreshness(resolved, stripQueryAndHash(resolved))) {
+            if (Array.isArray(cached.parents)) {
+                if (!cached.parents
+                    .map((parent) => parent.name)
+                    .includes(this.entrypoint.name)) {
+                    cached.parents.push(this.entrypoint);
+                }
+            }
+            continue;
+        }
+        const nextEntrypoint = this.entrypoint.createChild(resolved, requiredOnly);
         if (nextEntrypoint === 'loop' || nextEntrypoint.ignored) {
             continue;
         }
@@ -57,7 +97,7 @@ function* processImports() {
             slowImportThresholdMs > 0) {
             const durationMs = performance.now() - startedAt;
             if (durationMs >= slowImportThresholdMs) {
-                const { key: importKey } = (0, importOverrides_1.toImportKey)({
+                const { key: importKey } = toImportKey({
                     source: dependency.source,
                     resolved,
                     root,
@@ -66,20 +106,20 @@ function* processImports() {
                 if (!warnedSlowImports.has(dedupeKey)) {
                     warnedSlowImports.add(dedupeKey);
                     const warning = [
-                        `[wyw-in-js] Slow import during prepare stage`,
-                        ``,
+                        '[wyw-in-js] Slow import during prepare stage',
+                        '',
                         `file: ${this.entrypoint.name}`,
                         `import: ${dependency.source}`,
                         `resolved: ${resolved}`,
                         `duration: ${durationMs.toFixed(1)}ms`,
-                        ``,
-                        `tip: if this import is runtime-only or heavy, mock it during evaluation via importOverrides:`,
-                        `  importOverrides: {`,
+                        '',
+                        'tip: if this import is runtime-only or heavy, mock it during evaluation via importOverrides:',
+                        '  importOverrides: {',
                         `    '${importKey}': { mock: './path/to/mock' },`,
-                        `  }`,
-                        ``,
-                        `note: importOverrides affects only build-time evaluation (it does not change your bundler runtime behavior)`,
-                        ``,
+                        '  }',
+                        '',
+                        'note: importOverrides affects only build-time evaluation (it does not change your bundler runtime behavior)',
+                        '',
                         `note: configure threshold with WYW_WARN_SLOW_IMPORTS_MS (current: ${slowImportThresholdMs}ms)`,
                     ].join('\n');
                     emitWarning(this.services, warning);

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,11 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncResolveImports = syncResolveImports;
-exports.asyncResolveImports = asyncResolveImports;
-/* eslint-disable no-continue,no-await-in-loop,require-yield */
-const getFileIdx_1 = require("../../utils/getFileIdx");
-const Entrypoint_helpers_1 = require("../Entrypoint.helpers");
-const importOverrides_1 = require("../../utils/importOverrides");
+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) {
@@ -13,20 +56,20 @@ function applyImportOverrides(services, entrypoint, resolvedImports) {
     }
     const { root } = services.options;
     const importer = entrypoint.name;
-    const stack = (0, Entrypoint_helpers_1.getStack)(entrypoint);
+    const stack = getStack(entrypoint);
     return resolvedImports.map((dependency) => {
-        const { key } = (0, importOverrides_1.toImportKey)({
+        const { key } = toImportKey({
             source: dependency.source,
             resolved: dependency.resolved,
             root,
         });
-        const override = (0, importOverrides_1.getImportOverride)(overrides, key);
+        const override = getImportOverride(overrides, key);
         if (!override) {
             return dependency;
         }
-        const nextOnly = (0, importOverrides_1.applyImportOverrideToOnly)(dependency.only, override);
+        const nextOnly = applyImportOverrideToOnly(dependency.only, override);
         const nextResolved = override.mock
-            ? (0, importOverrides_1.resolveMockSpecifier)({
+            ? resolveMockSpecifier({
                 mock: override.mock,
                 importer,
                 root,
@@ -50,7 +93,7 @@ function emitDependency(emitter, entrypoint, imports, phase) {
             from: resolved,
             what: only,
         })),
-        fileIdx: (0, getFileIdx_1.getFileIdx)(entrypoint.name),
+        fileIdx: getFileIdx(entrypoint.name),
     });
 }
 function filterUnresolved(entrypoint, resolvedImports) {
@@ -68,7 +111,7 @@ function getPreResolvedImports(preResolved) {
 /**
  * Synchronously resolves specified imports with a provided resolver.
  */
-function* syncResolveImports(resolve) {
+export function* syncResolveImports(resolve) {
     const { data: { imports }, entrypoint, services: { eventEmitter }, } = this;
     const listOfImports = Array.from(imports?.entries() ?? []);
     const preResolvedImports = getPreResolvedImports(this.data.preResolved);
@@ -81,7 +124,7 @@ function* syncResolveImports(resolve) {
     const resolvedImports = listOfImports.map(([source, only]) => {
         const preResolved = preResolvedImports.get(source);
         if (preResolved) {
-            const mergedOnly = (0, Entrypoint_helpers_1.mergeOnly)(preResolved.only, only);
+            const mergedOnly = mergeOnly(preResolved.only, only);
             log('[sync-resolve] ♻️ %s -> %s (only: %o)', source, preResolved.resolved, mergedOnly);
             return {
                 ...preResolved,
@@ -90,7 +133,7 @@ function* syncResolveImports(resolve) {
         }
         let resolved = null;
         try {
-            resolved = resolve(source, entrypoint.name, (0, Entrypoint_helpers_1.getStack)(entrypoint));
+            resolved = resolve(source, entrypoint.name, getStack(entrypoint));
             log('[sync-resolve] ✅ %s -> %s (only: %o)', source, resolved, only);
         }
         catch (err) {
@@ -110,7 +153,7 @@ function* syncResolveImports(resolve) {
 /**
  * Asynchronously resolves specified imports with a provided resolver.
  */
-async function* asyncResolveImports(resolve) {
+export async function* asyncResolveImports(resolve) {
     const { data: { imports }, entrypoint, services: { eventEmitter }, } = this;
     const listOfImports = Array.from(imports?.entries() ?? []);
     const preResolvedImports = getPreResolvedImports(this.data.preResolved);
@@ -124,7 +167,7 @@ async function* asyncResolveImports(resolve) {
     const getResolveTask = async (source, only) => {
         let resolved = null;
         try {
-            resolved = await resolve(source, entrypoint.name, (0, Entrypoint_helpers_1.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);
@@ -141,7 +184,7 @@ async function* asyncResolveImports(resolve) {
     const resolvedImports = await Promise.all(listOfImports.map(([source, importsOnly]) => {
         const preResolved = preResolvedImports.get(source);
         if (preResolved) {
-            const mergedOnly = (0, Entrypoint_helpers_1.mergeOnly)(preResolved.only, importsOnly);
+            const mergedOnly = mergeOnly(preResolved.only, importsOnly);
             log('[async-resolve] ♻️ %s (%o) in %s -> %s', source, mergedOnly, entrypoint.name, preResolved.resolved);
             return {
                 ...preResolved,
@@ -152,7 +195,7 @@ async function* asyncResolveImports(resolve) {
         if (cached) {
             return {
                 source,
-                only: (0, Entrypoint_helpers_1.mergeOnly)(cached.only, importsOnly),
+                only: mergeOnly(cached.only, importsOnly),
                 resolved: cached.resolved,
             };
         }
@@ -160,11 +203,11 @@ async function* asyncResolveImports(resolve) {
         if (task) {
             // If we have cached task, we need to merge only…
             const newTask = task.then((res) => {
-                if ((0, Entrypoint_helpers_1.isSuperSet)(res.only, importsOnly)) {
+                if (isSuperSet(res.only, importsOnly)) {
                     return res;
                 }
                 // Is this branch even possible?
-                const merged = (0, Entrypoint_helpers_1.mergeOnly)(res.only, importsOnly);
+                const merged = mergeOnly(res.only, importsOnly);
                 log('merging imports %o and %o: %o', importsOnly, res.only, merged);
                 return { ...res, only: merged };
             });

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>;