@atlaspack/core 2.12.1-canary.3464 → 2.12.1-canary.3466

package/lib/Atlaspack.js

@@ -64,7 +64,7 @@ function _utils2() {
   };
   return data;
 }
-var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
+var _AtlaspackConfig = require("./AtlaspackConfig");
 function _logger() {
   const data = _interopRequireDefault(require("@atlaspack/logger"));
   _logger = function () {
@@ -203,7 +203,7 @@ class Atlaspack {
     let {
       config
     } = await (0, _AtlaspackConfigRequest.loadAtlaspackConfig)(resolvedOptions);
-    this.#config = new _AtlaspackConfig.default(config, resolvedOptions);
+    this.#config = new _AtlaspackConfig.AtlaspackConfig(config, resolvedOptions);
     if (this.#initialOptions.workerFarm) {
       if (this.#initialOptions.workerFarm.ending) {
         throw new Error('Supplied WorkerFarm is ending');

package/lib/AtlaspackConfig.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.AtlaspackConfig = void 0;
 function _diagnostic() {
   const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
   _diagnostic = function () {
@@ -289,7 +289,7 @@ class AtlaspackConfig {
     });
   }
 }
-exports.default = AtlaspackConfig;
+exports.AtlaspackConfig = AtlaspackConfig;
 function getConfigPaths(options, nodes) {
   return nodes.map(node => node !== '...' ? getConfigPath(options, node) : null).filter(Boolean);
 }

package/lib/Transformation.js

@@ -47,7 +47,7 @@ function _utils() {
   return data;
 }
 var _Dependency = require("./Dependency");
-var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
+var _AtlaspackConfig = require("./AtlaspackConfig");
 var _PathRequest = require("./requests/PathRequest");
 var _Asset = require("./public/Asset");
 var _UncommittedAsset = _interopRequireDefault(require("./UncommittedAsset"));

package/lib/Validation.js

@@ -32,7 +32,7 @@ function _diagnostic() {
   };
   return data;
 }
-var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
+var _AtlaspackConfig = require("./AtlaspackConfig");
 var _UncommittedAsset = _interopRequireDefault(require("./UncommittedAsset"));
 var _assetUtils = require("./assetUtils");
 var _Asset = require("./public/Asset");

package/lib/atlaspack-v3/worker/compat/mutable-asset.js

@@ -19,6 +19,7 @@ class MutableAsset {
   #inner;
   #ast;
   #contents;
+  #astDirty;
   get astGenerator() {
     throw new Error('get MutableAsset.astGenerator');
   }
@@ -47,6 +48,7 @@ class MutableAsset {
     this.#contents = Buffer.from(asset.code);
     this.fs = fs;
     this.env = env;
+    this.#astDirty = false;
   }
 
   // eslint-disable-next-line require-await
@@ -54,10 +56,11 @@ class MutableAsset {
     return this.#ast;
   }
   setAST(ast) {
+    this.#astDirty = true;
     this.#ast = ast;
   }
   isASTDirty() {
-    throw new Error('MutableAsset.isASTDirty()');
+    return this.#astDirty;
   }
 
   // eslint-disable-next-line require-await
@@ -91,7 +94,8 @@ class MutableAsset {
     });
   }
   getMap() {
-    throw new Error('MutableAsset.getMap');
+    // TODO: Provide source maps once they exist
+    return Promise.resolve(null);
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -122,23 +126,23 @@ class MutableAsset {
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnFileChange() {
-    throw new Error('MutableAsset.invalidateOnFileChange()');
+    // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnFileCreate() {
-    throw new Error('MutableAsset.invalidateOnFileCreate()');
+    // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnEnvChange() {
-    throw new Error('MutableAsset.invalidateOnEnvChange()');
+    // TODO: Forward invalidations to Rust
   }
   invalidateOnStartup() {
-    throw new Error('MutableAsset.invalidateOnStartup()');
+    // TODO: Forward invalidations to Rust
   }
   invalidateOnBuild() {
-    throw new Error('MutableAsset.invalidateOnBuild()');
+    // TODO: Forward invalidations to Rust
   }
 }
 exports.MutableAsset = MutableAsset;

package/lib/atlaspack-v3/worker/worker.js

@@ -96,7 +96,7 @@ class AtlaspackWorker {
     dependency: napiDependency,
     specifier,
     pipeline,
-    projectRoot
+    options
   }) => {
     const state = this.#resolvers.get(key);
     if (!state) {
@@ -104,7 +104,7 @@ class AtlaspackWorker {
     }
     let packageManager = state.packageManager;
     if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, projectRoot);
+      packageManager = new (_packageManager().NodePackageManager)(this.#fs, options.projectRoot);
       state.packageManager = packageManager;
     }
     const env = new _compat.Environment(napiDependency.env);
@@ -113,9 +113,9 @@ class AtlaspackWorker {
       logger: new _compat.PluginLogger(),
       tracer: new _compat.PluginTracer(),
       options: new _compat.PluginOptions({
+        ...options,
         packageManager,
         shouldAutoInstall: false,
-        projectRoot,
         inputFS: this.#fs,
         outputFS: this.#fs
       })
@@ -164,7 +164,7 @@ class AtlaspackWorker {
   runTransformerTransform = (0, _jsCallable.jsCallable)(async ({
     key,
     env: napiEnv,
-    projectRoot,
+    options,
     asset: innerAsset
   }) => {
     var _transformer$loadConf;
@@ -174,7 +174,7 @@ class AtlaspackWorker {
     }
     let packageManager = state.packageManager;
     if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, projectRoot);
+      packageManager = new (_packageManager().NodePackageManager)(this.#fs, options.projectRoot);
       state.packageManager = packageManager;
     }
     const transformer = state.transformer;
@@ -184,9 +184,9 @@ class AtlaspackWorker {
       logger: new _compat.PluginLogger(),
       tracer: new _compat.PluginTracer(),
       options: new _compat.PluginOptions({
+        ...options,
         packageManager,
         shouldAutoInstall: false,
-        projectRoot,
         inputFS: this.#fs,
         outputFS: this.#fs
       })
@@ -222,21 +222,20 @@ class AtlaspackWorker {
     });
     if (transformer.generate) {
       const ast = await mutableAsset.getAST();
-      if (!ast) {
-        throw new Error('Transformer.generate.ast');
-      }
-      // $FlowFixMe "Cannot call `transformer.generate` because  undefined [1] is not a function." 🤷‍♀️
-      const output = await transformer.generate({
-        asset: mutableAsset,
-        ast,
-        ...defaultOptions
-      });
-      if (typeof output.content === 'string') {
-        mutableAsset.setCode(output.content);
-      } else if (output.content instanceof Buffer) {
-        mutableAsset.setBuffer(output.content);
-      } else {
-        mutableAsset.setStream(output.content);
+      if (ast) {
+        // $FlowFixMe "Cannot call `transformer.generate` because  undefined [1] is not a function." 🤷‍♀️
+        const output = await transformer.generate({
+          asset: mutableAsset,
+          ast,
+          ...defaultOptions
+        });
+        if (typeof output.content === 'string') {
+          mutableAsset.setCode(output.content);
+        } else if (output.content instanceof Buffer) {
+          mutableAsset.setBuffer(output.content);
+        } else {
+          mutableAsset.setStream(output.content);
+        }
       }
     }
     (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');

package/lib/registerCoreWithSerializer.js

@@ -14,7 +14,7 @@ function _graph() {
 var _serializer = require("./serializer");
 var _AssetGraph = _interopRequireDefault(require("./AssetGraph"));
 var _BundleGraph = _interopRequireDefault(require("./BundleGraph"));
-var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
+var _AtlaspackConfig = require("./AtlaspackConfig");
 var _RequestTracker = require("./RequestTracker");
 var _Config = _interopRequireDefault(require("./public/Config"));
 var _package = _interopRequireDefault(require("../package.json"));
@@ -35,7 +35,7 @@ function registerCoreWithSerializer() {
     Config: _Config.default,
     BundleGraph: _BundleGraph.default,
     Graph: _graph().Graph,
-    AtlaspackConfig: _AtlaspackConfig.default,
+    AtlaspackConfig: _AtlaspackConfig.AtlaspackConfig,
     RequestGraph: _RequestTracker.RequestGraph
     // $FlowFixMe[unclear-type]
   })) {

package/lib/requests/AtlaspackConfigRequest.js

@@ -53,12 +53,12 @@ function _assert() {
   };
   return data;
 }
-var _AtlaspackConfig = _interopRequireDefault(require("../AtlaspackConfig.schema"));
-var _utils2 = require("../utils");
-var _AtlaspackConfig2 = _interopRequireDefault(require("../AtlaspackConfig"));
+var _AtlaspackConfig = require("../AtlaspackConfig");
+var _AtlaspackConfig2 = _interopRequireDefault(require("../AtlaspackConfig.schema"));
 var _buildCache = require("../buildCache");
 var _projectPath = require("../projectPath");
 var _RequestTracker = require("../RequestTracker");
+var _utils2 = require("../utils");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
@@ -113,7 +113,7 @@ function getCachedAtlaspackConfig(result, options) {
   if (config) {
     return config;
   }
-  config = new _AtlaspackConfig2.default(processedConfig, options);
+  config = new _AtlaspackConfig.AtlaspackConfig(processedConfig, options);
   atlaspackConfigCache.set(cachePath, config);
   return config;
 }
@@ -396,7 +396,7 @@ function validateConfigFile(config, relativePath) {
       }
     });
   }
-  _utils().validateSchema.diagnostic(_AtlaspackConfig.default, {
+  _utils().validateSchema.diagnostic(_AtlaspackConfig2.default, {
     data: config,
     filePath: relativePath
   }, '@atlaspack/core', 'Invalid Parcel Config');

package/lib/requests/PathRequest.js

@@ -43,7 +43,7 @@ function _utils() {
 var _ReporterRunner = require("../ReporterRunner");
 var _Dependency = require("../public/Dependency");
 var _PluginOptions = _interopRequireDefault(require("../public/PluginOptions"));
-var _AtlaspackConfig = _interopRequireDefault(require("../AtlaspackConfig"));
+var _AtlaspackConfig = require("../AtlaspackConfig");
 var _AtlaspackConfigRequest = _interopRequireWildcard(require("./AtlaspackConfigRequest"));
 var _utils2 = require("../utils");
 var _projectPath = require("../projectPath");

package/lib/requests/ValidationRequest.js

@@ -11,7 +11,7 @@ function _nullthrows() {
   };
   return data;
 }
-var _AtlaspackConfig = _interopRequireDefault(require("../AtlaspackConfig"));
+var _AtlaspackConfig = require("../AtlaspackConfig");
 var _ReporterRunner = require("../ReporterRunner");
 var _Validation = _interopRequireDefault(require("../Validation"));
 var _AtlaspackConfigRequest = _interopRequireDefault(require("./AtlaspackConfigRequest"));
@@ -34,7 +34,7 @@ function createValidationRequest(input) {
         config: processedConfig,
         cachePath
       } = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
-      let config = new _AtlaspackConfig.default(processedConfig, options);
+      let config = new _AtlaspackConfig.AtlaspackConfig(processedConfig, options);
       let trackedRequestsDesc = assetRequests.filter(request => {
         return config.getValidatorNames(request.filePath).length > 0;
       });

package/lib/requests/WriteBundleRequest.js

@@ -45,7 +45,7 @@ function _logger() {
   return data;
 }
 var _DevDepRequest = require("./DevDepRequest");
-var _AtlaspackConfig = _interopRequireDefault(require("../AtlaspackConfig"));
+var _AtlaspackConfig = require("../AtlaspackConfig");
 function _diagnostic() {
   const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
   _diagnostic = function () {

package/lib/worker.js

@@ -35,7 +35,7 @@ var _Transformation = _interopRequireDefault(require("./Transformation"));
 var _ReporterRunner = require("./ReporterRunner");
 var _PackagerRunner = _interopRequireDefault(require("./PackagerRunner"));
 var _Validation = _interopRequireDefault(require("./Validation"));
-var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
+var _AtlaspackConfig = require("./AtlaspackConfig");
 var _registerCoreWithSerializer = require("./registerCoreWithSerializer");
 var _buildCache = require("./buildCache");
 function _sourceMap() {
@@ -98,7 +98,7 @@ async function loadConfig(cachePath, options) {
     return config;
   }
   let processedConfig = (0, _nullthrows().default)(await options.cache.get(cachePath));
-  config = new _AtlaspackConfig.default(processedConfig, options);
+  config = new _AtlaspackConfig.AtlaspackConfig(processedConfig, options);
   atlaspackConfigCache.set(cachePath, config);
   (0, _featureFlags().setFeatureFlags)(options.featureFlags);
   return config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3464+b66723585",
+  "version": "2.12.1-canary.3466+f92a71f3e",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/diagnostic": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/events": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/feature-flags": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/fs": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/graph": "3.2.1-canary.3464+b66723585",
-    "@atlaspack/logger": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/package-manager": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/plugin": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/profiler": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/rust": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/types": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/utils": "2.12.1-canary.3464+b66723585",
-    "@atlaspack/workers": "2.12.1-canary.3464+b66723585",
+    "@atlaspack/cache": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/diagnostic": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/events": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/feature-flags": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/fs": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/graph": "3.2.1-canary.3466+f92a71f3e",
+    "@atlaspack/logger": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/package-manager": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/plugin": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/profiler": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/rust": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/types": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/utils": "2.12.1-canary.3466+f92a71f3e",
+    "@atlaspack/workers": "2.12.1-canary.3466+f92a71f3e",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -64,5 +64,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "b667235859922e485011908e0d4069ab95598be5"
+  "gitHead": "f92a71f3e7673b1c0c89ec4c3345f8ae10325275"
 }

package/src/Atlaspack.js

@@ -31,7 +31,7 @@ import resolveOptions from './resolveOptions';
 import {ValueEmitter} from '@atlaspack/events';
 import {registerCoreWithSerializer} from './registerCoreWithSerializer';
 import {PromiseQueue} from '@atlaspack/utils';
-import AtlaspackConfig from './AtlaspackConfig';
+import {AtlaspackConfig} from './AtlaspackConfig';
 import logger from '@atlaspack/logger';
 import RequestTracker, {
   getWatcherOptions,

package/src/AtlaspackConfig.js

@@ -55,7 +55,7 @@ export type LoadedPlugin<T> = {|
   range?: ?SemverRange,
 |};
 
-export default class AtlaspackConfig {
+export class AtlaspackConfig {
   options: AtlaspackOptions;
   filePath: ProjectPath;
   resolvers: PureAtlaspackConfigPipeline;

package/src/PackagerRunner.js

@@ -18,7 +18,7 @@ import type {
   ReportFn,
   RequestInvalidation,
 } from './types';
-import type AtlaspackConfig, {LoadedPlugin} from './AtlaspackConfig';
+import type {AtlaspackConfig, LoadedPlugin} from './AtlaspackConfig';
 import type InternalBundleGraph from './BundleGraph';
 import type {ConfigRequest} from './requests/ConfigRequest';
 import type {DevDepSpecifier} from './requests/DevDepRequest';

package/src/Transformation.js

@@ -35,7 +35,7 @@ import ThrowableDiagnostic, {
 import {SOURCEMAP_EXTENSIONS} from '@atlaspack/utils';
 
 import {createDependency} from './Dependency';
-import AtlaspackConfig from './AtlaspackConfig';
+import {AtlaspackConfig} from './AtlaspackConfig';
 // TODO: eventually call path request as sub requests
 import {ResolverRunner} from './requests/PathRequest';
 import {

package/src/Validation.js

@@ -9,7 +9,7 @@ import path from 'path';
 import {resolveConfig} from '@atlaspack/utils';
 import logger, {PluginLogger} from '@atlaspack/logger';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
-import AtlaspackConfig from './AtlaspackConfig';
+import {AtlaspackConfig} from './AtlaspackConfig';
 import UncommittedAsset from './UncommittedAsset';
 import {createAsset} from './assetUtils';
 import {Asset} from './public/Asset';

package/src/applyRuntimes.js

@@ -11,7 +11,7 @@ import type {
   DevDepRequest,
   AtlaspackOptions,
 } from './types';
-import type AtlaspackConfig from './AtlaspackConfig';
+import type {AtlaspackConfig} from './AtlaspackConfig';
 import type PluginOptions from './public/PluginOptions';
 import type {RequestResult, RunAPI} from './RequestTracker';
 

package/src/atlaspack-v3/worker/compat/mutable-asset.js

@@ -43,6 +43,7 @@ export class MutableAsset implements IMutableAsset {
   #inner: InnerAsset;
   #ast: ?AST;
   #contents: Buffer;
+  #astDirty: boolean;
 
   get astGenerator(): ?ASTGenerator {
     throw new Error('get MutableAsset.astGenerator');
@@ -74,6 +75,7 @@ export class MutableAsset implements IMutableAsset {
     this.#contents = Buffer.from(asset.code);
     this.fs = fs;
     this.env = env;
+    this.#astDirty = false;
   }
 
   // eslint-disable-next-line require-await
@@ -82,11 +84,12 @@ export class MutableAsset implements IMutableAsset {
   }
 
   setAST(ast: AST): void {
+    this.#astDirty = true;
     this.#ast = ast;
   }
 
   isASTDirty(): boolean {
-    throw new Error('MutableAsset.isASTDirty()');
+    return this.#astDirty;
   }
 
   // eslint-disable-next-line require-await
@@ -128,7 +131,8 @@ export class MutableAsset implements IMutableAsset {
   }
 
   getMap(): Promise<?SourceMap> {
-    throw new Error('MutableAsset.getMap');
+    // TODO: Provide source maps once they exist
+    return Promise.resolve(null);
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -161,24 +165,24 @@ export class MutableAsset implements IMutableAsset {
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnFileChange(invalidation: FilePath): void {
-    throw new Error('MutableAsset.invalidateOnFileChange()');
+    // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnFileCreate(invalidation: FileCreateInvalidation): void {
-    throw new Error('MutableAsset.invalidateOnFileCreate()');
+    // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnEnvChange(invalidation: string): void {
-    throw new Error('MutableAsset.invalidateOnEnvChange()');
+    // TODO: Forward invalidations to Rust
   }
 
   invalidateOnStartup(): void {
-    throw new Error('MutableAsset.invalidateOnStartup()');
+    // TODO: Forward invalidations to Rust
   }
 
   invalidateOnBuild(): void {
-    throw new Error('MutableAsset.invalidateOnBuild()');
+    // TODO: Forward invalidations to Rust
   }
 }

package/src/atlaspack-v3/worker/worker.js

@@ -76,13 +76,7 @@ export class AtlaspackWorker {
     [RunResolverResolveOptions],
     Promise<RunResolverResolveResult>,
   > = jsCallable(
-    async ({
-      key,
-      dependency: napiDependency,
-      specifier,
-      pipeline,
-      projectRoot,
-    }) => {
+    async ({key, dependency: napiDependency, specifier, pipeline, options}) => {
       const state = this.#resolvers.get(key);
       if (!state) {
         throw new Error(`Resolver not found: ${key}`);
@@ -90,7 +84,7 @@ export class AtlaspackWorker {
 
       let packageManager = state.packageManager;
       if (!packageManager) {
-        packageManager = new NodePackageManager(this.#fs, projectRoot);
+        packageManager = new NodePackageManager(this.#fs, options.projectRoot);
         state.packageManager = packageManager;
       }
 
@@ -101,9 +95,9 @@ export class AtlaspackWorker {
         logger: new PluginLogger(),
         tracer: new PluginTracer(),
         options: new PluginOptions({
+          ...options,
           packageManager,
           shouldAutoInstall: false,
-          projectRoot,
           inputFS: this.#fs,
           outputFS: this.#fs,
         }),
@@ -155,71 +149,68 @@ export class AtlaspackWorker {
   runTransformerTransform: JsCallable<
     [RunTransformerTransformOptions],
     Promise<RunTransformerTransformResult>,
-  > = jsCallable(
-    async ({key, env: napiEnv, projectRoot, asset: innerAsset}) => {
-      const state = this.#transformers.get(key);
-      if (!state) {
-        throw new Error(`Transformer not found: ${key}`);
-      }
-
-      let packageManager = state.packageManager;
-      if (!packageManager) {
-        packageManager = new NodePackageManager(this.#fs, projectRoot);
-        state.packageManager = packageManager;
-      }
-
-      const transformer: Transformer<any> = state.transformer;
-      const env = new Environment(napiEnv);
-      const mutableAsset = new MutableAsset(innerAsset, this.#fs, env);
-      const defaultOptions = {
-        logger: new PluginLogger(),
-        tracer: new PluginTracer(),
-        options: new PluginOptions({
-          packageManager,
-          shouldAutoInstall: false,
-          projectRoot,
-          inputFS: this.#fs,
-          outputFS: this.#fs,
-        }),
-      };
-
-      const config = await transformer.loadConfig?.({
-        config: new PluginConfig({
-          env,
-          isSource: true,
-          searchPath: '',
-        }),
-        ...defaultOptions,
-      });
-
-      if (transformer.parse) {
-        const ast = await transformer.parse({
-          asset: mutableAsset,
-          config,
-          get resolve() {
-            throw new Error('Transformer.parse.resolve()');
-          },
-          ...defaultOptions,
-        });
-        if (ast) {
-          mutableAsset.setAST(ast);
-        }
-      }
-
-      const result = await state.transformer.transform({
+  > = jsCallable(async ({key, env: napiEnv, options, asset: innerAsset}) => {
+    const state = this.#transformers.get(key);
+    if (!state) {
+      throw new Error(`Transformer not found: ${key}`);
+    }
+
+    let packageManager = state.packageManager;
+    if (!packageManager) {
+      packageManager = new NodePackageManager(this.#fs, options.projectRoot);
+      state.packageManager = packageManager;
+    }
+
+    const transformer: Transformer<any> = state.transformer;
+    const env = new Environment(napiEnv);
+    const mutableAsset = new MutableAsset(innerAsset, this.#fs, env);
+    const defaultOptions = {
+      logger: new PluginLogger(),
+      tracer: new PluginTracer(),
+      options: new PluginOptions({
+        ...options,
+        packageManager,
+        shouldAutoInstall: false,
+        inputFS: this.#fs,
+        outputFS: this.#fs,
+      }),
+    };
+
+    const config = await transformer.loadConfig?.({
+      config: new PluginConfig({
+        env,
+        isSource: true,
+        searchPath: '',
+      }),
+      ...defaultOptions,
+    });
+
+    if (transformer.parse) {
+      const ast = await transformer.parse({
         asset: mutableAsset,
         config,
         get resolve() {
-          throw new Error('Transformer.transform.resolve()');
+          throw new Error('Transformer.parse.resolve()');
         },
         ...defaultOptions,
       });
-
-      if (transformer.generate) {
-        const ast = await mutableAsset.getAST();
-        if (!ast) {
-          throw new Error('Transformer.generate.ast');
-        }
+      if (ast) {
+        mutableAsset.setAST(ast);
+      }
+    }
+
+    const result = await state.transformer.transform({
+      asset: mutableAsset,
+      config,
+      get resolve() {
+        throw new Error('Transformer.transform.resolve()');
+      },
+      ...defaultOptions,
+    });
+
+    if (transformer.generate) {
+      const ast = await mutableAsset.getAST();
+      if (ast) {
         // $FlowFixMe "Cannot call `transformer.generate` because  undefined [1] is not a function." 🤷‍♀️
         const output = await transformer.generate({
           asset: mutableAsset,
@@ -235,38 +226,38 @@ export class AtlaspackWorker {
           mutableAsset.setStream(output.content);
         }
       }
-
-      assert(
-        result.length === 1,
-        '[V3] Unimplemented: Multiple asset return from Node transformer',
-      );
-
-      assert(
-        result[0] === mutableAsset,
-        '[V3] Unimplemented: New asset returned from Node transformer',
-      );
-
-      return {
-        asset: {
-          id: mutableAsset.id,
-          bundleBehavior: bundleBehaviorMap.intoNullable(
-            mutableAsset.bundleBehavior,
-          ),
-          filePath: mutableAsset.filePath,
-          type: mutableAsset.type,
-          code: Array.from(await mutableAsset.getBuffer()),
-          meta: mutableAsset.meta,
-          pipeline: mutableAsset.pipeline,
-          query: mutableAsset.query.toString(),
-          symbols: mutableAsset.symbols.intoNapi(),
-          uniqueKey: mutableAsset.uniqueKey,
-          sideEffects: mutableAsset.sideEffects,
-          isBundleSplittable: mutableAsset.isBundleSplittable,
-          isSource: mutableAsset.isSource,
-        },
-      };
-    },
-  );
+    }
+
+    assert(
+      result.length === 1,
+      '[V3] Unimplemented: Multiple asset return from Node transformer',
+    );
+
+    assert(
+      result[0] === mutableAsset,
+      '[V3] Unimplemented: New asset returned from Node transformer',
+    );
+
+    return {
+      asset: {
+        id: mutableAsset.id,
+        bundleBehavior: bundleBehaviorMap.intoNullable(
+          mutableAsset.bundleBehavior,
+        ),
+        filePath: mutableAsset.filePath,
+        type: mutableAsset.type,
+        code: Array.from(await mutableAsset.getBuffer()),
+        meta: mutableAsset.meta,
+        pipeline: mutableAsset.pipeline,
+        query: mutableAsset.query.toString(),
+        symbols: mutableAsset.symbols.intoNapi(),
+        uniqueKey: mutableAsset.uniqueKey,
+        sideEffects: mutableAsset.sideEffects,
+        isBundleSplittable: mutableAsset.isBundleSplittable,
+        isSource: mutableAsset.isSource,
+      },
+    };
+  });
 }
 
 napi.registerWorker(workerData.tx_worker, new AtlaspackWorker());
@@ -288,12 +279,17 @@ type LoadPluginOptions = {|
   resolveFrom: string,
 |};
 
+type RpcPluginOptions = {|
+  projectRoot: string,
+  mode: string,
+|};
+
 type RunResolverResolveOptions = {|
   key: string,
   dependency: napi.Dependency,
   specifier: FilePath,
   pipeline: ?string,
-  projectRoot: string,
+  options: RpcPluginOptions,
 |};
 
 type RunResolverResolveResult = {|
@@ -317,7 +313,7 @@ type RunResolverResolveResult = {|
 type RunTransformerTransformOptions = {|
   key: string,
   env: napi.Environment,
-  projectRoot: string,
+  options: RpcPluginOptions,
   asset: napi.Asset,
 |};
 

package/src/registerCoreWithSerializer.js

@@ -3,7 +3,7 @@ import {Graph} from '@atlaspack/graph';
 import {registerSerializableClass} from './serializer';
 import AssetGraph from './AssetGraph';
 import BundleGraph from './BundleGraph';
-import AtlaspackConfig from './AtlaspackConfig';
+import {AtlaspackConfig} from './AtlaspackConfig';
 import {RequestGraph} from './RequestTracker';
 import Config from './public/Config';
 import packageJson from '../package.json';

package/src/requests/AtlaspackConfigRequest.js

@@ -33,12 +33,12 @@ import {parse} from 'json5';
 import path from 'path';
 import invariant from 'assert';
 
+import {AtlaspackConfig} from '../AtlaspackConfig';
 import AtlaspackConfigSchema from '../AtlaspackConfig.schema';
-import {optionsProxy} from '../utils';
-import AtlaspackConfig from '../AtlaspackConfig';
 import {createBuildCache} from '../buildCache';
 import {toProjectPath} from '../projectPath';
 import {requestTypes} from '../RequestTracker';
+import {optionsProxy} from '../utils';
 
 type ConfigMap<K, V> = {[K]: V, ...};
 

package/src/requests/BundleGraphRequest.js

@@ -2,7 +2,7 @@
 
 import type {Async, Bundle as IBundle, Namer} from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
-import type AtlaspackConfig, {LoadedPlugin} from '../AtlaspackConfig';
+import type {AtlaspackConfig, LoadedPlugin} from '../AtlaspackConfig';
 import type {StaticRunOpts, RunAPI} from '../RequestTracker';
 import type {
   Asset,

package/src/requests/DevDepRequest.js

@@ -4,7 +4,7 @@ import type {
   SemverRange,
   Invalidations,
 } from '@atlaspack/types';
-import type AtlaspackConfig from '../AtlaspackConfig';
+import type {AtlaspackConfig} from '../AtlaspackConfig';
 import type {
   DevDepRequest,
   AtlaspackOptions,

package/src/requests/PathRequest.js

@@ -28,7 +28,7 @@ import {normalizePath} from '@atlaspack/utils';
 import {report} from '../ReporterRunner';
 import {getPublicDependency} from '../public/Dependency';
 import PluginOptions from '../public/PluginOptions';
-import AtlaspackConfig from '../AtlaspackConfig';
+import {AtlaspackConfig, type LoadedPlugin} from '../AtlaspackConfig';
 import createAtlaspackConfigRequest, {
   getCachedAtlaspackConfig,
 } from './AtlaspackConfigRequest';
@@ -41,7 +41,6 @@ import {
 } from '../projectPath';
 import {Priority} from '../types';
 import {createBuildCache} from '../buildCache';
-import type {LoadedPlugin} from '../AtlaspackConfig';
 import {createConfig} from '../InternalConfig';
 import {loadPluginConfig, runConfigRequest} from './ConfigRequest';
 import {

package/src/requests/ValidationRequest.js

@@ -6,7 +6,7 @@ import type {AssetGroup} from '../types';
 import type {ConfigAndCachePath} from './AtlaspackConfigRequest';
 
 import nullthrows from 'nullthrows';
-import AtlaspackConfig from '../AtlaspackConfig';
+import {AtlaspackConfig} from '../AtlaspackConfig';
 import {report} from '../ReporterRunner';
 import Validation from '../Validation';
 import createAtlaspackConfigRequest from './AtlaspackConfigRequest';

package/src/requests/WriteBundleRequest.js

@@ -36,7 +36,7 @@ import {
   createDevDependency,
   runDevDepRequest,
 } from './DevDepRequest';
-import AtlaspackConfig from '../AtlaspackConfig';
+import {AtlaspackConfig} from '../AtlaspackConfig';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import {PluginTracer, tracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';

package/src/worker.js

@@ -20,7 +20,7 @@ import Transformation, {
 import {reportWorker, report} from './ReporterRunner';
 import PackagerRunner, {type RunPackagerRunnerResult} from './PackagerRunner';
 import Validation, {type ValidationOpts} from './Validation';
-import AtlaspackConfig from './AtlaspackConfig';
+import {AtlaspackConfig} from './AtlaspackConfig';
 import {registerCoreWithSerializer} from './registerCoreWithSerializer';
 import {clearBuildCaches} from './buildCache';
 import {init as initSourcemaps} from '@parcel/source-map';

package/test/AtlaspackConfig.test.js

@@ -1,14 +1,17 @@
 // @flow strict-local
 
-import AtlaspackConfig from '../src/AtlaspackConfig';
 import assert from 'assert';
 import path from 'path';
-import sinon from 'sinon';
+
 import logger from '@atlaspack/logger';
 import {inputFS} from '@atlaspack/test-utils';
+import sinon from 'sinon';
+
+import {AtlaspackConfig} from '../src/AtlaspackConfig';
+import {toProjectPath} from '../src/projectPath';
 import {parseAndProcessConfig} from '../src/requests/AtlaspackConfigRequest';
+
 import {DEFAULT_OPTIONS} from './test-utils';
-import {toProjectPath} from '../src/projectPath';
 
 const ATLASPACKRC_PATH = toProjectPath('/', '/.parcelrc');
 

package/test/AtlaspackConfigRequest.test.js

@@ -1,8 +1,11 @@
 // @flow
 import assert from 'assert';
-import nullthrows from 'nullthrows';
 import path from 'path';
-import AtlaspackConfig from '../src/AtlaspackConfig';
+
+import nullthrows from 'nullthrows';
+
+import {AtlaspackConfig} from '../src/AtlaspackConfig';
+import {toProjectPath} from '../src/projectPath';
 import {
   validateConfigFile,
   mergePipelines,
@@ -13,8 +16,8 @@ import {
   resolveAtlaspackConfig,
   processConfig,
 } from '../src/requests/AtlaspackConfigRequest';
+
 import {DEFAULT_OPTIONS, relative} from './test-utils';
-import {toProjectPath} from '../src/projectPath';
 
 describe('AtlaspackConfigRequest', () => {
   describe('validateConfigFile', () => {