@atlaspack/core 2.12.1-canary.3354

package/lib/public/MutableBundleGraph.js

@@ -0,0 +1,184 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+var _BundleGraph = _interopRequireDefault(require("./BundleGraph"));
+var _BundleGraph2 = _interopRequireWildcard(require("../BundleGraph"));
+var _Bundle = require("./Bundle");
+var _Asset = require("./Asset");
+var _utils = require("../utils");
+var _Dependency = _interopRequireWildcard(require("./Dependency"));
+var _Environment = require("./Environment");
+var _Target = require("./Target");
+var _constants = require("../constants");
+var _projectPath = require("../projectPath");
+var _types = require("../types");
+var _BundleGroup = _interopRequireWildcard(require("./BundleGroup"));
+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; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class MutableBundleGraph extends _BundleGraph.default {
+  #graph /*: InternalBundleGraph */;
+  #options /*: AtlaspackOptions */;
+  #bundlePublicIds /*: Set<string> */ = new Set();
+  constructor(graph, options) {
+    super(graph, _Bundle.Bundle.get.bind(_Bundle.Bundle), options);
+    this.#graph = graph;
+    this.#options = options;
+  }
+  addAssetToBundle(asset, bundle) {
+    this.#graph.addAssetToBundle((0, _Asset.assetToAssetValue)(asset), (0, _Bundle.bundleToInternalBundle)(bundle));
+  }
+  addAssetGraphToBundle(asset, bundle, shouldSkipDependency) {
+    this.#graph.addAssetGraphToBundle((0, _Asset.assetToAssetValue)(asset), (0, _Bundle.bundleToInternalBundle)(bundle), shouldSkipDependency ? d => shouldSkipDependency(new _Dependency.default(d, this.#options)) : undefined);
+  }
+  addEntryToBundle(asset, bundle, shouldSkipDependency) {
+    this.#graph.addEntryToBundle((0, _Asset.assetToAssetValue)(asset), (0, _Bundle.bundleToInternalBundle)(bundle), shouldSkipDependency ? d => shouldSkipDependency(new _Dependency.default(d, this.#options)) : undefined);
+  }
+  createBundleGroup(dependency, target) {
+    let dependencyNode = this.#graph._graph.getNodeByContentKey(dependency.id);
+    if (!dependencyNode) {
+      throw new Error('Dependency not found');
+    }
+    (0, _assert().default)(dependencyNode.type === 'dependency');
+    let resolved = this.#graph.getResolvedAsset((0, _Dependency.dependencyToInternalDependency)(dependency));
+    if (!resolved) {
+      throw new Error('Dependency did not resolve to an asset ' + dependency.id);
+    }
+    let bundleGroup = {
+      target: (0, _Target.targetToInternalTarget)(target),
+      entryAssetId: resolved.id
+    };
+    let bundleGroupKey = (0, _utils.getBundleGroupId)(bundleGroup);
+    let bundleGroupNodeId = this.#graph._graph.hasContentKey(bundleGroupKey) ? this.#graph._graph.getNodeIdByContentKey(bundleGroupKey) : this.#graph._graph.addNodeByContentKey(bundleGroupKey, {
+      id: bundleGroupKey,
+      type: 'bundle_group',
+      value: bundleGroup
+    });
+    let dependencyNodeId = this.#graph._graph.getNodeIdByContentKey(dependencyNode.id);
+    let resolvedNodeId = this.#graph._graph.getNodeIdByContentKey(resolved.id);
+    let assetNodes = this.#graph._graph.getNodeIdsConnectedFrom(dependencyNodeId);
+    this.#graph._graph.addEdge(dependencyNodeId, bundleGroupNodeId);
+    this.#graph._graph.replaceNodeIdsConnectedTo(bundleGroupNodeId, assetNodes);
+    this.#graph._graph.addEdge(dependencyNodeId, resolvedNodeId, _BundleGraph2.bundleGraphEdgeTypes.references);
+    if (
+    // This check is needed for multiple targets, when we go over the same nodes twice
+    this.#graph._graph.hasEdge(dependencyNodeId, resolvedNodeId, _BundleGraph2.bundleGraphEdgeTypes.null)) {
+      //nullEdgeType
+      this.#graph._graph.removeEdge(dependencyNodeId, resolvedNodeId);
+    }
+    if (dependency.isEntry) {
+      this.#graph._graph.addEdge((0, _nullthrows().default)(this.#graph._graph.rootNodeId), bundleGroupNodeId, _BundleGraph2.bundleGraphEdgeTypes.bundle);
+    } else {
+      let inboundBundleNodeIds = this.#graph._graph.getNodeIdsConnectedTo(dependencyNodeId, _BundleGraph2.bundleGraphEdgeTypes.contains);
+      for (let inboundBundleNodeId of inboundBundleNodeIds) {
+        var _this$graph$_graph$ge;
+        (0, _assert().default)(((_this$graph$_graph$ge = this.#graph._graph.getNode(inboundBundleNodeId)) === null || _this$graph$_graph$ge === void 0 ? void 0 : _this$graph$_graph$ge.type) === 'bundle');
+        this.#graph._graph.addEdge(inboundBundleNodeId, bundleGroupNodeId, _BundleGraph2.bundleGraphEdgeTypes.bundle);
+      }
+    }
+    return new _BundleGroup.default(bundleGroup, this.#options);
+  }
+  removeBundleGroup(bundleGroup) {
+    this.#graph.removeBundleGroup((0, _BundleGroup.bundleGroupToInternalBundleGroup)(bundleGroup));
+  }
+  internalizeAsyncDependency(bundle, dependency) {
+    this.#graph.internalizeAsyncDependency((0, _Bundle.bundleToInternalBundle)(bundle), (0, _Dependency.dependencyToInternalDependency)(dependency));
+  }
+  createBundle(opts) {
+    let entryAsset = opts.entryAsset ? (0, _Asset.assetToAssetValue)(opts.entryAsset) : null;
+    let target = (0, _Target.targetToInternalTarget)(opts.target);
+    let bundleId = (0, _rust().hashString)('bundle:' + (opts.entryAsset ? opts.entryAsset.id : opts.uniqueKey) + (0, _projectPath.fromProjectPathRelative)(target.distDir) + (opts.bundleBehavior ?? ''));
+    let existing = this.#graph._graph.getNodeByContentKey(bundleId);
+    if (existing != null) {
+      (0, _assert().default)(existing.type === 'bundle');
+      return _Bundle.Bundle.get(existing.value, this.#graph, this.#options);
+    }
+    let publicId = (0, _utils.getPublicId)(bundleId, existing => this.#bundlePublicIds.has(existing));
+    this.#bundlePublicIds.add(publicId);
+    let isPlaceholder = false;
+    if (entryAsset) {
+      let entryAssetNode = this.#graph._graph.getNodeByContentKey(entryAsset.id);
+      (0, _assert().default)((entryAssetNode === null || entryAssetNode === void 0 ? void 0 : entryAssetNode.type) === 'asset', 'Entry asset does not exist');
+      isPlaceholder = entryAssetNode.requested === false;
+    }
+    let bundleNode = {
+      type: 'bundle',
+      id: bundleId,
+      value: {
+        id: bundleId,
+        hashReference: this.#options.shouldContentHash ? _constants.HASH_REF_PREFIX + bundleId : bundleId.slice(-8),
+        type: opts.entryAsset ? opts.entryAsset.type : opts.type,
+        env: opts.env ? (0, _Environment.environmentToInternalEnvironment)(opts.env) : (0, _nullthrows().default)(entryAsset).env,
+        entryAssetIds: entryAsset ? [entryAsset.id] : [],
+        mainEntryId: entryAsset === null || entryAsset === void 0 ? void 0 : entryAsset.id,
+        pipeline: opts.entryAsset ? opts.entryAsset.pipeline : opts.pipeline,
+        needsStableName: opts.needsStableName,
+        bundleBehavior: opts.bundleBehavior != null ? _types.BundleBehavior[opts.bundleBehavior] : null,
+        isSplittable: opts.entryAsset ? opts.entryAsset.isBundleSplittable : opts.isSplittable,
+        isPlaceholder,
+        target,
+        name: null,
+        displayName: null,
+        publicId,
+        manualSharedBundle: opts.manualSharedBundle
+      }
+    };
+    let bundleNodeId = this.#graph._graph.addNodeByContentKey(bundleId, bundleNode);
+    if (opts.entryAsset) {
+      this.#graph._graph.addEdge(bundleNodeId, this.#graph._graph.getNodeIdByContentKey(opts.entryAsset.id));
+    }
+    return _Bundle.Bundle.get(bundleNode.value, this.#graph, this.#options);
+  }
+  addBundleToBundleGroup(bundle, bundleGroup) {
+    this.#graph.addBundleToBundleGroup((0, _Bundle.bundleToInternalBundle)(bundle), (0, _BundleGroup.bundleGroupToInternalBundleGroup)(bundleGroup));
+  }
+  createAssetReference(dependency, asset, bundle) {
+    return this.#graph.createAssetReference((0, _Dependency.dependencyToInternalDependency)(dependency), (0, _Asset.assetToAssetValue)(asset), (0, _Bundle.bundleToInternalBundle)(bundle));
+  }
+  createBundleReference(from, to) {
+    return this.#graph.createBundleReference((0, _Bundle.bundleToInternalBundle)(from), (0, _Bundle.bundleToInternalBundle)(to));
+  }
+  getDependencyAssets(dependency) {
+    return this.#graph.getDependencyAssets((0, _Dependency.dependencyToInternalDependency)(dependency)).map(asset => (0, _Asset.assetFromValue)(asset, this.#options));
+  }
+  getBundleGroupsContainingBundle(bundle) {
+    return this.#graph.getBundleGroupsContainingBundle((0, _Bundle.bundleToInternalBundle)(bundle)).map(bundleGroup => new _BundleGroup.default(bundleGroup, this.#options));
+  }
+  getParentBundlesOfBundleGroup(bundleGroup) {
+    return this.#graph.getParentBundlesOfBundleGroup((0, _BundleGroup.bundleGroupToInternalBundleGroup)(bundleGroup)).map(bundle => _Bundle.Bundle.get(bundle, this.#graph, this.#options));
+  }
+  getTotalSize(asset) {
+    return this.#graph.getTotalSize((0, _Asset.assetToAssetValue)(asset));
+  }
+  isAssetReachableFromBundle(asset, bundle) {
+    return this.#graph.isAssetReachableFromBundle((0, _Asset.assetToAssetValue)(asset), (0, _Bundle.bundleToInternalBundle)(bundle));
+  }
+  removeAssetGraphFromBundle(asset, bundle) {
+    this.#graph.removeAssetGraphFromBundle((0, _Asset.assetToAssetValue)(asset), (0, _Bundle.bundleToInternalBundle)(bundle));
+  }
+}
+exports.default = MutableBundleGraph;

package/lib/public/PluginOptions.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+let atlaspackOptionsToPluginOptions = new WeakMap();
+class PluginOptions {
+  #options /*: AtlaspackOptions */;
+
+  constructor(options) {
+    let existing = atlaspackOptionsToPluginOptions.get(options);
+    if (existing != null) {
+      return existing;
+    }
+    this.#options = options;
+    atlaspackOptionsToPluginOptions.set(options, this);
+    return this;
+  }
+  get instanceId() {
+    return this.#options.instanceId;
+  }
+  get mode() {
+    return this.#options.mode;
+  }
+  get env() {
+    return this.#options.env;
+  }
+  get atlaspackVersion() {
+    return this.#options.atlaspackVersion;
+  }
+  get hmrOptions() {
+    return this.#options.hmrOptions;
+  }
+  get serveOptions() {
+    return this.#options.serveOptions;
+  }
+  get shouldBuildLazily() {
+    return this.#options.shouldBuildLazily;
+  }
+  get shouldAutoInstall() {
+    return this.#options.shouldAutoInstall;
+  }
+  get logLevel() {
+    return this.#options.logLevel;
+  }
+  get cacheDir() {
+    // TODO: remove this. Probably bad if there are other types of caches.
+    // Maybe expose the Cache object instead?
+    return this.#options.cacheDir;
+  }
+  get projectRoot() {
+    return this.#options.projectRoot;
+  }
+  get inputFS() {
+    return this.#options.inputFS;
+  }
+  get outputFS() {
+    return this.#options.outputFS;
+  }
+  get packageManager() {
+    return this.#options.packageManager;
+  }
+  get detailedReport() {
+    return this.#options.detailedReport;
+  }
+  get featureFlags() {
+    return this.#options.featureFlags;
+  }
+}
+exports.default = PluginOptions;

package/lib/public/Symbols.js

@@ -0,0 +1,247 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MutableDependencySymbols = exports.MutableAssetSymbols = exports.AssetSymbols = void 0;
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const EMPTY_ITERABLE = {
+  [Symbol.iterator]() {
+    return EMPTY_ITERATOR;
+  }
+};
+const EMPTY_ITERATOR = {
+  next() {
+    return {
+      done: true
+    };
+  }
+};
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+let valueToSymbols = new WeakMap();
+class AssetSymbols {
+  /*::
+  @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|}]> { return ({}: any); }
+  */
+  #value;
+  #options;
+  constructor(options, asset) {
+    let existing = valueToSymbols.get(asset);
+    if (existing != null) {
+      return existing;
+    }
+    this.#value = asset;
+    this.#options = options;
+    valueToSymbols.set(asset, this);
+    return this;
+  }
+  hasExportSymbol(exportSymbol) {
+    var _this$value$symbols;
+    return Boolean((_this$value$symbols = this.#value.symbols) === null || _this$value$symbols === void 0 ? void 0 : _this$value$symbols.has(exportSymbol));
+  }
+  hasLocalSymbol(local) {
+    if (this.#value.symbols == null) {
+      return false;
+    }
+    for (let s of this.#value.symbols.values()) {
+      if (local === s.local) return true;
+    }
+    return false;
+  }
+  get(exportSymbol) {
+    var _this$value$symbols2;
+    return fromInternalAssetSymbol(this.#options.projectRoot, (_this$value$symbols2 = this.#value.symbols) === null || _this$value$symbols2 === void 0 ? void 0 : _this$value$symbols2.get(exportSymbol));
+  }
+  get isCleared() {
+    return this.#value.symbols == null;
+  }
+  exportSymbols() {
+    var _this$value$symbols3;
+    return ((_this$value$symbols3 = this.#value.symbols) === null || _this$value$symbols3 === void 0 ? void 0 : _this$value$symbols3.keys()) ?? [];
+  }
+  // $FlowFixMe
+  [Symbol.iterator]() {
+    return this.#value.symbols ? this.#value.symbols[Symbol.iterator]() : EMPTY_ITERATOR;
+  }
+
+  // $FlowFixMe
+  [inspect]() {
+    return `AssetSymbols(${this.#value.symbols ? [...this.#value.symbols].map(([s, {
+      local
+    }]) => `${s}:${local}`).join(', ') : null})`;
+  }
+}
+exports.AssetSymbols = AssetSymbols;
+let valueToMutableAssetSymbols = new WeakMap();
+class MutableAssetSymbols {
+  /*::
+  @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|}]> { return ({}: any); }
+  */
+  #value;
+  #options;
+  constructor(options, asset) {
+    let existing = valueToMutableAssetSymbols.get(asset);
+    if (existing != null) {
+      return existing;
+    }
+    this.#value = asset;
+    this.#options = options;
+    return this;
+  }
+
+  // immutable
+
+  hasExportSymbol(exportSymbol) {
+    var _this$value$symbols4;
+    return Boolean((_this$value$symbols4 = this.#value.symbols) === null || _this$value$symbols4 === void 0 ? void 0 : _this$value$symbols4.has(exportSymbol));
+  }
+  hasLocalSymbol(local) {
+    if (this.#value.symbols == null) {
+      return false;
+    }
+    for (let s of this.#value.symbols.values()) {
+      if (local === s.local) return true;
+    }
+    return false;
+  }
+  get(exportSymbol) {
+    var _this$value$symbols5;
+    return fromInternalAssetSymbol(this.#options.projectRoot, (_this$value$symbols5 = this.#value.symbols) === null || _this$value$symbols5 === void 0 ? void 0 : _this$value$symbols5.get(exportSymbol));
+  }
+  get isCleared() {
+    return this.#value.symbols == null;
+  }
+  exportSymbols() {
+    // $FlowFixMe
+    return this.#value.symbols.keys();
+  }
+  // $FlowFixMe
+  [Symbol.iterator]() {
+    return this.#value.symbols ? this.#value.symbols[Symbol.iterator]() : EMPTY_ITERATOR;
+  }
+
+  // $FlowFixMe
+  [inspect]() {
+    return `MutableAssetSymbols(${this.#value.symbols ? [...this.#value.symbols].map(([s, {
+      local
+    }]) => `${s}:${local}`).join(', ') : null})`;
+  }
+
+  // mutating
+
+  ensure() {
+    if (this.#value.symbols == null) {
+      this.#value.symbols = new Map();
+    }
+  }
+  set(exportSymbol, local, loc, meta) {
+    (0, _nullthrows().default)(this.#value.symbols).set(exportSymbol, {
+      local,
+      loc: (0, _utils.toInternalSourceLocation)(this.#options.projectRoot, loc),
+      meta
+    });
+  }
+  delete(exportSymbol) {
+    (0, _nullthrows().default)(this.#value.symbols).delete(exportSymbol);
+  }
+}
+exports.MutableAssetSymbols = MutableAssetSymbols;
+let valueToMutableDependencySymbols = new WeakMap();
+class MutableDependencySymbols {
+  /*::
+  @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, isWeak: boolean, meta?: ?Meta|}]> { return ({}: any); }
+  */
+  #value;
+  #options;
+  constructor(options, dep) {
+    let existing = valueToMutableDependencySymbols.get(dep);
+    if (existing != null) {
+      return existing;
+    }
+    this.#value = dep;
+    this.#options = options;
+    return this;
+  }
+
+  // immutable:
+
+  hasExportSymbol(exportSymbol) {
+    var _this$value$symbols6;
+    return Boolean((_this$value$symbols6 = this.#value.symbols) === null || _this$value$symbols6 === void 0 ? void 0 : _this$value$symbols6.has(exportSymbol));
+  }
+  hasLocalSymbol(local) {
+    if (this.#value.symbols) {
+      for (let s of this.#value.symbols.values()) {
+        if (local === s.local) return true;
+      }
+    }
+    return false;
+  }
+  get(exportSymbol) {
+    return fromInternalDependencySymbol(this.#options.projectRoot, (0, _nullthrows().default)(this.#value.symbols).get(exportSymbol));
+  }
+  get isCleared() {
+    return this.#value.symbols == null;
+  }
+  exportSymbols() {
+    // $FlowFixMe
+    return this.#value.symbols ? this.#value.symbols.keys() : EMPTY_ITERABLE;
+  }
+
+  // $FlowFixMe
+  [Symbol.iterator]() {
+    return this.#value.symbols ? this.#value.symbols[Symbol.iterator]() : EMPTY_ITERATOR;
+  }
+
+  // $FlowFixMe
+  [inspect]() {
+    return `MutableDependencySymbols(${this.#value.symbols ? [...this.#value.symbols].map(([s, {
+      local,
+      isWeak
+    }]) => `${s}:${local}${isWeak ? '?' : ''}`).join(', ') : null})`;
+  }
+
+  // mutating:
+
+  ensure() {
+    if (this.#value.symbols == null) {
+      this.#value.symbols = new Map();
+    }
+  }
+  set(exportSymbol, local, loc, isWeak) {
+    var _symbols$get;
+    let symbols = (0, _nullthrows().default)(this.#value.symbols);
+    symbols.set(exportSymbol, {
+      local,
+      loc: (0, _utils.toInternalSourceLocation)(this.#options.projectRoot, loc),
+      isWeak: (((_symbols$get = symbols.get(exportSymbol)) === null || _symbols$get === void 0 ? void 0 : _symbols$get.isWeak) ?? true) && (isWeak ?? false)
+    });
+  }
+  delete(exportSymbol) {
+    (0, _nullthrows().default)(this.#value.symbols).delete(exportSymbol);
+  }
+}
+exports.MutableDependencySymbols = MutableDependencySymbols;
+function fromInternalAssetSymbol(projectRoot, value) {
+  return value && {
+    local: value.local,
+    meta: value.meta,
+    loc: (0, _utils.fromInternalSourceLocation)(projectRoot, value.loc)
+  };
+}
+function fromInternalDependencySymbol(projectRoot, value) {
+  return value && {
+    local: value.local,
+    meta: value.meta,
+    isWeak: value.isWeak,
+    loc: (0, _utils.fromInternalSourceLocation)(projectRoot, value.loc)
+  };
+}

package/lib/public/Target.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.targetToInternalTarget = targetToInternalTarget;
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _Environment = _interopRequireDefault(require("./Environment"));
+var _projectPath = require("../projectPath");
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const internalTargetToTarget = new WeakMap();
+const _targetToInternalTarget = new WeakMap();
+function targetToInternalTarget(target) {
+  return (0, _nullthrows().default)(_targetToInternalTarget.get(target));
+}
+class Target {
+  #target /*: TargetValue */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(target, options) {
+    let existing = internalTargetToTarget.get(target);
+    if (existing != null) {
+      return existing;
+    }
+    this.#target = target;
+    this.#options = options;
+    _targetToInternalTarget.set(this, target);
+    internalTargetToTarget.set(target, this);
+    return this;
+  }
+  get distEntry() {
+    return this.#target.distEntry;
+  }
+  get distDir() {
+    return (0, _projectPath.fromProjectPath)(this.#options.projectRoot, this.#target.distDir);
+  }
+  get env() {
+    return new _Environment.default(this.#target.env, this.#options);
+  }
+  get name() {
+    return this.#target.name;
+  }
+  get publicUrl() {
+    return this.#target.publicUrl;
+  }
+  get loc() {
+    return (0, _utils.fromInternalSourceLocation)(this.#options.projectRoot, this.#target.loc);
+  }
+
+  // $FlowFixMe[unsupported-syntax]
+  [inspect]() {
+    return `Target(${this.name} - ${this.env[inspect]()})`;
+  }
+}
+exports.default = Target;

package/lib/registerCoreWithSerializer.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.registerCoreWithSerializer = registerCoreWithSerializer;
+function _graph() {
+  const data = require("@atlaspack/graph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+var _serializer = require("./serializer");
+var _AssetGraph = _interopRequireDefault(require("./AssetGraph"));
+var _BundleGraph = _interopRequireDefault(require("./BundleGraph"));
+var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
+var _RequestTracker = require("./RequestTracker");
+var _Config = _interopRequireDefault(require("./public/Config"));
+var _package = _interopRequireDefault(require("../package.json"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+let coreRegistered;
+function registerCoreWithSerializer() {
+  if (coreRegistered) {
+    return;
+  }
+  const packageVersion = _package.default.version;
+  if (typeof packageVersion !== 'string') {
+    throw new Error('Expected package version to be a string');
+  }
+
+  // $FlowFixMe[incompatible-cast]
+  for (let [name, ctor] of Object.entries({
+    AssetGraph: _AssetGraph.default,
+    Config: _Config.default,
+    BundleGraph: _BundleGraph.default,
+    Graph: _graph().Graph,
+    AtlaspackConfig: _AtlaspackConfig.default,
+    RequestGraph: _RequestTracker.RequestGraph
+    // $FlowFixMe[unclear-type]
+  })) {
+    (0, _serializer.registerSerializableClass)(packageVersion + ':' + name, ctor);
+  }
+  coreRegistered = true;
+}