@atlaspack/core 2.12.1-dev.3443 → 2.12.1-dev.3460

package/src/PackagerRunner.js

@@ -85,6 +85,7 @@ export type BundleInfo = {|
   +hashReferences: Array<string>,
   +time?: number,
   +cacheKeys: CacheKeyMap,
+  +isLargeBlob: boolean,
 |};
 
 type CacheKeyMap = {|
@@ -126,7 +127,7 @@ export default class PackagerRunner {
     this.previousInvalidations = previousInvalidations;
     this.invalidations = new Map();
     this.pluginOptions = new PluginOptions(
-      optionsProxy(this.options, option => {
+      optionsProxy(this.options, (option) => {
         let invalidation: RequestInvalidation = {
           type: 'option',
           key: option,
@@ -339,7 +340,7 @@ export default class PackagerRunner {
     bundleConfigs: Map<string, Config>,
   ): Promise<{|
     type: string,
-    contents: Buffer | string,
+    contents: Blob,
     map: ?string,
   |}> {
     let packaged = await this.package(
@@ -409,7 +410,7 @@ export default class PackagerRunner {
           NamedBundle.get.bind(NamedBundle),
           this.options,
         ),
-        getSourceMapReference: map => {
+        getSourceMapReference: (map) => {
           return this.getSourceMapReference(bundle, map);
         },
         options: this.pluginOptions,
@@ -466,7 +467,7 @@ export default class PackagerRunner {
     internalBundle: InternalBundle,
     internalBundleGraph: InternalBundleGraph,
     type: string,
-    contents: Buffer | string,
+    contents: Blob,
     map?: ?SourceMap,
     configs: Map<string, Config>,
     bundleConfigs: Map<string, Config>,
@@ -485,7 +486,7 @@ export default class PackagerRunner {
       bundle.name,
       internalBundle.pipeline,
     );
-    if (optimizers.length === 0) {
+    if (!optimizers.length) {
       return {type: bundle.type, contents, map};
     }
 
@@ -516,7 +517,7 @@ export default class PackagerRunner {
           bundleGraph,
           contents: optimized.contents,
           map: optimized.map,
-          getSourceMapReference: map => {
+          getSourceMapReference: (map) => {
             return this.getSourceMapReference(bundle, map);
           },
           options: this.pluginOptions,
@@ -690,18 +691,64 @@ export default class PackagerRunner {
     return devDepHashes;
   }
 
+  async readFromCache(cacheKey: string): Promise<?{|
+    contents: Readable,
+    map: ?Readable,
+  |}> {
+    let contentKey = PackagerRunner.getContentKey(cacheKey);
+    let mapKey = PackagerRunner.getMapKey(cacheKey);
+
+    let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
+    let contentExists =
+      isLargeBlob || (await this.options.cache.has(contentKey));
+    if (!contentExists) {
+      return null;
+    }
+
+    let mapExists = await this.options.cache.has(mapKey);
+
+    return {
+      contents: isLargeBlob
+        ? this.options.cache.getStream(contentKey)
+        : blobToStream(await this.options.cache.getBlob(contentKey)),
+      map: mapExists
+        ? blobToStream(await this.options.cache.getBlob(mapKey))
+        : null,
+    };
+  }
+
   async writeToCache(
     cacheKeys: CacheKeyMap,
     type: string,
-    contents: Buffer | string,
+    contents: Blob,
     map: ?string,
   ): Promise<BundleInfo> {
     let size = 0;
     let hash;
     let hashReferences = [];
+    let isLargeBlob = false;
 
     // TODO: don't replace hash references in binary files??
-    if (typeof contents === 'string') {
+    if (contents instanceof Readable) {
+      isLargeBlob = true;
+      let boundaryStr = '';
+      let h = new Hash();
+      await this.options.cache.setStream(
+        cacheKeys.content,
+        blobToStream(contents).pipe(
+          new TapStream((buf) => {
+            let str = boundaryStr + buf.toString();
+            hashReferences = hashReferences.concat(
+              str.match(HASH_REF_REGEX) ?? [],
+            );
+            size += buf.length;
+            h.writeBuffer(buf);
+            boundaryStr = str.slice(str.length - BOUNDARY_LENGTH);
+          }),
+        ),
+      );
+      hash = h.finish();
+    } else if (typeof contents === 'string') {
       let buffer = Buffer.from(contents);
       size = buffer.byteLength;
       hash = hashBuffer(buffer);
@@ -723,6 +770,7 @@ export default class PackagerRunner {
       hash,
       hashReferences,
       cacheKeys,
+      isLargeBlob,
     };
     await this.options.cache.set(cacheKeys.info, info);
     return info;

package/src/ReporterRunner.js

@@ -45,8 +45,8 @@ export default class ReporterRunner {
     this.workerFarm = opts.workerFarm;
     this.pluginOptions = new PluginOptions(this.options);
 
-    logger.onLog(event => this.report(event));
-    tracer.onTrace(event => this.report(event));
+    logger.onLog((event) => this.report(event));
+    tracer.onTrace((event) => this.report(event));
 
     bus.on('reporterEvent', this.eventHandler);
     instances.add(this);
@@ -58,7 +58,7 @@ export default class ReporterRunner {
     }
   }
 
-  eventHandler: ReporterEvent => void = (event): void => {
+  eventHandler: (ReporterEvent) => void = (event): void => {
     if (
       event.type === 'buildProgress' &&
       (event.phase === 'optimizing' || event.phase === 'packaging') &&
@@ -154,5 +154,5 @@ export function reportWorker(workerApi: WorkerApi, event: ReporterEvent) {
 }
 
 export async function report(event: ReporterEvent): Promise<void> {
-  await Promise.all([...instances].map(instance => instance.report(event)));
+  await Promise.all([...instances].map((instance) => instance.report(event)));
 }

package/src/RequestTracker.js

@@ -210,9 +210,9 @@ type RequestGraphNode =
   | ConfigKeyNode;
 
 export type RunAPI<TResult: RequestResult> = {|
-  invalidateOnFileCreate: InternalFileCreateInvalidation => void,
-  invalidateOnFileDelete: ProjectPath => void,
-  invalidateOnFileUpdate: ProjectPath => void,
+  invalidateOnFileCreate: (InternalFileCreateInvalidation) => void,
+  invalidateOnFileDelete: (ProjectPath) => void,
+  invalidateOnFileUpdate: (ProjectPath) => void,
   invalidateOnConfigKeyChange: (
     filePath: ProjectPath,
     configKey: string,
@@ -220,8 +220,8 @@ export type RunAPI<TResult: RequestResult> = {|
   ) => void,
   invalidateOnStartup: () => void,
   invalidateOnBuild: () => void,
-  invalidateOnEnvChange: string => void,
-  invalidateOnOptionChange: string => void,
+  invalidateOnEnvChange: (string) => void,
+  invalidateOnOptionChange: (string) => void,
   getInvalidations(): Array<RequestInvalidation>,
   storeResult(result: TResult, cacheKey?: string): void,
   getRequestResult<T: RequestResult>(contentKey: ContentKey): Async<?T>,
@@ -761,7 +761,7 @@ export class RequestGraph extends ContentGraph<
       requestGraphEdgeTypes.invalidated_by_update,
     );
     return invalidations
-      .map(nodeId => {
+      .map((nodeId) => {
         let node = nullthrows(this.getNode(nodeId));
         switch (node.type) {
           case FILE:
@@ -788,7 +788,7 @@ export class RequestGraph extends ContentGraph<
       requestGraphEdgeTypes.subrequest,
     );
 
-    return subRequests.map(nodeId => {
+    return subRequests.map((nodeId) => {
       let node = nullthrows(this.getNode(nodeId));
       invariant(node.type === REQUEST);
       return node;
@@ -806,8 +806,8 @@ export class RequestGraph extends ContentGraph<
     );
 
     return subRequests
-      .filter(id => this.invalidNodeIds.has(id))
-      .map(nodeId => {
+      .filter((id) => this.invalidNodeIds.has(id))
+      .map((nodeId) => {
         let node = nullthrows(this.getNode(nodeId));
         invariant(node.type === REQUEST);
         return node;
@@ -920,7 +920,7 @@ export class RequestGraph extends ContentGraph<
       this.invalidateNode(nodeId, reason);
     };
     const aboveCache = new Map();
-    const getAbove = fileNameNodeId => {
+    const getAbove = (fileNameNodeId) => {
       const cachedResult = aboveCache.get(fileNameNodeId);
       if (enableOptimization && cachedResult) {
         return cachedResult;
@@ -1390,7 +1390,7 @@ export default class RequestTracker {
   ): {|api: RunAPI<TResult>, subRequestContentKeys: Set<ContentKey>|} {
     let subRequestContentKeys = new Set<ContentKey>();
     let api: RunAPI<TResult> = {
-      invalidateOnFileCreate: input =>
+      invalidateOnFileCreate: (input) =>
         this.graph.invalidateOnFileCreate(requestId, input),
       invalidateOnConfigKeyChange: (filePath, configKey, contentHash) =>
         this.graph.invalidateOnConfigKeyChange(
@@ -1399,15 +1399,15 @@ export default class RequestTracker {
           configKey,
           contentHash,
         ),
-      invalidateOnFileDelete: filePath =>
+      invalidateOnFileDelete: (filePath) =>
         this.graph.invalidateOnFileDelete(requestId, filePath),
-      invalidateOnFileUpdate: filePath =>
+      invalidateOnFileUpdate: (filePath) =>
         this.graph.invalidateOnFileUpdate(requestId, filePath),
       invalidateOnStartup: () => this.graph.invalidateOnStartup(requestId),
       invalidateOnBuild: () => this.graph.invalidateOnBuild(requestId),
-      invalidateOnEnvChange: env =>
+      invalidateOnEnvChange: (env) =>
         this.graph.invalidateOnEnvChange(requestId, env, this.options.env[env]),
-      invalidateOnOptionChange: option =>
+      invalidateOnOptionChange: (option) =>
         this.graph.invalidateOnOptionChange(
           requestId,
           option,
@@ -1425,7 +1425,7 @@ export default class RequestTracker {
       },
       getRequestResult: <T: RequestResult>(id): Async<?T> =>
         this.getRequestResult<T>(id),
-      canSkipSubrequest: contentKey => {
+      canSkipSubrequest: (contentKey) => {
         if (
           this.graph.hasContentKey(contentKey) &&
           this.hasValidResult(this.graph.getNodeIdByContentKey(contentKey))
@@ -1611,7 +1611,7 @@ export function getWatcherOptions({
 }: AtlaspackOptions): WatcherOptions {
   const vcsDirs = ['.git', '.hg'];
   const uniqueDirs = [...new Set([...watchIgnore, ...vcsDirs, cacheDir])];
-  const ignore = uniqueDirs.map(dir => path.resolve(watchDir, dir));
+  const ignore = uniqueDirs.map((dir) => path.resolve(watchDir, dir));
 
   return {ignore, backend: watchBackend};
 }
@@ -1787,7 +1787,7 @@ export function cleanUpOrphans<N, E: number>(graph: Graph<N, E>): NodeId[] {
   }
 
   const reachableNodes = new Set();
-  graph.traverse(nodeId => {
+  graph.traverse((nodeId) => {
     reachableNodes.add(nodeId);
   });
 

package/src/SymbolPropagation.js

@@ -33,7 +33,7 @@ export function propagateSymbols({
   previousErrors?: ?Map<NodeId, Array<Diagnostic>>,
 |}): Map<NodeId, Array<Diagnostic>> {
   let changedAssets = new Set(
-    [...changedAssetsPropagation].map(id =>
+    [...changedAssetsPropagation].map((id) =>
       assetGraph.getNodeIdByContentKey(id),
     ),
   );
@@ -80,7 +80,7 @@ export function propagateSymbols({
         }
       }
       let hasNamespaceOutgoingDeps = outgoingDeps.some(
-        d => d.value.symbols?.get('*')?.local === '*',
+        (d) => d.value.symbols?.get('*')?.local === '*',
       );
 
       // 1) Determine what the incomingDeps requests from the asset
@@ -196,18 +196,18 @@ export function propagateSymbols({
                 // we need everything
                 depUsedSymbolsDown.add(symbol);
 
-                [...reexportedExportSymbols].forEach(s =>
+                [...reexportedExportSymbols].forEach((s) =>
                   assetNode.usedSymbols.delete(s),
                 );
               } else {
                 let usedReexportedExportSymbols = [
                   ...reexportedExportSymbols,
-                ].filter(s => assetNode.usedSymbols.has(s));
+                ].filter((s) => assetNode.usedSymbols.has(s));
                 if (usedReexportedExportSymbols.length > 0) {
                   // The symbol is indeed a reexport, so it's not used from the asset itself
                   depUsedSymbolsDown.add(symbol);
 
-                  usedReexportedExportSymbols.forEach(s =>
+                  usedReexportedExportSymbols.forEach((s) =>
                     assetNode.usedSymbols.delete(s),
                   );
                 }
@@ -341,7 +341,7 @@ export function propagateSymbols({
 
           let reexported = assetSymbolsInverse?.get(local);
           if (reexported != null) {
-            reexported.forEach(s => {
+            reexported.forEach((s) => {
               // see same code above
               if (reexportedSymbols.has(s)) {
                 if (!assetNode.usedSymbols.has('*')) {
@@ -558,16 +558,8 @@ function propagateSymbolsDown(
     } else if (node.type === 'asset' && node.usedSymbolsDownDirty) {
       visit(
         node,
-        assetGraph.getIncomingDependencies(node.value).map(d => {
-          let dep = assetGraph.getNodeByContentKey(d.id);
-          invariant(dep && dep.type === 'dependency');
-          return dep;
-        }),
-        outgoing.map(dep => {
-          let depNode = nullthrows(assetGraph.getNode(dep));
-          invariant(depNode.type === 'dependency');
-          return depNode;
-        }),
+        incomingDependencyNodesFromAsset(assetGraph, node.value),
+        dependencyNodesFromIds(assetGraph, outgoing),
       );
       node.usedSymbolsDownDirty = false;
     }
@@ -623,7 +615,7 @@ function propagateSymbolsUp(
   let changedDepsUsedSymbolsUpDirtyDownAssets = new Set([
     ...[...changedDepsUsedSymbolsUpDirtyDown]
       .reverse()
-      .flatMap(id => getDependencyResolution(assetGraph, id)),
+      .flatMap((id) => getDependencyResolution(assetGraph, id)),
     ...changedAssets,
   ]);
 
@@ -643,27 +635,18 @@ function propagateSymbolsUp(
       'A root node is required to traverse',
     );
 
-    const nodeVisitor = nodeId => {
+    const nodeVisitor = (nodeId) => {
       let node = nullthrows(assetGraph.getNode(nodeId));
-      let outgoing = assetGraph.getNodeIdsConnectedFrom(nodeId);
 
-      for (let childId of outgoing) {
-        let child = nullthrows(assetGraph.getNode(childId));
-        if (node.type === 'asset') {
-          invariant(child.type === 'dependency');
+      if (node.type === 'asset') {
+        let outgoing = outgoingDependencyNodesFromAsset(assetGraph, nodeId);
+        for (let child of outgoing) {
           if (child.usedSymbolsUpDirtyUp) {
             node.usedSymbolsUpDirty = true;
             child.usedSymbolsUpDirtyUp = false;
           }
         }
-      }
-
-      if (node.type === 'asset') {
-        let incoming = assetGraph.getIncomingDependencies(node.value).map(d => {
-          let n = assetGraph.getNodeByContentKey(d.id);
-          invariant(n && n.type === 'dependency');
-          return n;
-        });
+        let incoming = incomingDependencyNodesFromAsset(assetGraph, node.value);
         for (let dep of incoming) {
           if (dep.usedSymbolsUpDirtyDown) {
             dep.usedSymbolsUpDirtyDown = false;
@@ -671,15 +654,7 @@ function propagateSymbolsUp(
           }
         }
         if (node.usedSymbolsUpDirty) {
-          let e = visit(
-            node,
-            incoming,
-            outgoing.map(depNodeId => {
-              let depNode = nullthrows(assetGraph.getNode(depNodeId));
-              invariant(depNode.type === 'dependency');
-              return depNode;
-            }),
-          );
+          let e = visit(node, incoming, outgoing);
           if (e.length > 0) {
             node.usedSymbolsUpDirty = true;
             errors.set(nodeId, e);
@@ -706,24 +681,14 @@ function propagateSymbolsUp(
     let queuedNodeId = setPop(queue);
     let node = nullthrows(assetGraph.getNode(queuedNodeId));
     if (node.type === 'asset') {
-      let incoming = assetGraph.getIncomingDependencies(node.value).map(dep => {
-        let depNode = assetGraph.getNodeByContentKey(dep.id);
-        invariant(depNode && depNode.type === 'dependency');
-        return depNode;
-      });
+      let incoming = incomingDependencyNodesFromAsset(assetGraph, node.value);
       for (let dep of incoming) {
         if (dep.usedSymbolsUpDirtyDown) {
           dep.usedSymbolsUpDirtyDown = false;
           node.usedSymbolsUpDirty = true;
         }
       }
-      let outgoing = assetGraph
-        .getNodeIdsConnectedFrom(queuedNodeId)
-        .map(depNodeId => {
-          let depNode = nullthrows(assetGraph.getNode(depNodeId));
-          invariant(depNode.type === 'dependency');
-          return depNode;
-        });
+      let outgoing = outgoingDependencyNodesFromAsset(assetGraph, queuedNodeId);
       for (let dep of outgoing) {
         if (dep.usedSymbolsUpDirtyUp) {
           node.usedSymbolsUpDirty = true;
@@ -795,3 +760,26 @@ function setPop<T>(set: Set<T>): T {
   set.delete(v);
   return v;
 }
+
+function outgoingDependencyNodesFromAsset(assetGraph, assetNode) {
+  return dependencyNodesFromIds(
+    assetGraph,
+    assetGraph.getNodeIdsConnectedFrom(assetNode),
+  );
+}
+
+function dependencyNodesFromIds(assetGraph, dependencyIds) {
+  return dependencyIds.map((depNodeId) => {
+    let depNode = nullthrows(assetGraph.getNode(depNodeId));
+    invariant(depNode.type === 'dependency');
+    return depNode;
+  });
+}
+
+function incomingDependencyNodesFromAsset(assetGraph, assetNodeValue) {
+  return assetGraph.getIncomingDependencies(assetNodeValue).map((d) => {
+    let n = assetGraph.getNodeByContentKey(d.id);
+    invariant(n && n.type === 'dependency');
+    return n;
+  });
+}

package/src/Transformation.js

@@ -121,10 +121,10 @@ export default class Transformation {
     this.pluginOptions = new PluginOptions(
       optionsProxy(
         this.options,
-        option => {
+        (option) => {
           this.invalidations.invalidateOnOptionChange.add(option);
         },
-        devDep => {
+        (devDep) => {
           this.pluginDevDeps.push(devDep);
         },
       ),
@@ -181,8 +181,8 @@ export default class Transformation {
     let assets, error;
     try {
       let results = await this.runPipelines(pipeline, asset);
-      await Promise.all(results.map(asset => asset.commit()));
-      assets = results.map(a => a.value);
+      await Promise.all(results.map((asset) => asset.commit()));
+      assets = results.map((a) => a.value);
     } catch (e) {
       error = e;
     }
@@ -440,7 +440,7 @@ export default class Transformation {
     await Promise.all(
       resultingAssets
         .filter(
-          asset =>
+          (asset) =>
             asset.ast != null &&
             !(
               this.options.mode === 'production' &&
@@ -448,7 +448,7 @@ export default class Transformation {
               asset.value.symbols
             ),
         )
-        .map(async asset => {
+        .map(async (asset) => {
           if (asset.isASTDirty && asset.generate) {
             let output = await asset.generate();
             asset.content = output.content;
@@ -481,8 +481,8 @@ export default class Transformation {
     }
 
     return {
-      id: transformers.map(t => t.name).join(':'),
-      transformers: transformers.map(transformer => ({
+      id: transformers.map((t) => t.name).join(':'),
+      transformers: transformers.map((transformer) => ({
         name: transformer.name,
         resolveFrom: transformer.resolveFrom,
         config: this.configs.get(transformer.name)?.result,
@@ -584,7 +584,7 @@ export default class Transformation {
 
       if (result.invalidateOnFileCreate) {
         this.invalidations.invalidateOnFileCreate.push(
-          ...result.invalidateOnFileCreate.map(i =>
+          ...result.invalidateOnFileCreate.map((i) =>
             invalidateOnFileCreateToInternal(this.options.projectRoot, i),
           ),
         );
@@ -686,7 +686,7 @@ export default class Transformation {
         assets: Array<UncommittedAsset>,
       ): Promise<Array<UncommittedAsset> | null> => {
         let results = await postProcess.call(transformer, {
-          assets: assets.map(asset => new MutableAsset(asset)),
+          assets: assets.map((asset) => new MutableAsset(asset)),
           config,
           options: pipeline.pluginOptions,
           resolve,
@@ -695,7 +695,7 @@ export default class Transformation {
         });
 
         return Promise.all(
-          results.map(result =>
+          results.map((result) =>
             asset.createChildAsset(
               result,
               transformerName,
@@ -734,7 +734,7 @@ function normalizeAssets(
   options,
   results: Array<TransformerResult | MutableAsset>,
 ): Array<TransformerResult | UncommittedAsset> {
-  return results.map(result => {
+  return results.map((result) => {
     if (result instanceof MutableAsset) {
       return mutableAssetToUncommittedAsset(result);
     }

package/src/UncommittedAsset.js

@@ -99,7 +99,7 @@ export default class UncommittedAsset {
     await Promise.all([
       contentKey != null &&
         this.commitContent(contentKey).then(
-          s => ((size = s.size), (outputHash = s.hash)),
+          (s) => ((size = s.size), (outputHash = s.hash)),
         ),
       this.mapBuffer != null &&
         mapKey != null &&
@@ -134,7 +134,7 @@ export default class UncommittedAsset {
       await this.options.cache.setStream(
         contentKey,
         content.pipe(
-          new TapStream(buf => {
+          new TapStream((buf) => {
             hash.writeBuffer(buf);
             size += buf.length;
           }),

package/src/Validation.js

@@ -62,7 +62,7 @@ export default class Validation {
     let pluginOptions = new PluginOptions(this.options);
     await this.buildAssetsAndValidators();
     await Promise.all(
-      Object.keys(this.allValidators).map(async validatorName => {
+      Object.keys(this.allValidators).map(async (validatorName) => {
         let assets = this.allAssets[validatorName];
         if (assets) {
           let plugin = this.allValidators[validatorName];
@@ -76,7 +76,7 @@ export default class Validation {
             // If the plugin supports the single-threading validateAll method, pass all assets to it.
             if (plugin.validateAll && this.dedicatedThread) {
               validatorResults = await plugin.validateAll({
-                assets: assets.map(asset => new Asset(asset)),
+                assets: assets.map((asset) => new Asset(asset)),
                 options: pluginOptions,
                 logger: validatorLogger,
                 tracer: validatorTracer,
@@ -96,7 +96,7 @@ export default class Validation {
             // Otherwise, pass the assets one-at-a-time
             else if (plugin.validate && !this.dedicatedThread) {
               await Promise.all(
-                assets.map(async input => {
+                assets.map(async (input) => {
                   let config = null;
                   let publicAsset = new Asset(input);
                   if (plugin.getConfig) {
@@ -142,7 +142,7 @@ export default class Validation {
   async buildAssetsAndValidators() {
     // Figure out what validators need to be run, and group the assets by the relevant validators.
     await Promise.all(
-      this.requests.map(async request => {
+      this.requests.map(async (request) => {
         this.report({
           type: 'validation',
           filePath: fromProjectPath(this.options.projectRoot, request.filePath),
@@ -169,7 +169,7 @@ export default class Validation {
   handleResults(validatorResults: Array<?ValidateResult>) {
     let warnings: Array<Diagnostic> = [];
     let errors: Array<Diagnostic> = [];
-    validatorResults.forEach(result => {
+    validatorResults.forEach((result) => {
       if (result) {
         warnings.push(...result.warnings);
         errors.push(...result.errors);

package/src/applyRuntimes.js

@@ -320,7 +320,7 @@ export default async function applyRuntimes<TResult: RequestResult>({
 
       let assets = runtimesBundleGraph._graph
         .getNodeIdsConnectedFrom(nodeId)
-        .map(assetNodeId => {
+        .map((assetNodeId) => {
           let assetNode = nullthrows(
             runtimesBundleGraph._graph.getNode(assetNodeId),
           );
@@ -393,7 +393,7 @@ function reconcileNewRuntimes<TResult: RequestResult>(
   connections: Array<RuntimeConnection>,
   optionsRef: SharedReference,
 ) {
-  let assetGroups = connections.map(t => t.assetGroup);
+  let assetGroups = connections.map((t) => t.assetGroup);
   let request = createAssetGraphRequest({
     name: 'Runtimes',
     assetGroups,

package/src/assetUtils.js

@@ -70,7 +70,7 @@ export type AssetOptions = {|
 
 export function createAssetIdFromOptions(options: AssetOptions): string {
   return createAssetIdRust({
-    env: options.env,
+    environmentId: options.env.id,
     filePath: options.filePath,
     code: options.code,
     pipeline: options.pipeline,

package/src/atlaspack-v3/AtlaspackV3.js

@@ -57,7 +57,7 @@ export class AtlaspackV3 {
 
     return [
       workers,
-      tx_worker => {
+      (tx_worker) => {
         let worker = new Worker(WORKER_PATH, {
           workerData: {
             tx_worker,