@atlaspack/query 2.14.0 → 2.14.1-canary.6

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2024 Atlassian US., Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/lib/bin.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+'use strict';
+
+const run = require('./cli').run;
+require('v8-compile-cache');
+run(process.argv.slice(2));

package/lib/cli.js

@@ -0,0 +1,850 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.run = run;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _repl() {
+  const data = _interopRequireDefault(require("repl"));
+  _repl = function () {
+    return data;
+  };
+  return data;
+}
+function _os() {
+  const data = _interopRequireDefault(require("os"));
+  _os = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _v() {
+  const data = require("v8");
+  _v = function () {
+    return data;
+  };
+  return data;
+}
+function _table() {
+  const data = require("table");
+  _table = function () {
+    return data;
+  };
+  return data;
+}
+var _index = require("./index");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable no-console, monorepo/no-internal-import */
+// $FlowFixMe
+const {
+  BundleGraph: {
+    bundleGraphEdgeTypes: bundleGraphEdgeTypes
+  },
+  Priority,
+  fromProjectPathRelative
+} = require('./deep-imports');
+async function run(input) {
+  let args = input;
+  let cacheDir = _path().default.join(process.cwd(), '.parcel-cache');
+  if (args[0] === '--cache') {
+    cacheDir = _path().default.resolve(process.cwd(), args[1]);
+    args = args.slice(2);
+  }
+  let initialCmd = args[0];
+  try {
+    _fs().default.accessSync(cacheDir);
+  } catch (e) {
+    console.error("Can't find cache dir", cacheDir);
+    process.exit(1);
+  }
+  console.log('Loading graphs...');
+  let {
+    assetGraph,
+    bundleGraph,
+    bundleInfo,
+    requestTracker,
+    cacheInfo
+  } = await (0, _index.loadGraphs)(cacheDir);
+  function hasRequestTracker() {
+    if (requestTracker == null) {
+      console.error('Request Graph could not be found');
+      return false;
+    }
+    return true;
+  }
+  function hasBundleGraph() {
+    if (bundleGraph == null) {
+      console.error('Bundle Graph could not be found');
+      return false;
+    }
+    return true;
+  }
+  function hasAssetGraph() {
+    if (assetGraph == null) {
+      console.error('Asset Graph could not be found');
+      return false;
+    }
+    return true;
+  }
+  function hasBundleInfo() {
+    if (bundleInfo == null) {
+      console.error('Bundle Info could not be found');
+      return false;
+    }
+    return true;
+  }
+
+  // -------------------------------------------------------
+
+  function getBundleFilePath(id) {
+    var _bundleInfo$get;
+    if (!hasBundleInfo()) {
+      return;
+    }
+    (0, _assert().default)(bundleInfo != null);
+    return fromProjectPathRelative((0, _nullthrows().default)((_bundleInfo$get = bundleInfo.get(id)) === null || _bundleInfo$get === void 0 ? void 0 : _bundleInfo$get.filePath));
+  }
+  function parseAssetLocator(v) {
+    let id = null;
+    if (v.length === 16) {
+      id = v;
+    } else {
+      if (!hasBundleGraph()) {
+        return;
+      }
+      (0, _assert().default)(bundleGraph != null);
+      for (let [assetId, publicId] of bundleGraph._publicIdByAssetId) {
+        if (publicId === v) {
+          id = assetId;
+          break;
+        }
+      }
+    }
+    if (id == null && v.length > 0) {
+      if (!hasAssetGraph()) {
+        return;
+      }
+      (0, _assert().default)(assetGraph != null);
+      let assetRegex = new RegExp(v);
+      for (let node of assetGraph.nodes.values()) {
+        if ((node === null || node === void 0 ? void 0 : node.type) === 'asset' && assetRegex.test(fromProjectPathRelative(node.value.filePath))) {
+          id = node.id;
+          break;
+        }
+      }
+    }
+    return id;
+  }
+  function parseBundleLocator(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleRegex = new RegExp(v);
+    for (let b of bundleGraph.getBundles()) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined && bundleRegex.test(bundleFilePath) || b.id === v) {
+        return b.id;
+      }
+    }
+  }
+  function getAsset(v) {
+    let id = parseAssetLocator(v);
+    if (id == null) {
+      console.log(null);
+    } else {
+      try {
+        if (!hasBundleGraph()) {
+          return;
+        }
+        (0, _assert().default)(bundleGraph != null);
+        let asset = bundleGraph.getAssetById(id);
+        console.log('Public id', bundleGraph.getAssetPublicId(asset));
+        console.log(asset);
+      } catch (e) {
+        if (!hasAssetGraph()) {
+          return;
+        }
+        (0, _assert().default)(assetGraph != null);
+        let node = (0, _nullthrows().default)(assetGraph.getNodeByContentKey(id));
+        (0, _assert().default)(node.type === 'asset');
+        console.log(node.value);
+      }
+    }
+  }
+  function _findAssetNode(v) {
+    if (!hasAssetGraph()) {
+      return;
+    }
+    (0, _assert().default)(assetGraph != null);
+    let assetRegex = new RegExp(v);
+    for (let node of assetGraph.nodes.values()) {
+      if ((node === null || node === void 0 ? void 0 : node.type) === 'asset' && assetRegex.test(fromProjectPathRelative(node.value.filePath))) {
+        return node;
+      }
+    }
+  }
+  function findAsset(v) {
+    let node = _findAssetNode(v);
+    if (node) {
+      try {
+        if (!hasBundleGraph()) {
+          return;
+        }
+        (0, _assert().default)(bundleGraph != null);
+        console.log(`${bundleGraph.getAssetPublicId(bundleGraph.getAssetById(node.id))} ${fromProjectPathRelative(node.value.filePath)}`);
+      } catch (e) {
+        console.log(fromProjectPathRelative(node.value.filePath));
+      }
+    }
+  }
+  function findAssetWithSymbol(local) {
+    if (!hasBundleGraph() || !hasAssetGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    (0, _assert().default)(assetGraph != null);
+    let [, assetId, binding, ref] = (0, _nullthrows().default)(local.match(/^\$([^$]+)\$([^$]+)\$(.*)$/), `symbol ${local} could not be resolved`);
+    let asset;
+    // Search against the id used by the JSTransformer and ScopeHoistingPackager,
+    // not the final asset id, as it may have changed with further transformation.
+    for (let node of assetGraph.nodes.values()) {
+      if ((node === null || node === void 0 ? void 0 : node.type) === 'asset' && node.value.meta.id === assetId) {
+        asset = node;
+        break;
+      }
+    }
+
+    // If the asset couldn't be found by searching for the id,
+    // search for the local name in asset used symbols.
+    if (asset == null) {
+      outer: for (let node of assetGraph.nodes.values()) {
+        if ((node === null || node === void 0 ? void 0 : node.type) === 'asset' && node.value.symbols) {
+          for (let symbol of node.value.symbols.values()) {
+            if (symbol.local === local) {
+              asset = node;
+              break outer;
+            }
+          }
+        }
+      }
+    }
+    (0, _assert().default)(asset, `An asset for ${assetId} could not be found`);
+    (0, _assert().default)(asset.type === 'asset', `Expected ${assetId} to be an asset, but found a ${asset.type}`);
+    try {
+      console.log(`${bundleGraph.getAssetPublicId(bundleGraph.getAssetById(asset.id))} ${fromProjectPathRelative(asset.value.filePath)}`);
+    } catch (e) {
+      console.log(fromProjectPathRelative(asset.value.filePath));
+    }
+    if (binding === 'export' && asset.value.symbols) {
+      for (let [symbolName, symbol] of asset.value.symbols) {
+        if (symbol.local === local) {
+          if (symbol.loc) {
+            let locPath = symbol.loc.filePath;
+            let locAsset = _findAssetNode(String(locPath));
+            if (locAsset != null) {
+              try {
+                console.log(`${bundleGraph.getAssetPublicId(bundleGraph.getAssetById(locAsset.id))} ${fromProjectPathRelative(locAsset.value.filePath)}`);
+              } catch (e) {
+                console.log(`imported as ${symbolName} from ${fromProjectPathRelative(locAsset.value.filePath)}`);
+              }
+            } else {
+              console.log(`imported as ${symbolName} from ${fromProjectPathRelative(locPath)}`);
+            }
+          } else {
+            console.log(`imported as ${symbolName}`);
+          }
+        }
+      }
+    } else if (ref) {
+      console.log(`possibly defined as ${ref}`);
+    }
+  }
+  function getNodeAssetGraph(v) {
+    if (!hasAssetGraph()) {
+      return;
+    }
+    (0, _assert().default)(assetGraph != null);
+    console.log(assetGraph.getNodeByContentKey(v));
+  }
+  function getNodeBundleGraph(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    console.log(bundleGraph._graph.getNodeByContentKey(v));
+  }
+  class Paths {
+    children = [];
+    constructor(value, label = '-', suffix = '') {
+      this.value = value;
+      this.label = label;
+      this.suffix = suffix;
+    }
+    add(v, label, suffix) {
+      let next = new Paths(v, label, suffix);
+      this.children.push(next);
+      return next;
+    }
+    print(format, prefix = '') {
+      console.log(`${prefix}${this.label} ${format(this.value)} ${this.suffix}`);
+      for (let i = 0; i < this.children.length; i++) {
+        this.children[i].print(format, prefix + '  ');
+      }
+    }
+  }
+  function _findEntries(graph, v) {
+    let asset = (0, _nullthrows().default)(parseAssetLocator(v), 'Asset not found');
+    let paths = new Paths(graph.getNodeIdByContentKey(asset), ' ');
+    let cb = (id, ctx, revisiting) => {
+      let {
+        paths,
+        lazyOutgoing
+      } = ctx;
+      let node = (0, _nullthrows().default)(graph.getNode(id));
+      if (node.id === asset) return ctx;
+      if (node.type === 'asset') {
+        paths = paths.add(id, lazyOutgoing ? '<' : undefined, revisiting ? '(revisiting)' : undefined);
+        lazyOutgoing = false;
+      } else if (node.type === 'dependency') {
+        if (node.value.priority === Priority.lazy) {
+          lazyOutgoing = true;
+        }
+      }
+      return {
+        paths,
+        lazyOutgoing
+      };
+    };
+
+    // like graph.dfs, but revisiting nodes and skipping its children
+    let seen = new Set();
+    function walk(id, ctx) {
+      let revisiting = seen.has(id);
+      let newCtx = cb(id, ctx, revisiting);
+      if (revisiting) return;
+      seen.add(id);
+      for (let parent of graph.getNodeIdsConnectedTo(id)) {
+        walk(parent, newCtx);
+      }
+    }
+    walk(graph.getNodeIdByContentKey(asset), {
+      paths,
+      lazyOutgoing: false
+    });
+    paths.print(id => {
+      let node = (0, _nullthrows().default)(graph.getNode(id));
+      (0, _assert().default)(node.type === 'asset');
+      return fromProjectPathRelative(node.value.filePath);
+    });
+  }
+  function findEntriesAssetGraph(v) {
+    if (!hasAssetGraph()) {
+      return;
+    }
+    (0, _assert().default)(assetGraph != null);
+    _findEntries(assetGraph, v);
+  }
+  function findEntriesBundleGraph(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    _findEntries(bundleGraph._graph, v);
+  }
+  function findEntries(v) {
+    findEntriesBundleGraph(v);
+  }
+  function getBundlesWithAsset(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let asset = (0, _nullthrows().default)(parseAssetLocator(v), 'Asset not found');
+    for (let b of bundleGraph.getBundlesWithAsset(bundleGraph.getAssetById(asset))) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined) {
+        console.log(`${b.id} ${bundleFilePath} ${b.mainEntryId != null ? `(main: ${b.mainEntryId})` : ''}`);
+      }
+    }
+  }
+  function getBundlesWithDependency(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let node = (0, _nullthrows().default)(bundleGraph._graph.getNodeByContentKey(v));
+    (0, _assert().default)(node.type === 'dependency');
+    for (let b of bundleGraph.getBundlesWithDependency(node.value)) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined) {
+        console.log(`${b.id} ${bundleFilePath} ${b.mainEntryId != null ? `(main: ${b.mainEntryId})` : ''}`);
+      }
+    }
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  function getBundles(_) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    for (let b of bundleGraph.getBundles()) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined) {
+        console.log(`${b.id} ${bundleFilePath} ${b.mainEntryId != null ? `(main: ${b.mainEntryId})` : ''}`);
+      }
+    }
+  }
+  function getReferencingBundles(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleId = (0, _nullthrows().default)(parseBundleLocator(v), 'Bundle not found');
+    let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundleId);
+    let bundleNode = (0, _nullthrows().default)(bundleGraph._graph.getNode(bundleNodeId), 'Bundle not found');
+    (0, _assert().default)(bundleNode.type === 'bundle', 'Not a bundle');
+    for (let b of bundleGraph.getReferencingBundles(bundleNode.value)) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined) {
+        console.log(`${b.id} ${bundleFilePath} ${b.mainEntryId != null ? `(main: ${b.mainEntryId})` : ''}`);
+      }
+    }
+  }
+  function getIncomingDependenciesAssetGraph(v) {
+    if (!hasAssetGraph()) {
+      return;
+    }
+    (0, _assert().default)(assetGraph != null);
+    let asset = (0, _nullthrows().default)(parseAssetLocator(v), 'Asset not found');
+    let node = (0, _nullthrows().default)(assetGraph.getNodeByContentKey(asset));
+    (0, _assert().default)(node.type === 'asset');
+    console.log(assetGraph.getIncomingDependencies(node.value));
+  }
+  function getIncomingDependenciesBundleGraph(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let asset = (0, _nullthrows().default)(parseAssetLocator(v), 'Asset not found');
+    let value = (0, _nullthrows().default)(bundleGraph.getAssetById(asset));
+    console.log(bundleGraph.getIncomingDependencies(value));
+  }
+  function getIncomingDependencies(v) {
+    getIncomingDependenciesBundleGraph(v);
+  }
+  function getResolvedAsset(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let node = (0, _nullthrows().default)(bundleGraph._graph.getNodeByContentKey(v), 'Dependency not found');
+    (0, _assert().default)(node.type === 'dependency', 'Node is not a dependency, but a ' + node.type);
+    console.log(bundleGraph.getResolvedAsset(node.value));
+  }
+  function getAssetWithDependency(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let node = (0, _nullthrows().default)(bundleGraph._graph.getNodeByContentKey(v), 'Dependency not found');
+    (0, _assert().default)(node.type === 'dependency', 'Node is not a dependency, but a ' + node.type);
+    console.log(bundleGraph.getAssetWithDependency(node.value));
+  }
+  function traverseAssets(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleId = (0, _nullthrows().default)(parseBundleLocator(v), 'Bundle not found');
+    let node = (0, _nullthrows().default)(bundleGraph._graph.getNodeByContentKey(bundleId), 'Bundle not found');
+    (0, _assert().default)(node.type === 'bundle', 'Node is not a bundle, but a ' + node.type);
+    bundleGraph.traverseAssets(node.value, asset => {
+      console.log(asset.id, asset.filePath);
+    });
+  }
+  function traverseBundle(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleId = (0, _nullthrows().default)(parseBundleLocator(v), 'Bundle not found');
+    let node = (0, _nullthrows().default)(bundleGraph._graph.getNodeByContentKey(bundleId), 'Bundle not found');
+    (0, _assert().default)(node.type === 'bundle', 'Node is not a bundle, but a ' + node.type);
+    bundleGraph.traverseBundle(node.value, node => {
+      if (node.type === 'asset') {
+        console.log(node.id, node.value.filePath);
+      } else {
+        console.log(node.id, node.value.sourcePath, '->', node.value.specifier, node.value.symbols ? `(${[...node.value.symbols.keys()].join(',')})` : '', node.excluded ? `- excluded` : '');
+      }
+    });
+  }
+  function getBundle(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleRegex = new RegExp(v);
+    for (let b of bundleGraph.getBundles()) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined && bundleRegex.test(bundleFilePath) || b.id === v) {
+        console.log(getBundleFilePath(b.id), b);
+      }
+    }
+  }
+  function findBundleReason(bundle, asset) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleId = (0, _nullthrows().default)(parseBundleLocator(bundle), 'Bundle not found');
+    let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundleId);
+    let bundleNode = (0, _nullthrows().default)(bundleGraph._graph.getNode(bundleNodeId), 'Bundle not found');
+    (0, _assert().default)(bundleNode.type === 'bundle', 'Not a bundle');
+    let assetId = (0, _nullthrows().default)(parseAssetLocator(asset), 'Asset not found');
+    let assetNodeId = bundleGraph._graph.getNodeIdByContentKey(assetId);
+    let assetNode = (0, _nullthrows().default)(bundleGraph._graph.getNode(assetNodeId), 'Asset not found');
+    (0, _assert().default)(assetNode.type === 'asset', 'Not an asset');
+    (0, _assert().default)(bundleGraph._graph.hasEdge(bundleNodeId, assetNodeId, bundleGraphEdgeTypes.contains), 'Asset is not part of the bundle');
+    console.log('# Asset is main entry of bundle:', bundleNode.value.mainEntryId === assetId);
+    console.log('# Asset is an entry of bundle:', bundleNode.value.entryAssetIds.includes(assetId));
+    console.log('# Incoming dependencies contained in the bundle:');
+    for (let incoming of bundleGraph._graph.getNodeIdsConnectedTo(assetNodeId)) {
+      if (bundleGraph._graph.hasEdge(bundleNodeId, incoming, bundleGraphEdgeTypes.contains)) {
+        console.log(bundleGraph._graph.getNode(incoming));
+      }
+    }
+    console.log('# Incoming dependencies contained in referencing bundles (using this bundle as a shared bundle)');
+    let referencingBundles = bundleGraph.getReferencingBundles(bundleNode.value);
+    for (let incoming of bundleGraph._graph.getNodeIdsConnectedTo(assetNodeId)) {
+      if (referencingBundles.some(ref => bundleGraph._graph.hasEdge(bundleGraph._graph.getNodeIdByContentKey(ref.id), incoming, bundleGraphEdgeTypes.contains))) {
+        console.log(bundleGraph._graph.getNode(incoming));
+      }
+    }
+  }
+  function _getIncomingNodeOfType(bundleGraph, node, type) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    const bundleGraphNodeId = bundleGraph._graph.getNodeIdByContentKey(node.id);
+    return bundleGraph._graph.getNodeIdsConnectedTo(bundleGraphNodeId, -1).map(id => (0, _nullthrows().default)(bundleGraph._graph.getNode(id))).find(node => node.type == type);
+  }
+
+  // We find the priority of a Bundle or BundleGroup by looking at its incoming dependencies.
+  // If a Bundle does not have an incoming dependency, we look for an incoming BundleGroup and its dependency
+  // e.g. Dep(priority = 1) -> BundleGroup -> Bundle means that the Bundle has priority 1.
+  function _getBundlePriority(bundleGraph, bundle) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let node = _getIncomingNodeOfType(bundleGraph, bundle, 'dependency');
+    if (node == null) {
+      node = _getIncomingNodeOfType(bundleGraph, bundle, 'bundle_group');
+      if (node == null) return null;
+      node = _getIncomingNodeOfType(bundleGraph, node, 'dependency');
+    }
+    if (node == null) return null;
+    (0, _assert().default)(node.type === 'dependency', 'Not a dependency');
+    return node.value.priority;
+  }
+  function _findEntryBundle(bundleGraph, node) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    const bundleGraphNodeId = bundleGraph._graph.getNodeIdByContentKey(node.id);
+    const entryBundleGroup = bundleGraph._graph.getNodeIdsConnectedTo(bundleGraphNodeId, -1).map(id => (0, _nullthrows().default)(bundleGraph._graph.getNode(id))).find(node => node.type === 'bundle_group' && bundleGraph.isEntryBundleGroup(node.value));
+    return entryBundleGroup;
+  }
+  // eslint-disable-next-line no-unused-vars
+  function inspectCache(_) {
+    // displays sizing of various entries of the cache
+    let table = [];
+    table.push(['Graphs', 'Size (bytes)', 'Deserialize (ms)', 'Serialize (ms)']);
+    let serialized = new Map();
+    serialized.set('RequestGraph', timeSerialize(requestTracker));
+    serialized.set('BundleGraph', timeSerialize(bundleGraph));
+    serialized.set('AssetGraph', timeSerialize(assetGraph));
+    for (let [name, info] of (0, _nullthrows().default)(cacheInfo).entries()) {
+      if (name === 'RequestGraph' && !hasRequestTracker() || name === 'BundleGraph' && !hasBundleGraph() || name === 'AssetGraph' && !hasAssetGraph()) {
+        continue;
+      }
+      let s = serialized.get(name);
+      (0, _assert().default)(s != null);
+      table.push([name, ...info, s]);
+    }
+    function getColumnSum(t, col) {
+      if (t == null) {
+        return '';
+      }
+      const initialValue = 0;
+      let column = t.map(r => r[col]);
+      column.shift();
+      (0, _assert().default)(column != null);
+      return column.reduce((accumulator, currentValue) => accumulator + currentValue, initialValue);
+    }
+    table.push(['Totals', getColumnSum(table, 1), getColumnSum(table, 2), getColumnSum(table, 3)]);
+    _printStatsTable('Cache Info', table);
+  }
+  function timeSerialize(graph) {
+    let date = Date.now();
+    (0, _v().serialize)(graph);
+    date = Date.now() - date;
+    return date;
+  }
+  function _printStatsTable(header, data) {
+    const config = {
+      columnDefault: {
+        width: 18
+      },
+      header: {
+        alignment: 'center',
+        content: header
+      }
+    };
+    console.log((0, _table().table)(data, config));
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  function stats(_) {
+    let ag = {
+      asset: 0,
+      dependency: 0,
+      asset_group: 0
+    };
+    if (hasAssetGraph()) {
+      (0, _assert().default)(assetGraph != null);
+      for (let n of assetGraph.nodes) {
+        if (n && n.type in ag) {
+          // $FlowFixMe
+          ag[n.type]++;
+        }
+      }
+      _printStatsTable('# Asset Graph Node Counts', Object.entries(ag));
+    }
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bg = {
+      dependency: 0,
+      bundle: 0,
+      bundle_group: 0,
+      asset_node_modules: 0,
+      asset_source: 0
+    };
+    let b_type = {
+      entry: 0,
+      shared: 0,
+      async: 0,
+      parallel: 0,
+      sync: 0
+    };
+    let b_ext = {};
+    const entries = new Set();
+    for (let n of bundleGraph._graph.nodes) {
+      if ((n === null || n === void 0 ? void 0 : n.type) === 'bundle_group') {
+        bg.bundle_group++;
+      } else if ((n === null || n === void 0 ? void 0 : n.type) === 'bundle') {
+        bg.bundle++;
+
+        // $FlowFixMe
+        b_ext[n.value.type] = (b_ext[n.value.type] || 0) + 1;
+
+        // $FlowFixMe
+        const entry_group = _findEntryBundle(bundleGraph, n);
+        if (entry_group != null && !entries.has(entry_group.id)) {
+          b_type.entry++;
+          entries.add(entry_group.id);
+        } else if (n.value.mainEntryId == null) {
+          // In general, !bundle.mainEntryId means that it is shared. In the case of an async and shared bundle, only count it as shared.
+          b_type.shared++;
+        } else {
+          const priority = _getBundlePriority(bundleGraph, n);
+          if (priority == Priority.lazy) {
+            b_type.async++;
+          } else if (priority == Priority.parallel) {
+            b_type.parallel++;
+          } else if (priority == Priority.sync) {
+            b_type.sync++;
+          }
+        }
+      } else if ((n === null || n === void 0 ? void 0 : n.type) === 'asset') {
+        if (
+        // $FlowFixMe
+        fromProjectPathRelative(n.value.filePath).includes('node_modules')) {
+          bg.asset_node_modules++;
+        } else {
+          bg.asset_source++;
+        }
+      } else if ((n === null || n === void 0 ? void 0 : n.type) === 'dependency') {
+        bg.dependency++;
+      }
+    }
+    _printStatsTable('# Bundle Graph Node Counts', Object.entries(bg));
+    _printStatsTable('# Bundles By Type', Object.entries(b_type));
+    _printStatsTable('# Bundles By Extension', Object.entries(b_ext));
+
+    // Assert that counts for each breakdown are correct
+
+    let sum_b_ext = 0;
+    for (let k in b_ext) {
+      sum_b_ext += b_ext[k];
+    }
+    let sum_b_type = 0;
+    for (let k in b_type) {
+      sum_b_type += b_type[k];
+    }
+    (0, _assert().default)(bg.bundle == sum_b_type, `Bundles by type ${sum_b_type} does not equal total ${bg.bundle}`);
+    (0, _assert().default)(bg.bundle == sum_b_ext, `Bundles by extension ${sum_b_ext} does not equal total ${bg.bundle}`);
+  }
+
+  // -------------------------------------------------------
+
+  if (initialCmd != null) {
+    (async () => {
+      await eval(initialCmd);
+      process.exit(0);
+    })();
+  } else {
+    console.log('See .help. The graphs can be accessed via `assetGraph`, `bundleGraph` and `requestTracker`.');
+    process.on('uncaughtException', function (err) {
+      console.error(err);
+      server.displayPrompt();
+    });
+    const server = _repl().default.start({
+      useColors: true,
+      useGlobal: true
+    });
+    // $FlowFixMe[prop-missing]
+    server.setupHistory(_path().default.join(_os().default.homedir(), '.parcel_query_history'), () => {});
+
+    // $FlowFixMe[prop-missing]
+    server.context.bundleGraph = bundleGraph;
+    // $FlowFixMe[prop-missing]
+    server.context.assetGraph = assetGraph;
+    // $FlowFixMe[prop-missing]
+    server.context.requestTracker = requestTracker;
+    // $FlowFixMe[prop-missing]
+    server.context.cacheInfo = cacheInfo;
+    for (let [name, cmd] of new Map([['getAsset', {
+      help: 'args: <id | public id | filepath>',
+      action: getAsset
+    }], ['getNodeAssetGraph', {
+      help: 'args: <content key>. Find node by content key in the asset graph',
+      action: getNodeAssetGraph
+    }], ['getNodeBundleGraph', {
+      help: 'args: <content key>. Find node by content key in the bundle graph',
+      action: getNodeBundleGraph
+    }], ['findEntriesAssetGraph', {
+      help: 'args: <id | public id | filepath>. List paths from an asset to entry points (in asset graph)',
+      action: findEntriesAssetGraph
+    }], ['findEntriesBundleGraph', {
+      help: 'args: <id | public id | filepath>. List paths from an asset to entry points (in bundle graph)',
+      action: findEntriesBundleGraph
+    }], ['findEntries', {
+      help: '= findEntriesBundleGraph',
+      action: findEntries
+    }], ['getBundlesWithAsset', {
+      help: 'args: <id | public id | filepath>. Gets bundles containing the asset',
+      action: getBundlesWithAsset
+    }], ['getBundlesWithDependency', {
+      help: 'args: <id>. Gets bundles containing the dependency',
+      action: getBundlesWithDependency
+    }], ['getIncomingDependenciesAssetGraph', {
+      help: 'args: <asset: id | public id | filepath regex>',
+      action: getIncomingDependenciesAssetGraph
+    }], ['getIncomingDependenciesBundleGraph', {
+      help: 'args: <asset: id | public id | filepath regex>',
+      action: getIncomingDependenciesBundleGraph
+    }], ['getIncomingDependencies', {
+      help: '= getIncomingDependenciesBundleGraph',
+      action: getIncomingDependencies
+    }], ['getResolvedAsset', {
+      help: 'args: <dependency id>. Resolve the dependency',
+      action: getResolvedAsset
+    }], ['getAssetWithDependency', {
+      help: 'args: <dependency id>. Show which asset created the dependency',
+      action: getAssetWithDependency
+    }], ['traverseAssets', {
+      help: 'args: <bundle id>. List assets in bundle',
+      action: traverseAssets
+    }], ['traverseBundle', {
+      help: 'args: <bundle id>. List assets and dependencies in bundle',
+      action: traverseBundle
+    }], ['getBundle', {
+      help: 'args: <name prefix|bundle id>. List matching bundles',
+      action: getBundle
+    }], ['findBundleReason', {
+      help: 'args: <bundle> <asset>. Why is the asset in the bundle',
+      action: v => findBundleReason(...v.split(' '))
+    }], ['getBundles', {
+      help: 'List all bundles',
+      action: getBundles
+    }], ['getReferencingBundles', {
+      help: 'args: <bundle>. List bundles that reference the bundle',
+      action: getReferencingBundles
+    }], ['stats', {
+      help: 'Statistics',
+      action: stats
+    }], ['findAsset', {
+      help: 'args: <regex>. List assets matching the filepath regex',
+      action: findAsset
+    }], ['inspectCache', {
+      help: 'Cache Information',
+      action: inspectCache
+    }], ['findAssetWithSymbol', {
+      help: 'args: <local>. Get the asset that defines the symbol with the given local name',
+      action: findAssetWithSymbol
+    }]])) {
+      // $FlowFixMe
+      server.context[name] = cmd.action;
+      // $FlowFixMe
+      server.defineCommand(name, {
+        // $FlowFixMe
+        help: '📦 ' + cmd.help,
+        action: v => {
+          // $FlowFixMe
+          server.clearBufferedCommand();
+          // $FlowFixMe
+          try {
+            cmd.action(v);
+          } finally {
+            server.displayPrompt();
+          }
+        }
+      });
+    }
+  }
+}

