@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/lib/requests/asset-graph-dot.js

@@ -13,8 +13,7 @@ function _path() {
   };
   return data;
 }
-var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /** @description Renders AssetGraph into GraphViz Dot format */
 function assetGraphToDot(assetGraph, {
   sort = false,
@@ -41,8 +40,6 @@ function assetGraphToDot(assetGraph, {
       edges.push(entry);
     }
   });
-
-  // $FlowFixMe
   const nodeStylesList = Object.entries(nodeStyles);
   if (sort) {
     edges.sort();
@@ -83,18 +80,15 @@ function fromCwd(input) {
 }
 function getNodeName(node) {
   if (node.type === 'asset_group') {
-    // $FlowFixMe
+    // @ts-expect-error TS2345
     return [`asset_group`, node.id, fromCwd(node.value.filePath)].join('\\n');
   } else if (node.type === 'asset') {
-    // $FlowFixMe
     return [`asset`, node.id, fromCwd(node.value.filePath)].join('\\n');
   } else if (node.type === 'dependency') {
     return [`dependency`, node.id, node.value.specifier].join('\\n');
   } else if (node.type === 'entry_specifier') {
-    // $FlowFixMe
     return [`entry_specifier`, node.value].join('\\n');
   } else if (node.type === 'entry_file') {
-    // $FlowFixMe
     return [`entry_file`, fromCwd(node.value.filePath)].join('\\n');
   }
   return 'ROOT';

package/lib/resolveOptions.js

@@ -57,7 +57,7 @@ var _loadDotEnv = _interopRequireDefault(require("./loadDotEnv"));
 var _projectPath = require("./projectPath");
 var _AtlaspackConfigRequest = require("./requests/AtlaspackConfigRequest");
 var _constants = require("./constants");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // Default cache directory name
 const DEFAULT_CACHE_DIRNAME = '.parcel-cache';
 const LOCK_FILE_NAMES = ['yarn.lock', 'package-lock.json', 'pnpm-lock.yaml'];
@@ -106,6 +106,21 @@ async function resolveOptions(initialOptions) {
   } else {
     entries = [_path().default.resolve(inputCwd, initialOptions.entries)];
   }
+
+  // When allowExplicitTargetEntries is enabled and no entries are provided,
+  // automatically derive entries from target sources
+  if ((0, _featureFlags().getFeatureFlag)('allowExplicitTargetEntries') && initialOptions.targets && !Array.isArray(initialOptions.targets) && entries.length === 0) {
+    const targetSources = new Set();
+    for (const [, target] of Object.entries(initialOptions.targets)) {
+      if (target.source) {
+        const sources = Array.isArray(target.source) ? target.source : [target.source];
+        for (const source of sources) {
+          targetSources.add(source);
+        }
+      }
+    }
+    entries = Array.from(targetSources);
+  }
   let shouldMakeEntryReferFolder = false;
   if (entries.length === 1 && !(0, _utils().isGlob)(entries[0])) {
     let [entry] = entries;
@@ -115,13 +130,21 @@ async function resolveOptions(initialOptions) {
       // ignore failing stat call
     }
   }
+  let projectRoot;
+  if (initialOptions.projectRoot) {
+    // Use explicitly provided projectRoot
+    if (!_path().default.isAbsolute(initialOptions.projectRoot)) {
+      throw new Error('Specified project root must be an absolute path');
+    }
+    projectRoot = initialOptions.projectRoot;
+  } else {
+    // getRootDir treats the input as files, so getRootDir(["/home/user/myproject"]) returns "/home/user".
+    // Instead we need to make the the entry refer to some file inside the specified folders if entries refers to the directory.
+    let entryRoot = (0, _utils().getRootDir)(shouldMakeEntryReferFolder ? [_path().default.join(entries[0], 'index')] : entries);
+    let projectRootFile = (await (0, _utils().resolveConfig)(inputFS, _path().default.join(entryRoot, 'index'), [...LOCK_FILE_NAMES, '.git', '.hg'], _path().default.parse(entryRoot).root)) || _path().default.join(inputCwd, 'index'); // ? Should this just be rootDir
 
-  // getRootDir treats the input as files, so getRootDir(["/home/user/myproject"]) returns "/home/user".
-  // Instead we need to make the the entry refer to some file inside the specified folders if entries refers to the directory.
-  let entryRoot = (0, _utils().getRootDir)(shouldMakeEntryReferFolder ? [_path().default.join(entries[0], 'index')] : entries);
-  let projectRootFile = (await (0, _utils().resolveConfig)(inputFS, _path().default.join(entryRoot, 'index'), [...LOCK_FILE_NAMES, '.git', '.hg'], _path().default.parse(entryRoot).root)) || _path().default.join(inputCwd, 'index'); // ? Should this just be rootDir
-
-  let projectRoot = _path().default.dirname(projectRootFile);
+    projectRoot = _path().default.dirname(projectRootFile);
+  }
   const gitRoot = await findGitRepositoryRoot(inputFS, projectRoot);
   if (inputFS instanceof _fs().NodeVCSAwareFS) {
     inputFS.setGitRepoPath(gitRoot);
@@ -139,18 +162,17 @@ async function resolveOptions(initialOptions) {
   // where symlinked dependencies outside the project root need to trigger HMR
   // updates. Default to the project root if not provided.
   let watchDir = initialOptions.watchDir != null ? _path().default.resolve(initialOptions.watchDir) : projectRoot;
-  let cache = function createCache() {
+  function createCache() {
     if (initialOptions.cache) {
       return initialOptions.cache;
     }
-    const needsRustLmdbCache = (0, _featureFlags().getFeatureFlag)('atlaspackV3');
-    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
-        return new (_cache().FSCache)(outputFS, cacheDir);
-      }
+    const needsRustLmdbCache = (0, _featureFlags().getFeatureFlag)('atlaspackV3') || (0, _featureFlags().getFeatureFlag)('nativePackager');
+    if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
+      return new (_cache().FSCache)(outputFS, cacheDir);
     }
     return new (_cache().LMDBLiteCache)(cacheDir);
-  }();
+  }
+  let cache = createCache();
   let mode = initialOptions.mode ?? 'development';
   let shouldOptimize = (initialOptions === null || initialOptions === void 0 || (_initialOptions$defau = initialOptions.defaultTargetOptions) === null || _initialOptions$defau === void 0 ? void 0 : _initialOptions$defau.shouldOptimize) ?? mode === 'production';
   let publicUrl = (initialOptions === null || initialOptions === void 0 || (_initialOptions$defau2 = initialOptions.defaultTargetOptions) === null || _initialOptions$defau2 === void 0 ? void 0 : _initialOptions$defau2.publicUrl) ?? '/';
@@ -195,6 +217,7 @@ async function resolveOptions(initialOptions) {
     } : false,
     shouldDisableCache: initialOptions.shouldDisableCache ?? false,
     shouldProfile: initialOptions.shouldProfile ?? false,
+    nativeProfiler: initialOptions.nativeProfiler,
     shouldTrace: initialOptions.shouldTrace ?? false,
     cacheDir,
     watchDir,

package/lib/rustWorkerThreadDylibHack.js

@@ -14,7 +14,6 @@ exports.loadRustWorkerThreadDylibHack = loadRustWorkerThreadDylibHack;
  */
 function loadRustWorkerThreadDylibHack() {
   try {
-    // $FlowFixMe
     require('@parcel/rust'); // eslint-disable-line
   } catch (err) {
     /* ignore */

package/lib/serializerCore.browser.js

@@ -18,8 +18,7 @@ function msgpackr() {
   };
   return data;
 }
-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 _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 let encoder = new (msgpackr().Encoder)({
   structuredClone: true
 });

package/lib/summarizeRequest.js

@@ -11,7 +11,7 @@ function _path() {
   };
   return data;
 }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const NODE_MODULES = `${_path().default.sep}node_modules${_path().default.sep}`;
 const BUFFER_LIMIT = 5000000; // 5mb
 

package/lib/types/AssetGraph.d.ts

@@ -0,0 +1,55 @@
+import type { GraphVisitor } from '@atlaspack/types';
+import type { ContentGraphOpts, ContentKey, NodeId, SerializedContentGraph } from '@atlaspack/graph';
+import type { Asset, AssetGraphNode, AssetGroup, AssetGroupNode, AssetNode, Dependency, DependencyNode, Entry, EntryFileNode, EntrySpecifierNode, Environment, Target } from './types';
+import { ContentGraph } from '@atlaspack/graph';
+import { ProjectPath } from './projectPath';
+type InitOpts = {
+    entries?: Array<ProjectPath>;
+    targets?: Array<Target>;
+    assetGroups?: Array<AssetGroup>;
+};
+type AssetGraphOpts = ContentGraphOpts<AssetGraphNode> & {
+    hash?: string | null | undefined;
+};
+type SerializedAssetGraph = SerializedContentGraph<AssetGraphNode> & {
+    hash?: string | null | undefined;
+};
+export declare function nodeFromDep(dep: Dependency): DependencyNode;
+export declare function nodeFromAssetGroup(assetGroup: AssetGroup): AssetGroupNode;
+export declare function nodeFromAsset(asset: Asset): AssetNode;
+export declare function nodeFromEntrySpecifier(entry: ProjectPath): EntrySpecifierNode;
+export declare function nodeFromEntryFile(entry: Entry): EntryFileNode;
+export default class AssetGraph extends ContentGraph<AssetGraphNode> {
+    onNodeRemoved: ((nodeId: NodeId) => unknown) | null | undefined;
+    hash: string | null | undefined;
+    envCache: Map<string, Environment>;
+    safeToIncrementallyBundle: boolean;
+    undeferredDependencies: Set<Dependency>;
+    constructor(opts?: AssetGraphOpts | null);
+    static deserialize(opts: AssetGraphOpts): AssetGraph;
+    serialize(): SerializedAssetGraph;
+    /**
+     * Determine if we can incrementally bundle, which will not require a full bundling pass
+     * but just update assets into the bundle graph output.
+     */
+    canIncrementallyBundle(): boolean;
+    normalizeEnvironment(input: Asset | Dependency | AssetGroup): void;
+    setRootConnections({ entries, assetGroups }: InitOpts): void;
+    addNode(node: AssetGraphNode): NodeId;
+    removeNode(nodeId: NodeId): void;
+    resolveEntry(entry: ProjectPath, resolved: Array<Entry>, correspondingRequest: ContentKey): void;
+    resolveTargets(entry: Entry, targets: Array<Target>, correspondingRequest: string): void;
+    resolveDependency(dependency: Dependency, assetGroup: AssetGroup | null | undefined, correspondingRequest: string): void;
+    shouldVisitChild(nodeId: NodeId, childNodeId: NodeId): boolean;
+    markParentsWithHasDeferred(nodeId: NodeId): void;
+    unmarkParentsWithHasDeferred(nodeId: NodeId): void;
+    shouldDeferDependency(dependency: Dependency, sideEffects: boolean | null | undefined, canDefer: boolean): boolean;
+    resolveAssetGroup(assetGroup: AssetGroup, assets: Array<Asset>, correspondingRequest: ContentKey): void;
+    resolveAsset(assetNode: AssetNode, dependentAssets: Array<Asset>): void;
+    getIncomingDependencies(asset: Asset): Array<Dependency>;
+    traverseAssets<TContext>(visit: GraphVisitor<Asset, TContext>, startNodeId?: NodeId | null): TContext | null | undefined;
+    getEntryAssetGroupNodes(): Array<AssetGroupNode>;
+    getEntryAssets(): Array<Asset>;
+    getHash(): string;
+}
+export {};

package/lib/types/Atlaspack.d.ts

@@ -0,0 +1,52 @@
+import type { Asset, AsyncSubscription, BuildEvent, BuildSuccessEvent, InitialAtlaspackOptions, AtlaspackTransformOptions, AtlaspackResolveOptions, AtlaspackResolveResult } from '@atlaspack/types';
+import type { AtlaspackOptions } from './types';
+import type { FarmOptions } from '@atlaspack/workers';
+import type { Diagnostic } from '@atlaspack/diagnostic';
+import ThrowableDiagnostic from '@atlaspack/diagnostic';
+import WorkerFarm from '@atlaspack/workers';
+import { AtlaspackV3 } from './atlaspack-v3';
+import type { AssetGraphRequestResult } from './requests/AssetGraphRequest';
+export declare const INTERNAL_TRANSFORM: symbol;
+export declare const INTERNAL_RESOLVE: symbol;
+export declare let WORKER_PATH: string;
+export default class Atlaspack {
+    #private;
+    rustAtlaspack: AtlaspackV3 | null | undefined;
+    isProfiling: boolean;
+    constructor(options: InitialAtlaspackOptions);
+    _init(): Promise<void>;
+    run(): Promise<BuildSuccessEvent>;
+    _end(): Promise<void>;
+    writeRequestTrackerToCache(): Promise<void>;
+    _startNextBuild(): Promise<BuildEvent | null | undefined>;
+    watch(cb?: (err?: Error | null | undefined, buildEvent?: BuildEvent) => unknown): Promise<AsyncSubscription>;
+    _build({ signal, startTime, }?: {
+        signal?: AbortSignal;
+        startTime?: number;
+    }): Promise<BuildEvent>;
+    _getWatcherSubscription(): Promise<AsyncSubscription>;
+    _getResolvedAtlaspackOptions(): AtlaspackOptions;
+    startProfiling(): Promise<void>;
+    stopProfiling(): Promise<void>;
+    takeHeapSnapshot(): Promise<void>;
+    /**
+     * Must be called between builds otherwise there is global state that will
+     * break things unexpectedly.
+     */
+    clearBuildCaches(): Promise<void>;
+    unstable_invalidate(): Promise<void>;
+    /**
+     * Build the asset graph
+     */
+    unstable_buildAssetGraph(writeToCache?: boolean): Promise<AssetGraphRequestResult>;
+    /**
+     * Copy the cache to a new directory and compact it.
+     */
+    unstable_compactCache(): Promise<void>;
+    unstable_transform(options: AtlaspackTransformOptions): Promise<Array<Asset>>;
+    unstable_resolve(request: AtlaspackResolveOptions): Promise<AtlaspackResolveResult | null | undefined>;
+}
+export declare class BuildError extends ThrowableDiagnostic {
+    constructor(diagnostic: Array<Diagnostic> | Diagnostic);
+}
+export declare function createWorkerFarm(options?: Partial<FarmOptions>): WorkerFarm;

package/lib/types/AtlaspackConfig.d.ts

@@ -0,0 +1,65 @@
+import type { Glob, Transformer, Resolver, Bundler, Namer, Runtime, PackageName, Optimizer, Compressor, Packager, Reporter, Semver, Validator, FilePath } from '@atlaspack/types';
+import type { ProcessedAtlaspackConfig, AtlaspackPluginNode, PureAtlaspackConfigPipeline, ExtendableAtlaspackConfigPipeline, AtlaspackOptions } from './types';
+import ThrowableDiagnostic from '@atlaspack/diagnostic';
+import { ProjectPath } from './projectPath';
+type GlobMap<T> = Partial<Record<Glob, T>>;
+type SerializedAtlaspackConfig = {
+    $$raw: boolean;
+    config: ProcessedAtlaspackConfig;
+    options: AtlaspackOptions;
+};
+export type LoadedPlugin<T> = {
+    name: string;
+    version: Semver;
+    plugin: T;
+    resolveFrom: ProjectPath;
+    keyPath?: string;
+};
+export declare class AtlaspackConfig {
+    options: AtlaspackOptions;
+    filePath: ProjectPath;
+    resolvers: PureAtlaspackConfigPipeline;
+    transformers: GlobMap<ExtendableAtlaspackConfigPipeline>;
+    bundler: AtlaspackPluginNode | null | undefined;
+    namers: PureAtlaspackConfigPipeline;
+    runtimes: PureAtlaspackConfigPipeline;
+    packagers: GlobMap<AtlaspackPluginNode>;
+    validators: GlobMap<ExtendableAtlaspackConfigPipeline>;
+    optimizers: GlobMap<ExtendableAtlaspackConfigPipeline>;
+    compressors: GlobMap<ExtendableAtlaspackConfigPipeline>;
+    reporters: PureAtlaspackConfigPipeline;
+    pluginCache: Map<PackageName, any>;
+    regexCache: Map<string, RegExp>;
+    constructor(config: ProcessedAtlaspackConfig, options: AtlaspackOptions);
+    static deserialize(serialized: SerializedAtlaspackConfig): AtlaspackConfig;
+    getConfig(): ProcessedAtlaspackConfig;
+    serialize(): SerializedAtlaspackConfig;
+    _loadPlugin<T>(node: AtlaspackPluginNode): Promise<{
+        plugin: T;
+        version: Semver;
+        resolveFrom: ProjectPath;
+    }>;
+    loadPlugin<T>(node: AtlaspackPluginNode): Promise<LoadedPlugin<T>>;
+    invalidatePlugin(packageName: PackageName): void;
+    loadPlugins<T>(plugins: PureAtlaspackConfigPipeline): Promise<Array<LoadedPlugin<T>>>;
+    getResolvers(): Promise<Array<LoadedPlugin<Resolver<unknown>>>>;
+    _getValidatorNodes(filePath: ProjectPath): ReadonlyArray<AtlaspackPluginNode>;
+    getValidatorNames(filePath: ProjectPath): Array<string>;
+    getValidators(filePath: ProjectPath): Promise<Array<LoadedPlugin<Validator>>>;
+    getNamedPipelines(): ReadonlyArray<string>;
+    getTransformers(filePath: ProjectPath, pipeline?: string | null, allowEmpty?: boolean): Promise<Array<LoadedPlugin<Transformer<unknown>>>>;
+    getBundler(): Promise<LoadedPlugin<Bundler<unknown>>>;
+    getNamers(): Promise<Array<LoadedPlugin<Namer<unknown>>>>;
+    getRuntimes(): Promise<Array<LoadedPlugin<Runtime<unknown>>>>;
+    getPackager(filePath: FilePath): Promise<LoadedPlugin<Packager<unknown, unknown>>>;
+    _getOptimizerNodes(filePath: FilePath, pipeline?: string | null): PureAtlaspackConfigPipeline;
+    getOptimizerNames(filePath: FilePath, pipeline?: string | null): Array<string>;
+    getOptimizers(filePath: FilePath, pipeline?: string | null): Promise<Array<LoadedPlugin<Optimizer<unknown, unknown>>>>;
+    getCompressors(filePath: FilePath): Promise<Array<LoadedPlugin<Compressor>>>;
+    getReporters(): Promise<Array<LoadedPlugin<Reporter>>>;
+    isGlobMatch(projectPath: ProjectPath, pattern: Glob, pipeline?: string | null): boolean;
+    matchGlobMap<T>(filePath: ProjectPath, globMap: Partial<Record<Glob, T>>): T | null | undefined;
+    matchGlobMapPipelines(filePath: ProjectPath, globMap: Partial<Record<Glob, ExtendableAtlaspackConfigPipeline>>, pipeline?: string | null): PureAtlaspackConfigPipeline;
+    missingPluginError(plugins: GlobMap<ExtendableAtlaspackConfigPipeline> | GlobMap<AtlaspackPluginNode> | PureAtlaspackConfigPipeline, message: string, key: string): Promise<ThrowableDiagnostic>;
+}
+export {};

package/lib/types/AtlaspackConfig.schema.d.ts

@@ -0,0 +1,53 @@
+import type { PackageName } from '@atlaspack/types';
+import type { SchemaEntity } from '@atlaspack/utils';
+export declare function validatePackageName(pkg: PackageName | null | undefined, pluginType: string, key: string): void;
+declare const _default: {
+    type: string;
+    properties: {
+        $schema: {
+            type: string;
+        };
+        extends: {
+            oneOf: ({
+                type: string;
+                __validate: (val: string) => void;
+                items?: undefined;
+            } | {
+                type: string;
+                items: {
+                    type: string;
+                    __validate: (val: string) => void;
+                };
+                __validate?: undefined;
+            })[];
+        };
+        bundler: {
+            type: string;
+            __validate: (arg1: string) => void;
+        };
+        resolvers: SchemaEntity;
+        transformers: SchemaEntity;
+        validators: SchemaEntity;
+        namers: SchemaEntity;
+        packagers: SchemaEntity;
+        optimizers: SchemaEntity;
+        compressors: SchemaEntity;
+        reporters: SchemaEntity;
+        runtimes: SchemaEntity;
+        unstable_alias: {
+            type: string;
+            properties: {};
+            additionalProperties: {
+                type: string;
+            };
+        };
+        filePath: {
+            type: string;
+        };
+        resolveFrom: {
+            type: string;
+        };
+    };
+    additionalProperties: boolean;
+};
+export default _default;

package/lib/types/BundleGraph.d.ts

@@ -0,0 +1,232 @@
+import type { GraphVisitor, FilePath, TraversalActions, BundleBehavior as IBundleBehavior, Symbol } from '@atlaspack/types';
+import type { ContentGraphOpts, NodeId, SerializedContentGraph } from '@atlaspack/graph';
+import type { Asset, AssetNode, Bundle, BundleGraphNode, BundleGroup, Dependency, DependencyNode, InternalSourceLocation, Target, Condition } from './types';
+import type AssetGraph from './AssetGraph';
+import type { ProjectPath } from './projectPath';
+import { ContentGraph } from '@atlaspack/graph';
+import type { EnvironmentRef } from './EnvironmentManager';
+export declare const bundleGraphEdgeTypes: {
+    readonly null: 1;
+    readonly contains: 2;
+    readonly bundle: 3;
+    readonly references: 4;
+    readonly internal_async: 5;
+    readonly conditional: 6;
+};
+export type BundleGraphEdgeType = (typeof bundleGraphEdgeTypes)[keyof typeof bundleGraphEdgeTypes];
+type InternalSymbolResolution = {
+    asset: Asset;
+    exportSymbol: string;
+    symbol: Symbol | null | undefined | false;
+    loc: InternalSourceLocation | null | undefined;
+};
+type InternalExportSymbolResolution = InternalSymbolResolution & {
+    readonly exportAs: Symbol | string;
+};
+type BundleGraphOpts = {
+    graph: ContentGraphOpts<BundleGraphNode, BundleGraphEdgeType>;
+    bundleContentHashes: Map<string, string>;
+    assetPublicIds: Set<string>;
+    publicIdByAssetId: Map<string, string>;
+    conditions: Map<string, Condition>;
+};
+type SerializedBundleGraph = {
+    $$raw: true;
+    graph: SerializedContentGraph<BundleGraphNode, BundleGraphEdgeType>;
+    bundleContentHashes: Map<string, string>;
+    assetPublicIds: Set<string>;
+    publicIdByAssetId: Map<string, string>;
+    conditions: Map<string, Condition>;
+};
+/**
+ * Stores assets, dependencies, bundle groups, bundles, and the relationships between them.
+ * The BundleGraph is passed to the bundler plugin wrapped in a MutableBundleGraph,
+ * and is passed to packagers and optimizers wrapped in the public BundleGraph object, both
+ * of which implement public api for this structure. This is the internal structure.
+ */
+export default class BundleGraph {
+    /** A set of all existing concise asset ids present in the BundleGraph */
+    _assetPublicIds: Set<string>;
+    /** Maps full asset ids (currently 32-character strings) to concise ids (minimum of 5 character strings) */
+    _publicIdByAssetId: Map<string, string>;
+    /**
+     * A cache of bundle hashes by bundle id.
+     *
+     * TODO: These hashes are being invalidated in mutative methods, but this._graph is not a private
+     * property so it is possible to reach in and mutate the graph without invalidating these hashes.
+     * It needs to be exposed in BundlerRunner for now based on how applying runtimes works and the
+     * BundlerRunner takes care of invalidating hashes when runtimes are applied, but this is not ideal.
+     */
+    _bundleContentHashes: Map<string, string>;
+    _targetEntryRoots: Map<ProjectPath, FilePath>;
+    /** The internal core Graph structure */
+    _graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>;
+    _bundlePublicIds: Set<string>;
+    _conditions: Map<string, Condition>;
+    constructor({ graph, publicIdByAssetId, assetPublicIds, bundleContentHashes, conditions, }: {
+        graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>;
+        publicIdByAssetId: Map<string, string>;
+        assetPublicIds: Set<string>;
+        bundleContentHashes: Map<string, string>;
+        conditions: Map<string, Condition>;
+    });
+    /**
+     * Produce a BundleGraph from an AssetGraph by removing asset groups and retargeting dependencies
+     * based on the symbol data (resolving side-effect free reexports).
+     */
+    static fromAssetGraph(assetGraph: AssetGraph, isProduction: boolean, publicIdByAssetId?: Map<string, string>, assetPublicIds?: Set<string>): BundleGraph;
+    serialize(): SerializedBundleGraph;
+    static deserialize(serialized: BundleGraphOpts): BundleGraph;
+    /**
+     * Serialize the bundle graph for efficient transfer to native Rust code.
+     * Returns a JSON string of nodes, an array of edges, and a map of asset IDs to public IDs.
+     */
+    serializeForNative(): {
+        nodesJson: string;
+        edges: [number, number, BundleGraphEdgeType][];
+        publicIdByAssetId: Record<string, string>;
+        environmentsJson: string;
+    };
+    /**
+     * Serialize only the given asset nodes for native incremental update.
+     * Same node shape and env/omit logic as serializeForNative.
+     */
+    serializeAssetNodesForNative(assetIds: Array<string>): string;
+    /**
+     * Remove null and undefined values from an object to reduce JSON size.
+     * Preserves false, 0, empty strings, and arrays.
+     */
+    private _omitNulls;
+    createBundle(opts: {
+        readonly entryAsset: Asset;
+        readonly bundleRoots?: Array<Asset>;
+        readonly target: Target;
+        readonly needsStableName?: boolean | null | undefined;
+        readonly bundleBehavior?: IBundleBehavior | null | undefined;
+        readonly shouldContentHash: boolean;
+        readonly env: EnvironmentRef;
+    } | {
+        readonly type: string;
+        readonly env: EnvironmentRef;
+        readonly uniqueKey: string;
+        readonly target: Target;
+        readonly needsStableName?: boolean | null | undefined;
+        readonly bundleBehavior?: IBundleBehavior | null | undefined;
+        readonly isSplittable?: boolean | null | undefined;
+        readonly pipeline?: string | null | undefined;
+        readonly shouldContentHash: boolean;
+    }): Bundle;
+    addAssetToBundle(asset: Asset, bundle: Bundle): void;
+    addAssetGraphToBundle(asset: Asset, bundle: Bundle, shouldSkipDependency?: (arg1: Dependency) => boolean): void;
+    markDependencyReferenceable(dependency: Dependency): void;
+    addEntryToBundle(asset: Asset, bundle: Bundle, shouldSkipDependency?: (arg1: Dependency) => boolean): void;
+    internalizeAsyncDependency(bundle: Bundle, dependency: Dependency): void;
+    isDependencySkipped(dependency: Dependency): boolean;
+    getParentBundlesOfBundleGroup(bundleGroup: BundleGroup): Array<Bundle>;
+    resolveAsyncDependency(dependency: Dependency, bundle?: Bundle | null): {
+        type: 'bundle_group';
+        value: BundleGroup;
+    } | {
+        type: 'asset';
+        value: Asset;
+    } | null | undefined;
+    getReferencedBundle(dependency: Dependency, fromBundle: Bundle): Bundle | null | undefined;
+    removeAssetGraphFromBundle(asset: Asset, bundle: Bundle): void;
+    /**
+     * Remove a bundle from the bundle graph. Remove its bundle group if it is
+     * the only bundle in the group.
+     */
+    removeBundle(bundle: Bundle): Set<BundleGroup>;
+    removeBundleGroup(bundleGroup: BundleGroup): void;
+    _removeExternalDependency(bundle: Bundle, dependency: Dependency): void;
+    createAssetReference(dependency: Dependency, asset: Asset, bundle: Bundle): void;
+    createBundleReference(from: Bundle, to: Bundle): void;
+    createBundleConditionalReference(from: Bundle, to: Bundle): void;
+    getBundlesWithAsset(asset: Asset): Array<Bundle>;
+    getBundlesWithDependency(dependency: Dependency): Array<Bundle>;
+    getDependencyAssets(dependency: Dependency): Array<Asset>;
+    getResolvedAsset(dep: Dependency, bundle?: Bundle | null): Asset | null | undefined;
+    getDependencies(asset: Asset): Array<Dependency>;
+    traverseAssets<TContext>(bundle: Bundle, visit: GraphVisitor<Asset, TContext>, startAsset?: Asset): TContext | null | undefined;
+    isAssetReferenced(bundle: Bundle, asset: Asset): boolean;
+    isAssetReferencedFastCheck(bundle: Bundle, asset: Asset): boolean | null;
+    getReferencedAssets(bundle: Bundle): Set<Asset>;
+    hasParentBundleOfType(bundle: Bundle, type: string): boolean;
+    getParentBundles(bundle: Bundle): Array<Bundle>;
+    isAssetReachableFromBundle(asset: Asset, bundle: Bundle): boolean;
+    /**
+     * Performs a depth-first traversal of all assets and dependencies contained
+     * within a bundle. Only visits nodes that are directly contained in the bundle
+     * (connected via a `contains` edge).
+     *
+     * Entry Asset Ordering:
+     * The traversal guarantees that entry assets are visited in the exact order they
+     * appear in `bundle.entryAssetIds`. This ordering is critical for several reasons:
+     *
+     * 1. **Code Execution Order in Packagers**: Packagers (ScopeHoistingPackager,
+     *    DevPackager) use this traversal to concatenate assets into the final bundle.
+     *    The traversal order determines the execution order of code in the output.
+     *    Entry assets must be processed in their defined order to ensure correct
+     *    initialization sequences.
+     *
+     * 2. **Runtime Injection**: Runtime assets (HMR, bundle manifests) are prepended
+     *    to `entryAssetIds` via `unshift()` in `applyRuntimes.ts`. By honoring the
+     *    array order, runtimes are guaranteed to be visited (and thus output) before
+     *    application entry points, ensuring the runtime infrastructure is available
+     *    when application code executes.
+     *
+     * 3. **Deterministic Builds**: Consistent traversal order ensures reproducible
+     *    bundle output, which is essential for caching and build verification.
+     *
+     * The sorting only applies at the first traversal level (direct children of the
+     * start node). Subsequent levels follow standard DFS order based on the graph's
+     * edge structure.
+     *
+     * @param bundle - The bundle to traverse
+     * @param visit - Visitor callback receiving asset or dependency nodes
+     * @param startAsset - Optional asset to start traversal from (defaults to bundle root)
+     */
+    traverseBundle<TContext>(bundle: Bundle, visit: GraphVisitor<AssetNode | DependencyNode, TContext>, startAsset?: Asset): TContext | null | undefined;
+    traverse<TContext>(visit: GraphVisitor<AssetNode | DependencyNode, TContext>, start?: Asset): TContext | null | undefined;
+    getChildBundles(bundle: Bundle): Array<Bundle>;
+    traverseBundles<TContext>(visit: GraphVisitor<Bundle, TContext>, startBundle?: Bundle | null): TContext | null | undefined;
+    getBundles(opts?: {
+        includeInline: boolean;
+    }): Array<Bundle>;
+    getTotalSize(asset: Asset): number;
+    getReferencingBundles(bundle: Bundle): Array<Bundle>;
+    getBundleGroupsContainingBundle(bundle: Bundle): Array<BundleGroup>;
+    getDirectParentBundleGroups(bundle: Bundle): Array<BundleGroup>;
+    getBundlesInBundleGroup(bundleGroup: BundleGroup, opts?: {
+        includeInline: boolean;
+    }): Array<Bundle>;
+    getReferencedBundles(bundle: Bundle, opts?: {
+        recursive?: boolean;
+        includeInline?: boolean;
+    }): Array<Bundle>;
+    getIncomingDependencies(asset: Asset): Array<Dependency>;
+    getAssetWithDependency(dep: Dependency): Asset | null | undefined;
+    bundleHasAsset(bundle: Bundle, asset: Asset): boolean;
+    bundleHasDependency(bundle: Bundle, dependency: Dependency): boolean;
+    filteredTraverse<TValue, TContext>(bundleNodeId: NodeId, filter: (arg1: NodeId, arg2: TraversalActions) => TValue | null | undefined, visit: GraphVisitor<TValue, TContext>): TContext | null | undefined;
+    getSymbolResolution(asset: Asset, symbol: Symbol, boundary?: Bundle | null): InternalSymbolResolution;
+    getAssetById(contentKey: string): Asset;
+    getAssetPublicId(asset: Asset): string;
+    getExportedSymbols(asset: Asset, boundary?: Bundle | null): Array<InternalExportSymbolResolution>;
+    getContentHash(bundle: Bundle): string;
+    getInlineBundles(bundle: Bundle): Array<Bundle>;
+    getHash(bundle: Bundle): string;
+    getBundleGraphHash(): string;
+    addBundleToBundleGroup(bundle: Bundle, bundleGroup: BundleGroup): void;
+    getUsedSymbolsAsset(asset: Asset): ReadonlySet<Symbol> | null | undefined;
+    getUsedSymbolsDependency(dep: Dependency): ReadonlySet<Symbol> | null | undefined;
+    merge(other: BundleGraph): void;
+    isEntryBundleGroup(bundleGroup: BundleGroup): boolean;
+    /**
+     * Update the asset in a Bundle Graph and clear the associated Bundle hash.
+     */
+    updateAsset(asset: AssetNode): void;
+    getEntryRoot(projectRoot: FilePath, target: Target): FilePath;
+    getReferencedConditionalBundles(bundle: Bundle): Array<Bundle>;
+}
+export {};

package/lib/types/CommittedAsset.d.ts

@@ -0,0 +1,23 @@
+import { Readable } from 'stream';
+import type { AST, Blob } from '@atlaspack/types';
+import SourceMap from '@atlaspack/source-map';
+import type { Asset, Dependency, AtlaspackOptions } from './types';
+export default class CommittedAsset {
+    key: string | null | undefined;
+    value: Asset;
+    options: AtlaspackOptions;
+    content: Promise<Buffer | string> | null | undefined;
+    mapBuffer: Promise<Buffer | null | undefined> | null | undefined;
+    map: Promise<SourceMap | null | undefined> | null | undefined;
+    ast: Promise<AST> | null | undefined;
+    code: string | null | undefined;
+    constructor(value: Asset, options: AtlaspackOptions);
+    getContent(): Blob | Promise<Buffer | string>;
+    getCode(): Promise<string>;
+    getBuffer(): Promise<Buffer>;
+    getStream(): Readable;
+    getMapBuffer(): Promise<Buffer | null | undefined>;
+    getMap(): Promise<SourceMap | null | undefined>;
+    getAST(): Promise<AST | null | undefined>;
+    getDependencies(): Array<Dependency>;
+}