@atlaspack/core 2.30.2 → 2.31.0

package/lib/types/atlaspack-v3/worker/side-effect-detector.d.ts

@@ -0,0 +1,76 @@
+import type { Async } from '@atlaspack/types';
+export interface FsUsage {
+    method: string;
+    path?: string;
+}
+export interface EnvUsage {
+    vars: Set<string>;
+    didEnumerate: boolean;
+}
+export interface SideEffects {
+    fsUsage: FsUsage[];
+    envUsage: EnvUsage;
+    packageName: string;
+}
+/**
+ * Side effect detector using AsyncLocalStorage to track filesystem and environment variable
+ * access across concurrent async operations in a Node.js worker thread.
+ *
+ * Usage:
+ *   const detector = new SideEffectDetector();
+ *   detector.install();
+ *
+ *   const [result, sideEffects] = await detector.monitorSideEffects(async () => {
+ *     return await someOperation();
+ *   });
+ *
+ *   console.log(sideEffects.fsUsage);   // Array of filesystem accesses
+ *   console.log(sideEffects.envUsage);  // Array of environment variable accesses
+ */
+export declare class SideEffectDetector {
+    private asyncStorage;
+    private patchesInstalled;
+    private originalMethods;
+    constructor();
+    /**
+     * Install global patches for filesystem and environment variable monitoring.
+     * This should be called once when the worker starts up.
+     */
+    install(): void;
+    /**
+     * Monitor side effects for an async operation.
+     *
+     * @param {Function} fn - Async function to monitor
+     * @param {Object} options - Optional configuration
+     * @param {string} options.label - Optional label for debugging
+     * @returns {Promise<[any, SideEffects]>} Tuple of [result, sideEffects]
+     */
+    monitorSideEffects<T>(packageName: string, fn: () => Async<T>): Async<[T, SideEffects]>;
+    /**
+     * Get the current monitoring context, if any.
+     * Useful for debugging or custom instrumentation.
+     *
+     * @returns {Object|null} Current context or null if not monitoring
+     */
+    getCurrentContext(): SideEffects | null;
+    /**
+     * Check if currently monitoring side effects.
+     *
+     * @returns {boolean}
+     */
+    isMonitoring(): boolean;
+    /**
+     * Patch filesystem methods to record access.
+     * @private
+     */
+    private _patchFilesystem;
+    /**
+     * Patch process.env to record environment variable access.
+     * @private
+     */
+    private _patchProcessEnv;
+}
+/**
+ * Default instance for convenience. Most workers will only need one detector.
+ */
+export declare const defaultDetector: SideEffectDetector;

package/lib/types/atlaspack-v3/worker/worker.d.ts

@@ -1,10 +1,12 @@
 import * as napi from '@atlaspack/rust';
 import type { JsCallable } from '@atlaspack/rust';
