@wyw-in-js/transform 1.0.7 → 1.1.0

package/types/cache.d.ts

@@ -25,6 +25,7 @@ export declare class TransformCacheCollection<TEntrypoint extends IBaseCachedEnt
     readonly exports: Map<string, string[]>;
     private readonly barrelManifestDependencies;
     private contentHashes;
+    private fileMtimes;
     private readonly exportDependencies;
     constructor(caches?: Partial<ICaches<TEntrypoint>>);
     add<TCache extends CacheNames, TValue extends MapValue<ICaches<TEntrypoint>[TCache]>>(cacheName: TCache, key: string, value: TValue): void;
@@ -40,6 +41,12 @@ export declare class TransformCacheCollection<TEntrypoint extends IBaseCachedEnt
     private getCachedDependencies;
     private getDependencyCache;
     private hasCachedDependencies;
+    /**
+     * Fast check if a file changed on disk since last seen.
+     * Uses mtime as a fast path — only reads the file if mtime differs.
+     * Returns true if the file changed (cache was invalidated).
+     */
+    checkFreshness(filename: string, strippedFilename: string): boolean;
     private setContentHash;
 }
 export {};

package/types/cache.js

@@ -12,6 +12,13 @@ const parseRequest_1 = require("./utils/parseRequest");
 function hashContent(content) {
     return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
 }