package/lib/deep-imports.js

@@ -0,0 +1,19 @@
+"use strict";
+
+/* eslint-disable monorepo/no-internal-import */
+const v = {
+  // Split up require specifier to outsmart packages/dev/babel-register/babel-plugin-module-translate.js
+  // $FlowFixMe(unsupported-syntax)
+  AssetGraph: require('@atlaspack/core' + '/lib/AssetGraph').default,
+  // $FlowFixMe(unsupported-syntax)
+  BundleGraph: require('@atlaspack/core' + '/lib/BundleGraph'),
+  // $FlowFixMe(unsupported-syntax)
+  RequestTracker: require('@atlaspack/core' + '/lib/RequestTracker'),
+  // $FlowFixMe(unsupported-syntax)
+  LMDBCache: require('@atlaspack/cache' + '/lib/LMDBCache').LMDBCache,
+  // $FlowFixMe(unsupported-syntax)
+  Priority: require('@atlaspack/core' + '/lib/types').Priority,
+  // $FlowFixMe(unsupported-syntax)
+  fromProjectPathRelative: require('@atlaspack/core' + '/lib/projectPath').fromProjectPathRelative
+};
+module.exports = v;

package/lib/index.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadGraphs = loadGraphs;
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _v() {
+  const data = _interopRequireDefault(require("v8"));
+  _v = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable no-console, monorepo/no-internal-import */
+const {
+  AssetGraph,
+  BundleGraph: {
+    default: BundleGraph
+  },
+  RequestTracker: {
+    default: RequestTracker,
+    readAndDeserializeRequestGraph,
+    requestGraphEdgeTypes
+  },
+  LMDBCache
+} = require('./deep-imports.js');
+async function loadGraphs(cacheDir) {
+  let cacheInfo = new Map();
+  let {
+    requestGraphBlob,
+    bundleGraphBlob,
+    assetGraphBlob
+  } = function getMostRecentCacheBlobs() {
+    let files = _fs().default.readdirSync(cacheDir);
+    let result = {};
+    let blobsToFind = [{
+      name: 'requestGraphBlob',
+      check: basename => basename.startsWith('requestGraph-') && !basename.startsWith('requestGraph-nodes')
+    }, {
+      name: 'bundleGraphBlob',
+      check: basename => basename.endsWith('BundleGraph-0')
+    }, {
+      name: 'assetGraphBlob',
+      check: basename => basename.endsWith('AssetGraph-0')
+    }];
+    for (let file of files) {
+      let basename = _path().default.basename(file);
+      let match = blobsToFind.find(({
+        check
+      }) => check(basename));
+      if (match) {
+        let stat = _fs().default.statSync(_path().default.join(cacheDir, file));
+        if (!match.mtime || stat.mtime > match.mtime) {
+          match.mtime = stat.mtime;
+          result[match.name] = file;
+        }
+      }
+    }
+    return result;
+  }();
+  const cache = new LMDBCache(cacheDir);
+
+  // Get requestTracker
+  let requestTracker;
+  if (requestGraphBlob) {
+    try {
+      var _cacheInfo$get;
+      let requestGraphKey = requestGraphBlob.slice(0, -'-0'.length);
+      let date = Date.now();
+      let {
+        requestGraph,
+        bufferLength
+      } = await readAndDeserializeRequestGraph(cache, requestGraphKey, requestGraphKey.replace('requestGraph-', ''));
+      requestTracker = new RequestTracker({
+        graph: requestGraph,
+        // $FlowFixMe
+        farm: null,
+        // $FlowFixMe
+        options: null
+      });
+      let timeToDeserialize = Date.now() - date;
+      cacheInfo.set('RequestGraph', [bufferLength]);
+      (_cacheInfo$get = cacheInfo.get('RequestGraph')) === null || _cacheInfo$get === void 0 || _cacheInfo$get.push(timeToDeserialize);
+    } catch (e) {
+      console.log('Error loading Request Graph\n', e);
+    }
+  }
+
+  // Get bundleGraph
+  let bundleGraph;
+  if (bundleGraphBlob) {
+    try {
+      var _cacheInfo$get2;
+      let file = await cache.getLargeBlob(_path().default.basename(bundleGraphBlob).slice(0, -'-0'.length));
+      let timeToDeserialize = Date.now();
+      let obj = _v().default.deserialize(file);
+      (0, _assert().default)(obj.bundleGraph != null);
+      bundleGraph = BundleGraph.deserialize(obj.bundleGraph.value);
+      timeToDeserialize = Date.now() - timeToDeserialize;
+      cacheInfo.set('BundleGraph', [Buffer.byteLength(file)]);
+      (_cacheInfo$get2 = cacheInfo.get('BundleGraph')) === null || _cacheInfo$get2 === void 0 || _cacheInfo$get2.push(timeToDeserialize);
+    } catch (e) {
+      console.log('Error loading Bundle Graph\n', e);
+    }
+  }
+
+  // Get assetGraph
+  let assetGraph;
+  if (assetGraphBlob) {
+    try {
+      var _cacheInfo$get3;
+      let file = await cache.getLargeBlob(_path().default.basename(assetGraphBlob).slice(0, -'-0'.length));
+      let timeToDeserialize = Date.now();
+      let obj = _v().default.deserialize(file);
+      (0, _assert().default)(obj.assetGraph != null);
+      assetGraph = AssetGraph.deserialize(obj.assetGraph.value);
+      timeToDeserialize = Date.now() - timeToDeserialize;
+      cacheInfo.set('AssetGraph', [Buffer.byteLength(file)]);
+      (_cacheInfo$get3 = cacheInfo.get('AssetGraph')) === null || _cacheInfo$get3 === void 0 || _cacheInfo$get3.push(timeToDeserialize);
+    } catch (e) {
+      console.log('Error loading Asset Graph\n', e);
+    }
+  }
+  function getSubRequests(id) {
+    return requestTracker.graph.getNodeIdsConnectedFrom(id, requestGraphEdgeTypes.subrequest).map(n => (0, _nullthrows().default)(requestTracker.graph.getNode(n)));
+  }
+
+  // Load graphs by finding the main subrequests and loading their results
+  let bundleInfo;
+  try {
+    (0, _assert().default)(requestTracker);
+    let buildRequestId = requestTracker.graph.getNodeIdByContentKey('atlaspack_build_request');
+    let buildRequestNode = (0, _nullthrows().default)(requestTracker.graph.getNode(buildRequestId));
+    (0, _assert().default)(buildRequestNode.type === 1 && buildRequestNode.requestType === 1);
+    let buildRequestSubRequests = getSubRequests(buildRequestId);
+    let writeBundlesRequest = buildRequestSubRequests.find(n => n.type === 1 && n.requestType === 11);
+    if (writeBundlesRequest != null) {
+      (0, _assert().default)(writeBundlesRequest.type === 1);
+      // $FlowFixMe[incompatible-cast]
+      bundleInfo = (0, _nullthrows().default)(writeBundlesRequest.result);
+    }
+  } catch (e) {
+    console.log('Error loading bundleInfo\n', e);
+  }
+  return {
+    assetGraph,
+    bundleGraph,
+    requestTracker,
+    bundleInfo,
+    cacheInfo
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/query",
-  "version": "2.14.0",
+  "version": "2.14.1-canary.6+57e29c592",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -18,17 +18,18 @@
   },
   "main": "src/index.js",
   "dependencies": {
-    "@atlaspack/cache": "2.13.2",
-    "@atlaspack/core": "2.14.0",
-    "@atlaspack/graph": "3.4.0",
+    "@atlaspack/cache": "2.13.3-canary.6+57e29c592",
+    "@atlaspack/core": "2.14.1-canary.6+57e29c592",
+    "@atlaspack/graph": "3.4.1-canary.6+57e29c592",
     "nullthrows": "^1.1.1",
     "table": "^6.8.1",
     "v8-compile-cache": "^2.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.22.11",
     "@atlaspack/babel-register": "2.14.0",
+    "@babel/core": "^7.22.11",
     "rimraf": "^5.0.5"
   },
-  "type": "commonjs"
+  "type": "commonjs",
+  "gitHead": "57e29c592cff406d084b3c676a1c899f0bb6e78f"
 }