-import type { FilePath } from '@atlaspack/types';
-import { FeatureFlags } from '@atlaspack/feature-flags';
+import { NodePackageManager } from '@atlaspack/package-manager';
+import type { Transformer, FilePath, FileSystem } from '@atlaspack/types';
+import type { FeatureFlags } from '@atlaspack/feature-flags';
 export declare class AtlaspackWorker {
     #private;
     constructor();
+    clearState(): void;
     loadPlugin: JsCallable<[LoadPluginOptions], Promise<undefined>>;
     runResolverResolve: JsCallable<[
         RunResolverResolveOptions
@@ -14,23 +16,37 @@ export declare class AtlaspackWorker {
         Buffer,
         string | null | undefined
     ], Promise<RunTransformerTransformResult>>;
+    get options(): Options;
+    initializeTransformer(instance: Transformer<any>, specifier: string): Promise<{
+        conditions: import("@atlaspack/types-internal").TransformerConditions | undefined;
+        config: any;
+        env: {
+            [k: string]: string | undefined;
+        };
+    } | undefined>;
 }
 type LoadPluginOptions = {
     kind: 'resolver' | 'transformer';
     specifier: string;
     resolveFrom: string;
-    featureFlags?: FeatureFlags;
+    options: RpcPluginOptions;
 };
 type RpcPluginOptions = {
     projectRoot: string;
     mode: string;
+    featureFlags: FeatureFlags;
+};
+type Options = RpcPluginOptions & {
+    inputFS: FileSystem;
+    outputFS: FileSystem;
+    packageManager: NodePackageManager;
+    shouldAutoInstall: boolean;
 };
 type RunResolverResolveOptions = {
     key: string;
     dependency: napi.Dependency;
     specifier: FilePath;
     pipeline: string | null | undefined;
-    pluginOptions: RpcPluginOptions;
 };
 type RunResolverResolveResult = {
     invalidations: Array<any>;
@@ -53,8 +69,12 @@ type RunResolverResolveResult = {
 type RunTransformerTransformOptions = {
     key: string;
     env: napi.Environment;
-    options: RpcPluginOptions;
     asset: napi.Asset;
 };
-type RunTransformerTransformResult = [napi.RpcAssetResult, Buffer, string];
+type RunTransformerTransformResult = [
+    napi.RpcAssetResult,
+    Buffer,
+    string,
+    boolean
+];
 export {};

package/lib/types/requests/ConfigRequest.d.ts

@@ -1,8 +1,14 @@
-import type { Async, Config as IConfig, PluginOptions as IPluginOptions, PluginLogger as IPluginLogger, PluginTracer as IPluginTracer, NamedBundle as INamedBundle, BundleGraph as IBundleGraph } from '@atlaspack/types';
+import type { Async, Config as IConfig, PluginOptions as IPluginOptions, PluginLogger as IPluginLogger, PluginTracer as IPluginTracer, NamedBundle as INamedBundle, BundleGraph as IBundleGraph, TransformerSetup } from '@atlaspack/types';
 import type { Config, AtlaspackOptions, InternalFileCreateInvalidation } from '../types';
 import type { LoadedPlugin } from '../AtlaspackConfig';
 import type { RequestResult, RunAPI } from '../RequestTracker';
 import type { ProjectPath } from '../projectPath';
+type Setup<T> = (arg1: {
+    config: IConfig;
+    options: IPluginOptions;
+    logger: IPluginLogger;
+    tracer: IPluginTracer;
+}) => Async<TransformerSetup<T>>;
 export type PluginWithLoadConfig = {
     loadConfig?: (arg1: {
         config: IConfig;
@@ -42,6 +48,7 @@ export type ConfigRequest = {
 };
 export type ConfigRequestResult = undefined;
 export declare function loadPluginConfig<T extends PluginWithLoadConfig>(loadedPlugin: LoadedPlugin<T>, config: Config, options: AtlaspackOptions): Promise<void>;
+export declare function loadPluginSetup<T>(pluginName: string, setup: Setup<T>, config: Config, options: AtlaspackOptions): Promise<void>;
 /**
  * Return value at a given key path within an object.
  *
@@ -57,3 +64,4 @@ export declare function getConfigKeyContentHash(filePath: ProjectPath, configKey
 export declare function runConfigRequest<TResult extends RequestResult>(api: RunAPI<TResult>, configRequest: ConfigRequest): Promise<void>;
 export declare function getConfigHash(config: Config, pluginName: string, options: AtlaspackOptions): Promise<string>;
 export declare function getConfigRequests(configs: Array<Config>): Array<ConfigRequest>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.30.2",
+  "version": "2.31.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -24,21 +24,21 @@
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
     "@atlaspack/build-cache": "2.13.6",
-    "@atlaspack/cache": "3.2.40",
+    "@atlaspack/cache": "3.2.41",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.27.4",
-    "@atlaspack/fs": "2.15.40",
-    "@atlaspack/graph": "3.6.7",
-    "@atlaspack/logger": "2.14.37",
-    "@atlaspack/package-manager": "2.14.45",
-    "@atlaspack/plugin": "2.14.45",
-    "@atlaspack/profiler": "2.15.6",
-    "@atlaspack/rust": "3.15.0",
-    "@atlaspack/types": "2.15.35",
-    "@atlaspack/utils": "3.2.6",
-    "@atlaspack/workers": "2.14.45",
-    "@atlaspack/source-map": "3.2.0",
+    "@atlaspack/feature-flags": "2.27.5",
+    "@atlaspack/fs": "2.15.41",
+    "@atlaspack/graph": "3.6.8",
+    "@atlaspack/logger": "2.14.38",
+    "@atlaspack/package-manager": "2.14.46",
+    "@atlaspack/plugin": "2.14.46",
+    "@atlaspack/profiler": "2.15.7",
+    "@atlaspack/rust": "3.16.0",
+    "@atlaspack/types": "2.15.36",
+    "@atlaspack/utils": "3.2.7",
+    "@atlaspack/workers": "2.14.46",
+    "@atlaspack/source-map": "3.2.1",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",

package/src/Atlaspack.ts

@@ -516,6 +516,7 @@ export default class Atlaspack {
           return result;
         },
         unstable_requestStats: this.#requestTracker.flushStats(),
+        nativeCacheStats: await this.rustAtlaspack?.completeCacheSession(),
         scopeHoistingStats,
       };
 
@@ -543,6 +544,7 @@ export default class Atlaspack {
         type: 'buildFailure',
         diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic],
         unstable_requestStats: this.#requestTracker.flushStats(),
+        nativeCacheStats: await this.rustAtlaspack?.completeCacheSession(),
       };
 
       // @ts-expect-error TS2345

package/src/InternalConfig.ts

@@ -13,7 +13,7 @@ import {identifierRegistry} from './IdentifierRegistry';
 import type {EnvironmentRef} from './EnvironmentManager';
 import {toEnvironmentId} from './EnvironmentManager';
 
-type ConfigOpts = {
+export type ConfigOpts = {
   plugin: PackageName;
   searchPath: ProjectPath;
   isSource?: boolean;

package/src/Transformation.ts

@@ -46,13 +46,13 @@ import UncommittedAsset from './UncommittedAsset';
 import {createAsset} from './assetUtils';
 import summarizeRequest from './summarizeRequest';
 import PluginOptions from './public/PluginOptions';
-import {fromEnvironmentId} from './EnvironmentManager';
 import {optionsProxy} from './utils';
 import {createConfig} from './InternalConfig';
 import {
   loadPluginConfig,
   getConfigRequests,
   ConfigRequest,
+  loadPluginSetup,
 } from './requests/ConfigRequest';
 import {
   createDevDependency,
@@ -71,6 +71,7 @@ import invariant from 'assert';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
 import SourceMap from '@atlaspack/source-map';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {createBuildCache} from '@atlaspack/build-cache';
 
 type GenerateFunc = (input: UncommittedAsset) => Promise<GenerateOutput>;
 
@@ -93,6 +94,10 @@ export type TransformationResult = {
   devDepRequests: Array<DevDepRequest | DevDepRequestRef>;
 };
 
+// Global setup config are not file-specific, so we only need to
+// load them once per build.
+const setupConfig = createBuildCache<string, Config>();
+
 export default class Transformation {
   request: TransformationRequest;
   configs: Map<string, Config>;
@@ -540,12 +545,42 @@ export default class Transformation {
     transformer: LoadedPlugin<Transformer<unknown>>,
     isSource: boolean,
   ): Promise<Config | null | undefined> {
+    // Only load setup config for a transformer once per build.
+    let config = setupConfig.get(transformer.name);
+
+    if (config == null && transformer.plugin.setup != null) {
+      config = createConfig({
+        plugin: transformer.name,
+        searchPath: toProjectPathUnsafe('index'),
+        // Consider project setup config as source
+        isSource: true,
+      });
+
+      await loadPluginSetup(
+        transformer.name,
+        transformer.plugin.setup,
+        config,
+        this.options,
+      );
+
+      setupConfig.set(transformer.name, config);
+    }
+
+    if (config != null) {
+      for (let devDep of config.devDeps) {
+        await this.addDevDependency(devDep);
+      }
+
+      // `loadConfig` is not called for setup configs
+      return config;
+    }
+
     let loadConfig = transformer.plugin.loadConfig;
     if (!loadConfig) {
       return;
     }
 
-    let config = createConfig({
+    config = createConfig({
       plugin: transformer.name,
       isSource,
       // @ts-expect-error TS2322

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -2,9 +2,11 @@ import {
   atlaspackNapiCreate,
   atlaspackNapiBuildAssetGraph,
   atlaspackNapiRespondToFsEvents,
+  atlaspackNapiCompleteSession,
   AtlaspackNapi,
   Lmdb,
   AtlaspackNapiOptions,
+  CacheStats,
 } from '@atlaspack/rust';
 import {NapiWorkerPool} from './NapiWorkerPool';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
@@ -108,4 +110,10 @@ export class AtlaspackV3 {
 
     return needsRebuild;
   }
+
+  async completeCacheSession(): Promise<CacheStats> {
+    return (await atlaspackNapiCompleteSession(
+      this._atlaspack_napi,
+    )) as CacheStats;
+  }
 }

package/src/atlaspack-v3/NapiWorkerPool.ts

@@ -46,6 +46,23 @@ export class NapiWorkerPool implements INapiWorkerPool {
     }
   }
 
+  clearAllWorkerState(): Promise<void[]> {
+    return Promise.all(
+      this.#workers.map(
+        (worker) =>
+          new Promise<void>((res) => {
+            worker.postMessage('clearState');
+
+            worker.once('message', (message) => {
+              if (message == 'stateCleared') {
+                res();
+              }
+            });
+          }),
+      ),
+    );
+  }
+
   workerCount(): number {
     return this.#workerCount;
   }

package/src/atlaspack-v3/index.ts

@@ -3,3 +3,4 @@ export {AtlaspackV3} from './AtlaspackV3';
 export {NapiWorkerPool} from './NapiWorkerPool';
 export * from './AtlaspackV3';
 export * from './NapiWorkerPool';
+export type {CacheStats} from '@atlaspack/rust';

package/src/atlaspack-v3/worker/compat/plugin-config.ts

@@ -6,57 +6,25 @@ import type {
   FileCreateInvalidation,
   ConfigResultWithFilePath,
   PackageJSON,
-  PackageManager as IPackageManager,
 } from '@atlaspack/types';
 
-import type {FileSystem as IFileSystem} from '@atlaspack/fs';
 import ClassicPublicConfig from '../../../public/Config';
-
-export type PluginConfigOptions = {
-  isSource: boolean;
-  searchPath: FilePath;
-  projectRoot: FilePath;
-  env: Environment;
-  fs: IFileSystem;
-  packageManager: IPackageManager;
-};
+import {type ConfigOpts, createConfig} from '../../../InternalConfig';
 
 export class PluginConfig implements IPluginConfig {
   isSource: boolean;
   searchPath: FilePath;
-  // @ts-expect-error TS2564
-  #projectRoot: FilePath;
   env: Environment;
   #inner: ClassicPublicConfig;
 
-  constructor({
-    env,
-    isSource,
-    searchPath,
-    projectRoot,
-    fs,
-    packageManager,
-  }: PluginConfigOptions) {
-    this.env = env;
-    this.isSource = isSource;
-    this.searchPath = searchPath;
+  constructor(configOpts: ConfigOpts, options: any) {
+    let internalConfig = createConfig(configOpts);
 
-    this.#inner = new ClassicPublicConfig(
-      // @ts-expect-error TS2345
-      {
-        invalidateOnConfigKeyChange: [],
-        invalidateOnFileCreate: [],
-        invalidateOnFileChange: new Set(),
-        devDeps: [],
-        searchPath: searchPath.replace(projectRoot + '/', ''),
-      },
-      {
-        projectRoot,
-        inputFS: fs,
-        outputFS: fs,
-        packageManager,
-      },
-    );
+    this.isSource = internalConfig.isSource;
+    this.searchPath = internalConfig.searchPath;
+    // @ts-expect-error TS2564
+    this.env = internalConfig.env;
+    this.#inner = new ClassicPublicConfig(internalConfig, options);
   }
 
   // eslint-disable-next-line no-unused-vars

package/src/atlaspack-v3/worker/compat/plugin-options.ts

@@ -14,6 +14,7 @@ import type {FeatureFlags} from '@atlaspack/feature-flags';
 
 export class PluginOptions implements IPluginOptions {
   #options: IPluginOptions;
+  used = false;
 
   get env(): EnvMap {
     if (!('env' in this.#options)) {
@@ -27,6 +28,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('projectRoot' in this.#options)) {
       throw new Error('PluginOptions.projectRoot');
     }
+    this.used = true;
     return this.#options.projectRoot;
   }
 
@@ -34,6 +36,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('packageManager' in this.#options)) {
       throw new Error('PluginOptions.packageManager');
     }
+    this.used = true;
     return this.#options.packageManager;
   }
 
@@ -41,6 +44,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('mode' in this.#options)) {
       throw new Error('PluginOptions.mode');
     }
+    this.used = true;
     return this.#options.mode;
   }
 
@@ -49,6 +53,7 @@ export class PluginOptions implements IPluginOptions {
       return 'UNKNOWN VERSION';
       // throw new Error('PluginOptions.parcelVersion');
     }
+    this.used = true;
     return this.#options.parcelVersion;
   }
 
@@ -56,6 +61,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('hmrOptions' in this.#options)) {
       throw new Error('PluginOptions.hmrOptions');
     }
+    this.used = true;
     return this.#options.hmrOptions;
   }
 
@@ -63,6 +69,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('serveOptions' in this.#options)) {
       throw new Error('PluginOptions.serveOptions');
     }
+    this.used = true;
     return this.#options.serveOptions;
   }
 
@@ -70,6 +77,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('shouldBuildLazily' in this.#options)) {
       throw new Error('PluginOptions.shouldBuildLazily');
     }
+    this.used = true;
     return this.#options.shouldBuildLazily;
   }
 
@@ -77,6 +85,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('shouldAutoInstall' in this.#options)) {
       throw new Error('PluginOptions.shouldAutoInstall');
     }
+    this.used = true;
     return this.#options.shouldAutoInstall;
   }
 
@@ -91,6 +100,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('cacheDir' in this.#options)) {
       throw new Error('PluginOptions.cacheDir');
     }
+    this.used = true;
     return this.#options.cacheDir;
   }
 
@@ -98,6 +108,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('inputFS' in this.#options)) {
       throw new Error('PluginOptions.inputFS');
     }
+    this.used = true;
     return this.#options.inputFS;
   }
 
@@ -105,6 +116,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('outputFS' in this.#options)) {
       throw new Error('PluginOptions.outputFS');
     }
+    this.used = true;
     return this.#options.outputFS;
   }
 
@@ -112,6 +124,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('instanceId' in this.#options)) {
       throw new Error('PluginOptions.instanceId');
     }
+    this.used = true;
     return this.#options.instanceId;
   }
 
@@ -119,6 +132,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('detailedReport' in this.#options)) {
       throw new Error('PluginOptions.detailedReport');
     }
+    this.used = true;
     return this.#options.detailedReport;
   }
 
@@ -126,6 +140,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('featureFlags' in this.#options)) {
       throw new Error('PluginOptions.featureFlags');
     }
+    this.used = true;
     return this.#options.featureFlags;
   }