+function isMissingFileError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const { code } = error;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+}
 const cacheLogger = shared_1.logger.extend('cache');
 const cacheNames = ['barrelManifests', 'entrypoints', 'exports'];
 const loggers = cacheNames.reduce((acc, key) => ({
@@ -24,6 +31,7 @@ class TransformCacheCollection {
     exports;
     barrelManifestDependencies = new Map();
     contentHashes = new Map();
+    fileMtimes = new Map();
     exportDependencies = new Map();
     constructor(caches = {}) {
         this.barrelManifests = caches.barrelManifests || new Map();
@@ -157,7 +165,19 @@ class TransformCacheCollection {
             for (const [, dependency] of dependenciesToCheck) {
                 const dependencyFilename = dependency.resolved;
                 if (dependencyFilename) {
-                    const dependencyContent = node_fs_1.default.readFileSync((0, parseRequest_1.stripQueryAndHash)(dependencyFilename), 'utf8');
+                    let dependencyContent;
+                    try {
+                        dependencyContent = node_fs_1.default.readFileSync((0, parseRequest_1.stripQueryAndHash)(dependencyFilename), 'utf8');
+                    }
+                    catch (error) {
+                        if (!isMissingFileError(error)) {
+                            throw error;
+                        }
+                        this.invalidateForFile(dependencyFilename);
+                        anyDepChanged = true;
+                        // eslint-disable-next-line no-continue
+                        continue;
+                    }
                     const dependencyChanged = this.invalidateIfChanged(dependencyFilename, dependencyContent, visitedFiles, 'fs', changedFiles);
                     if (dependencyChanged &&
                         invalidateOnDependencyChange?.has(dependencyFilename)) {
@@ -249,13 +269,49 @@ class TransformCacheCollection {
     hasCachedDependencies(filename) {
         return this.getCachedDependencies(filename).size > 0;
     }
+    /**
+     * Fast check if a file changed on disk since last seen.
+     * Uses mtime as a fast path — only reads the file if mtime differs.
+     * Returns true if the file changed (cache was invalidated).
+     */
+    checkFreshness(filename, strippedFilename) {
+        try {
+            const currentMtime = node_fs_1.default.statSync(strippedFilename).mtimeMs;
+            const cachedMtime = this.fileMtimes.get(filename);
+            if (cachedMtime !== undefined && currentMtime === cachedMtime) {
+                return false;
+            }
+            const content = node_fs_1.default.readFileSync(strippedFilename, 'utf-8');
+            this.fileMtimes.set(filename, currentMtime);
+            if (this.invalidateIfChanged(filename, content, undefined, 'fs')) {
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            if (!isMissingFileError(error)) {
+                throw error;
+            }
+            this.invalidateForFile(filename);
+            return true;
+        }
+    }
     setContentHash(filename, source, hash) {
         const current = this.contentHashes.get(filename);
         if (current) {
             current[source] = hash;
-            return;
         }
-        this.contentHashes.set(filename, { [source]: hash });
+        else {
+            this.contentHashes.set(filename, { [source]: hash });
+        }
+        if (source === 'fs') {
+            try {
+                this.fileMtimes.set(filename, node_fs_1.default.statSync((0, parseRequest_1.stripQueryAndHash)(filename)).mtimeMs);
+            }
+            catch {
+                // ignore
+            }
+        }
     }
 }
 exports.TransformCacheCollection = TransformCacheCollection;

package/types/index.d.ts

@@ -3,8 +3,10 @@ export { createFileReporter } from './debug/fileReporter';
 export type { IFileReporterOptions } from './debug/fileReporter';
 export { default as babelTransformPlugin } from './plugins/babel-transform';
 export { default as preeval } from './plugins/preeval';
-export { getTransformMetadata, withTransformMetadata, } from './utils/TransformMetadata';
-export type { WYWTransformMetadata } from './utils/TransformMetadata';
+export { createTransformManifest, getTransformMetadata, stringifyTransformManifest, toTransformResultMetadata, withTransformMetadata, } from './utils/TransformMetadata';
+export type { WYWTransformManifest, WYWTransformMetadata, WYWTransformProcessorMetadata, WYWTransformResultMetadata, } from './utils/TransformMetadata';
+export { collectTransformDiagnostics } from './utils/TransformDiagnostics';
+export type { WYWTransformDiagnostic } from './utils/TransformDiagnostics';
 export { Module, DefaultModuleImplementation } from './module';
 export { default as shaker } from './shaker';
 export { transform } from './transform';

package/types/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findIdentifiers = exports.TransformCacheCollection = exports.peek = exports.getVisitorKeys = exports.applyProcessors = exports.getFileIdx = exports.isNode = exports.EventEmitter = exports.withDefaultServices = exports.loadWywOptions = exports.syncResolveImports = exports.asyncResolveImports = exports.transformUrl = exports.Entrypoint = exports.prepareCode = exports.baseHandlers = exports.parseFile = exports.EvaluatedEntrypoint = exports.UnprocessedEntrypointError = exports.isUnprocessedEntrypointError = exports.transform = exports.shaker = exports.DefaultModuleImplementation = exports.Module = exports.withTransformMetadata = exports.getTransformMetadata = exports.preeval = exports.babelTransformPlugin = exports.createFileReporter = exports.slugify = void 0;
+exports.findIdentifiers = exports.TransformCacheCollection = exports.peek = exports.getVisitorKeys = exports.applyProcessors = exports.getFileIdx = exports.isNode = exports.EventEmitter = exports.withDefaultServices = exports.loadWywOptions = exports.syncResolveImports = exports.asyncResolveImports = exports.transformUrl = exports.Entrypoint = exports.prepareCode = exports.baseHandlers = exports.parseFile = exports.EvaluatedEntrypoint = exports.UnprocessedEntrypointError = exports.isUnprocessedEntrypointError = exports.transform = exports.shaker = exports.DefaultModuleImplementation = exports.Module = exports.collectTransformDiagnostics = exports.withTransformMetadata = exports.toTransformResultMetadata = exports.stringifyTransformManifest = exports.getTransformMetadata = exports.createTransformManifest = exports.preeval = exports.babelTransformPlugin = exports.createFileReporter = exports.slugify = void 0;
 var shared_1 = require("@wyw-in-js/shared");
 Object.defineProperty(exports, "slugify", { enumerable: true, get: function () { return shared_1.slugify; } });
 var fileReporter_1 = require("./debug/fileReporter");
@@ -27,8 +27,13 @@ Object.defineProperty(exports, "babelTransformPlugin", { enumerable: true, get:
 var preeval_1 = require("./plugins/preeval");
 Object.defineProperty(exports, "preeval", { enumerable: true, get: function () { return __importDefault(preeval_1).default; } });
 var TransformMetadata_1 = require("./utils/TransformMetadata");
+Object.defineProperty(exports, "createTransformManifest", { enumerable: true, get: function () { return TransformMetadata_1.createTransformManifest; } });
 Object.defineProperty(exports, "getTransformMetadata", { enumerable: true, get: function () { return TransformMetadata_1.getTransformMetadata; } });
+Object.defineProperty(exports, "stringifyTransformManifest", { enumerable: true, get: function () { return TransformMetadata_1.stringifyTransformManifest; } });
+Object.defineProperty(exports, "toTransformResultMetadata", { enumerable: true, get: function () { return TransformMetadata_1.toTransformResultMetadata; } });
 Object.defineProperty(exports, "withTransformMetadata", { enumerable: true, get: function () { return TransformMetadata_1.withTransformMetadata; } });
+var TransformDiagnostics_1 = require("./utils/TransformDiagnostics");
+Object.defineProperty(exports, "collectTransformDiagnostics", { enumerable: true, get: function () { return TransformDiagnostics_1.collectTransformDiagnostics; } });
 var module_1 = require("./module");
 Object.defineProperty(exports, "Module", { enumerable: true, get: function () { return module_1.Module; } });
 Object.defineProperty(exports, "DefaultModuleImplementation", { enumerable: true, get: function () { return module_1.DefaultModuleImplementation; } });

package/types/module.js

@@ -326,10 +326,15 @@ class Module {
         if (extension !== '.json' && !this.extensions.includes(extension)) {
             return null;
         }
-        const entrypoint = this.cache.get('entrypoints', filename);
+        let entrypoint = this.cache.get('entrypoints', filename);
         if (entrypoint && (0, Entrypoint_helpers_1.isSuperSet)(entrypoint.evaluatedOnly ?? [], only)) {
-            log('✅ file has been already evaluated');
-            return entrypoint;
+            if (this.cache.checkFreshness(filename, strippedFilename)) {
+                entrypoint = undefined;
+            }
+            if (entrypoint) {
+                log('✅ file has been already evaluated');
+                return entrypoint;
+            }
         }
         if (entrypoint?.ignored) {
             log('✅ file has been ignored during prepare stage. Original code will be used');

package/types/plugins/collector.d.ts

@@ -12,7 +12,10 @@ export declare const filename: string;
 export declare function collector(file: BabelFile, options: Pick<StrictOptions, 'classNameSlug' | 'displayName' | 'extensions' | 'evaluate' | 'tagResolver'> & {
     eventEmitter?: EventEmitter;
 }, values: ValueCache): {
-    artifacts: import("@wyw-in-js/shared").Artifact[];
+    readonly artifacts: import("@wyw-in-js/shared").Artifact[];
+    readonly className: string;
+    readonly displayName: string;
+    readonly location: import("@babel/types").SourceLocation | null;
 }[];
 export default function collectorPlugin(babel: Core, options: StrictOptions & {
     eventEmitter?: EventEmitter;

package/types/transform/Entrypoint.d.ts

@@ -43,7 +43,7 @@ export declare class Entrypoint extends BaseEntrypoint {
     assertNotSuperseded(): void;
     assertTransformed(): void;
     beginProcessing(): void;
-    createAction<TType extends ActionTypes, TAction extends ActionByType<TType>>(actionType: TType, data: TAction['data'], abortSignal?: AbortSignal | null): BaseAction<TAction>;
+    createAction<TType extends ActionTypes, TAction extends ActionByType<TType>>(actionType: TType, data: TAction['data'], abortSignal?: AbortSignal | null, actionContext?: unknown): BaseAction<TAction>;
     createChild(name: string, only: string[], loadedCode?: string): Entrypoint | 'loop';
     createEvaluated(): EvaluatedEntrypoint;
     endProcessing(): void;

package/types/transform/Entrypoint.js

@@ -14,6 +14,7 @@ const BaseAction_1 = require("./actions/BaseAction");
 const UnprocessedEntrypointError_1 = require("./actions/UnprocessedEntrypointError");
 const parseRequest_1 = require("../utils/parseRequest");
 const EMPTY_FILE = '=== empty file ===';
+const DEFAULT_ACTION_CONTEXT = Symbol('defaultActionContext');
 function hasLoop(name, parent, processed = []) {
     if (parent.name === name || processed.includes(parent.name)) {
         return true;
@@ -201,16 +202,20 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
     beginProcessing() {
         this.#isProcessing = true;
     }
-    createAction(actionType, data, abortSignal = null) {
+    createAction(actionType, data, abortSignal = null, actionContext = DEFAULT_ACTION_CONTEXT) {
         if (!this.actionsCache.has(actionType)) {
             this.actionsCache.set(actionType, new Map());
         }
-        const cache = this.actionsCache.get(actionType);
+        const contexts = this.actionsCache.get(actionType);
+        if (!contexts.has(actionContext)) {
+            contexts.set(actionContext, new Map());
+        }
+        const cache = contexts.get(actionContext);
         const cached = cache.get(data);
         if (cached && !cached.abortSignal?.aborted) {
             return cached;
         }
-        const newAction = new BaseAction_1.BaseAction(actionType, this.services, this, data, abortSignal);
+        const newAction = new BaseAction_1.BaseAction(actionType, this.services, this, data, abortSignal, actionContext);
         cache.set(data, newAction);
         this.services.eventEmitter.entrypointEvent(this.seqId, {
             type: 'actionCreated',

package/types/transform/actions/BaseAction.d.ts

@@ -13,13 +13,14 @@ export declare class BaseAction<TAction extends ActionQueueItem> implements GetB
     readonly entrypoint: Entrypoint;
     readonly data: TAction['data'];
     readonly abortSignal: AbortSignal | null;
+    readonly actionContext: unknown;
     readonly idx: string;
     result: TypeOfResult<TAction> | typeof Pending;
     private activeScenario;
     private activeScenarioError?;
     private activeScenarioNextResults;
     private handler;
-    constructor(type: TAction['type'], services: Services, entrypoint: Entrypoint, data: TAction['data'], abortSignal: AbortSignal | null);
+    constructor(type: TAction['type'], services: Services, entrypoint: Entrypoint, data: TAction['data'], abortSignal: AbortSignal | null, actionContext: unknown);
     get log(): Debugger;
     get ref(): string;
     createAbortSignal(): AbortSignal & Disposable;

package/types/transform/actions/BaseAction.js

@@ -11,18 +11,20 @@ class BaseAction {
     entrypoint;
     data;
     abortSignal;
+    actionContext;
     idx;
     result = types_1.Pending;
     activeScenario = null;
     activeScenarioError;
     activeScenarioNextResults = [];
     handler = null;
-    constructor(type, services, entrypoint, data, abortSignal) {
+    constructor(type, services, entrypoint, data, abortSignal, actionContext) {
         this.type = type;
         this.services = services;
         this.entrypoint = entrypoint;
         this.data = data;
         this.abortSignal = abortSignal;
+        this.actionContext = actionContext;
         actionIdx += 1;
         this.idx = actionIdx.toString(16).padStart(6, '0');
     }

package/types/transform/actions/actionRunner.js

@@ -36,7 +36,7 @@ async function asyncActionRunner(action, actionHandlers, stack = [getActionRef(a
             return result.value;
         }
         const [type, entrypoint, data, abortSignal] = result.value;
-        const nextAction = entrypoint.createAction(type, data, abortSignal);
+        const nextAction = entrypoint.createAction(type, data, abortSignal, action.actionContext);
         try {
             actionResult = await asyncActionRunner(nextAction, actionHandlers, [
                 ...stack,
@@ -70,7 +70,7 @@ function syncActionRunner(action, actionHandlers, stack = [getActionRef(action.t
             return result.value;
         }
         const [type, entrypoint, data, abortSignal] = result.value;
-        const nextAction = entrypoint.createAction(type, data, abortSignal);
+        const nextAction = entrypoint.createAction(type, data, abortSignal, action.actionContext);
         try {
             actionResult = syncActionRunner(nextAction, actionHandlers, [
                 ...stack,

package/types/transform/actions/types.d.ts

@@ -1,5 +1,7 @@
 import type { BabelFileResult } from '@babel/core';
 import type { Replacements, Rules } from '@wyw-in-js/shared';
+import type { WYWTransformDiagnostic } from '../../utils/TransformDiagnostics';
+import type { WYWTransformResultMetadata } from '../../utils/TransformMetadata';
 export interface IExtracted {
     cssSourceMapText: string;
     cssText: string;
@@ -12,4 +14,6 @@ export interface IWorkflowActionNonLinariaResult {
 }
 export interface IWorkflowActionLinariaResult extends IExtracted, IWorkflowActionNonLinariaResult {
     dependencies: string[];
+    diagnostics?: WYWTransformDiagnostic[];
+    metadata?: WYWTransformResultMetadata;
 }

package/types/transform/generators/processEntrypoint.js

@@ -57,7 +57,10 @@ const shaker_1 = require("../../shaker");
 const AbortError_1 = require("../actions/AbortError");
 const barrelManifest_1 = require("../barrelManifest");
 const shouldSkipExplodeReexports = (action) => {
-    const { loadedAndParsed } = action.entrypoint;
+    const { loadedAndParsed, only } = action.entrypoint;
+    if (only.length === 1 && only[0] === '__wywPreval') {
+        return true;
+    }
     if (loadedAndParsed.evaluator !== shaker_1.shaker || !loadedAndParsed.ast) {
         return false;
     }

package/types/transform/generators/workflow.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.workflow = workflow;
 const AbortError_1 = require("../actions/AbortError");
+const TransformDiagnostics_1 = require("../../utils/TransformDiagnostics");
+const TransformMetadata_1 = require("../../utils/TransformMetadata");
 /**
  * The entry point for file processing. Sequentially calls `processEntrypoint`,
  * `evalFile`, `collect`, and `extract`. Returns the result of transforming
@@ -59,6 +61,10 @@ function* workflow() {
             sourceMap: collectStageResult.map,
         };
     }
+    const metadata = options.pluginOptions.outputMetadata
+        ? (0, TransformMetadata_1.toTransformResultMetadata)(collectStageResult.metadata, dependencies)
+        : null;
+    const diagnostics = (0, TransformDiagnostics_1.collectTransformDiagnostics)(entrypoint.name, collectStageResult.metadata.processors);
     // *** 4th stage
     const extractStageResult = yield* this.getNext('extract', entrypoint, {
         processors: collectStageResult.metadata.processors,
@@ -67,6 +73,8 @@ function* workflow() {
         ...extractStageResult,
         code: collectStageResult.code ?? '',
         dependencies,
+        ...(diagnostics.length > 0 ? { diagnostics } : {}),
+        ...(metadata ? { metadata } : {}),
         replacements: [
             ...extractStageResult.replacements,
             ...collectStageResult.metadata.replacements,

package/types/transform/helpers/loadWywOptions.js

@@ -54,6 +54,7 @@ function loadWywOptions(overrides = defaultOverrides) {
         displayName: false,
         evaluate: true,
         extensions: ['.cjs', '.cts', '.js', '.jsx', '.mjs', '.mts', '.ts', '.tsx'],
+        outputMetadata: false,
         rules: rules ?? [
             {
                 action: shaker_1.shaker,

package/types/transform/types.d.ts

@@ -34,6 +34,7 @@ export type AnyIteratorResult<TMode extends 'async' | 'sync', TResult> = {
     sync: IteratorResult<YieldArg, TResult>;
 }[TMode];
 export interface IBaseAction<TAction extends ActionQueueItem, TResult, TData> extends IBaseNode {
+    actionContext: unknown;
     abortSignal: AbortSignal | null;
     createAbortSignal: () => AbortSignal & Disposable;
     data: TData;

package/types/transform.js

@@ -21,6 +21,24 @@ const resolveImports_1 = require("./transform/generators/resolveImports");
 const withDefaultServices_1 = require("./transform/helpers/withDefaultServices");
 const memoizedSyncResolve = new WeakMap();
 const memoizedAsyncResolve = new WeakMap();
+const EMPTY_CUSTOM_HANDLERS = {};
+const memoizedActionContexts = new WeakMap();
+const getActionContext = (resolveImportsHandler, customHandlers) => {
+    const customHandlersKey = Object.keys(customHandlers).length === 0
+        ? EMPTY_CUSTOM_HANDLERS
+        : customHandlers;
+    let actionContextsByHandlers = memoizedActionContexts.get(resolveImportsHandler);
+    if (!actionContextsByHandlers) {
+        actionContextsByHandlers = new WeakMap();
+        memoizedActionContexts.set(resolveImportsHandler, actionContextsByHandlers);
+    }
+    let actionContext = actionContextsByHandlers.get(customHandlersKey);
+    if (!actionContext) {
+        actionContext = {};
+        actionContextsByHandlers.set(customHandlersKey, actionContext);
+    }
+    return actionContext;
+};
 function transformSync(partialServices, originalCode, syncResolve, customHandlers = {}) {
     const { options } = partialServices;
     const pluginOptions = (0, loadWywOptions_1.loadWywOptions)(options.pluginOptions);
@@ -35,6 +53,18 @@ function transformSync(partialServices, originalCode, syncResolve, customHandler
         // If global cache is disabled, we need to create a new cache for each file
         services.cache = new cache_1.TransformCacheCollection();
     }
+    if (!memoizedSyncResolve.has(syncResolve)) {
+        memoizedSyncResolve.set(syncResolve, function resolveImports() {
+            return resolveImports_1.syncResolveImports.call(this, syncResolve);
+        });
+    }
+    const resolveImportsHandler = memoizedSyncResolve.get(syncResolve);
+    const actionHandlers = {
+        ...generators_1.baseHandlers,
+        ...customHandlers,
+        resolveImports: resolveImportsHandler,
+    };
+    const actionContext = getActionContext(resolveImportsHandler, customHandlers);
     const entrypoint = Entrypoint_1.Entrypoint.createRoot(services, options.filename, ['__wywPreval'], originalCode);
     if (entrypoint.ignored) {
         return {
@@ -42,18 +72,9 @@ function transformSync(partialServices, originalCode, syncResolve, customHandler
             sourceMap: options.inputSourceMap,
         };
     }
-    const workflowAction = entrypoint.createAction('workflow', undefined);
-    if (!memoizedSyncResolve.has(syncResolve)) {
-        memoizedSyncResolve.set(syncResolve, function resolveImports() {
-            return resolveImports_1.syncResolveImports.call(this, syncResolve);
-        });
-    }
+    const workflowAction = entrypoint.createAction('workflow', undefined, null, actionContext);
     try {
-        const result = (0, actionRunner_1.syncActionRunner)(workflowAction, {
-            ...generators_1.baseHandlers,
-            ...customHandlers,
-            resolveImports: memoizedSyncResolve.get(syncResolve),
-        });
+        const result = (0, actionRunner_1.syncActionRunner)(workflowAction, actionHandlers);
         entrypoint.log('%s is ready', entrypoint.name);
         return result;
     }
@@ -92,6 +113,19 @@ async function transform(partialServices, originalCode, asyncResolve, customHand
      * but the "only" option has changed, the file will be re-processed using
      * the combined "only" option.
      */
+    if (!memoizedAsyncResolve.has(asyncResolve)) {
+        const resolveImports = function resolveImports() {
+            return resolveImports_1.asyncResolveImports.call(this, asyncResolve);
+        };
+        memoizedAsyncResolve.set(asyncResolve, resolveImports);
+    }
+    const resolveImportsHandler = memoizedAsyncResolve.get(asyncResolve);
+    const actionHandlers = {
+        ...generators_1.baseHandlers,
+        ...customHandlers,
+        resolveImports: resolveImportsHandler,
+    };
+    const actionContext = getActionContext(resolveImportsHandler, customHandlers);
     const entrypoint = Entrypoint_1.Entrypoint.createRoot(services, options.filename, ['__wywPreval'], originalCode);
     if (entrypoint.ignored) {
         return {
@@ -99,19 +133,9 @@ async function transform(partialServices, originalCode, asyncResolve, customHand
             sourceMap: options.inputSourceMap,
         };
     }
-    const workflowAction = entrypoint.createAction('workflow', undefined);
-    if (!memoizedAsyncResolve.has(asyncResolve)) {
-        const resolveImports = function resolveImports() {
-            return resolveImports_1.asyncResolveImports.call(this, asyncResolve);
-        };
-        memoizedAsyncResolve.set(asyncResolve, resolveImports);
-    }
+    const workflowAction = entrypoint.createAction('workflow', undefined, null, actionContext);
     try {
-        const result = await (0, actionRunner_1.asyncActionRunner)(workflowAction, {
-            ...generators_1.baseHandlers,
-            ...customHandlers,
-            resolveImports: memoizedAsyncResolve.get(asyncResolve),
-        });
+        const result = await (0, actionRunner_1.asyncActionRunner)(workflowAction, actionHandlers);
         entrypoint.log('%s is ready', entrypoint.name);
         return result;
     }

package/types/types.d.ts

@@ -4,7 +4,8 @@ import type { File, Program } from '@babel/types';
 import type { RawSourceMap } from 'source-map';
 import type { BaseProcessor } from '@wyw-in-js/processor-utils';
 import type { Debugger, Replacement, Rules, StrictOptions } from '@wyw-in-js/shared';
-import type { WYWTransformMetadata } from './utils/TransformMetadata';
+import type { WYWTransformMetadata, WYWTransformResultMetadata } from './utils/TransformMetadata';
+import type { WYWTransformDiagnostic } from './utils/TransformDiagnostics';
 export type PluginOptions = StrictOptions & {
     configFile?: string | false;
     stage?: Stage;
@@ -36,6 +37,8 @@ export type Result = {
     cssSourceMapText?: string;
     cssText?: string;
     dependencies?: string[];
+    diagnostics?: WYWTransformDiagnostic[];
+    metadata?: WYWTransformResultMetadata;
     replacements?: Replacement[];
     rules?: Rules;
     sourceMap?: RawSourceMap | null;

package/types/utils/TransformDiagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { BaseProcessor, ProcessorDiagnostic } from '@wyw-in-js/processor-utils';
+type DiagnosticProcessor = Pick<BaseProcessor, 'artifacts' | 'className' | 'displayName'>;
+export type WYWTransformDiagnostic = ProcessorDiagnostic & {
+    className: string;
+    displayName: string;
+    filename: string;
+};
+export declare const collectTransformDiagnostics: (filename: string, processors: DiagnosticProcessor[]) => WYWTransformDiagnostic[];
+export {};

package/types/utils/TransformDiagnostics.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectTransformDiagnostics = void 0;
+const processor_utils_1 = require("@wyw-in-js/processor-utils");
+const collectTransformDiagnostics = (filename, processors) => processors.flatMap((processor) => processor.artifacts
+    .filter(processor_utils_1.isProcessorDiagnosticArtifact)
+    .map(([, diagnostic]) => ({
+    ...diagnostic,
+    className: processor.className,
+    displayName: processor.displayName,
+    end: diagnostic.end ?? null,
+    filename,
+    start: diagnostic.start ?? null,
+})));
+exports.collectTransformDiagnostics = collectTransformDiagnostics;

package/types/utils/TransformMetadata.d.ts

@@ -1,13 +1,31 @@
-import type { Artifact, Replacement, Rules } from '@wyw-in-js/shared';
+import type { BaseProcessor } from '@wyw-in-js/processor-utils';
+import type { Artifact, Location, Replacement, Rules } from '@wyw-in-js/shared';
+type TransformMetadataProcessor = Pick<BaseProcessor, 'artifacts' | 'className' | 'displayName' | 'location'>;
 export type WYWTransformMetadata = {
     dependencies: string[];
-    processors: {
-        artifacts: Artifact[];
-    }[];
+    processors: TransformMetadataProcessor[];
     replacements: Replacement[];
     rules: Rules;
 };
+export type WYWTransformProcessorMetadata = {
+    artifacts: Artifact[];
+    className: string;
+    displayName: string;
+    start: Location | null | undefined;
+};
+export type WYWTransformResultMetadata = Omit<WYWTransformMetadata, 'processors'> & {
+    processors: WYWTransformProcessorMetadata[];
+};
+export type WYWTransformManifest = WYWTransformResultMetadata & {
+    cssFile?: string;
+    source: string;
+    version: 1;
+};
 export declare const withTransformMetadata: (value: unknown) => value is {
     wywInJS: WYWTransformMetadata;
 };
 export declare const getTransformMetadata: (value: unknown) => WYWTransformMetadata | undefined;
+export declare const toTransformResultMetadata: (metadata: WYWTransformMetadata, dependencies: string[]) => WYWTransformResultMetadata;
+export declare const createTransformManifest: (metadata: WYWTransformResultMetadata, context: Pick<WYWTransformManifest, "cssFile" | "source">) => WYWTransformManifest;
+export declare const stringifyTransformManifest: (manifest: WYWTransformManifest) => string;
+export {};

package/types/utils/TransformMetadata.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTransformMetadata = exports.withTransformMetadata = void 0;
+exports.stringifyTransformManifest = exports.createTransformManifest = exports.toTransformResultMetadata = exports.getTransformMetadata = exports.withTransformMetadata = void 0;
+const processor_utils_1 = require("@wyw-in-js/processor-utils");
 const withTransformMetadata = (value) => typeof value === 'object' &&
     value !== null &&
     typeof value.wywInJS === 'object';
@@ -15,3 +16,25 @@ const getTransformMetadata = (value) => {
     return undefined;
 };
 exports.getTransformMetadata = getTransformMetadata;
+const toTransformResultMetadata = (metadata, dependencies) => ({
+    dependencies,
+    processors: metadata.processors.map((processor) => ({
+        artifacts: processor.artifacts
+            .filter((artifact) => !(0, processor_utils_1.isProcessorDiagnosticArtifact)(artifact))
+            .map(([type, data]) => [type, data]),
+        className: processor.className,
+        displayName: processor.displayName,
+        start: processor.location?.start ?? null,
+    })),
+    replacements: [...metadata.replacements],
+    rules: { ...metadata.rules },
+});
+exports.toTransformResultMetadata = toTransformResultMetadata;
+const createTransformManifest = (metadata, context) => ({
+    ...metadata,
+    ...context,
+    version: 1,
+});
+exports.createTransformManifest = createTransformManifest;
+const stringifyTransformManifest = (manifest) => `${JSON.stringify(manifest, null, 2)}\n`;
+exports.stringifyTransformManifest = stringifyTransformManifest;

package/types/utils/collectTemplateDependencies.js

@@ -18,6 +18,15 @@ const valueToLiteral_1 = require("./valueToLiteral");
 function staticEval(ex, evaluate = false) {
     if (!evaluate)
         return undefined;
+    if (ex.isIdentifier()) {
+        const binding = ex.scope.getBinding(ex.node.name);
+        // Babel may "evaluate" a destructured binding to its source container
+        // object/array instead of the bound value, which changes template semantics.
+        if (binding?.path.isVariableDeclarator() &&
+            !binding.path.get('id').isIdentifier()) {
+            return undefined;
+        }
+    }
     const result = ex.evaluate();
     if (result.confident && !(0, shared_1.hasEvalMeta)(result.value)) {
         return [result.value];