@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

package/lib/types/atlaspack-v3/NapiWorkerPool.d.ts

@@ -0,0 +1,12 @@
+import type { NapiWorkerPool as INapiWorkerPool } from '@atlaspack/types';
+import type { Transferable } from '@atlaspack/rust';
+export type NapiWorkerPoolOptions = {
+    workerCount?: number;
+};
+export declare class NapiWorkerPool implements INapiWorkerPool {
+    #private;
+    constructor({ workerCount }?: NapiWorkerPoolOptions);
+    workerCount(): number;
+    getWorkers(): Promise<Array<Transferable>>;
+    shutdown(): void;
+}

package/lib/types/atlaspack-v3/fs.d.ts

@@ -0,0 +1,12 @@
+import type { FileSystem, JsCallable } from '@atlaspack/rust';
+import type { Encoding, FilePath, FileSystem as IFileSystem } from '@atlaspack/types';
+export declare class FileSystemV3 implements FileSystem {
+    #private;
+    constructor(fs: IFileSystem);
+    canonicalize: JsCallable<[FilePath], FilePath>;
+    createDirectory: JsCallable<[FilePath], Promise<undefined>>;
+    cwd: JsCallable<[], FilePath>;
+    isFile: JsCallable<[FilePath], boolean>;
+    isDir: JsCallable<[FilePath], boolean>;
+    readFile: JsCallable<[FilePath, Encoding], string>;
+}

package/lib/types/atlaspack-v3/index.d.ts

@@ -0,0 +1,5 @@
+export { FileSystemV3 } from './fs';
+export { AtlaspackV3 } from './AtlaspackV3';
+export { NapiWorkerPool } from './NapiWorkerPool';
+export * from './AtlaspackV3';
+export * from './NapiWorkerPool';

package/lib/types/atlaspack-v3/jsCallable.d.ts

@@ -0,0 +1 @@
+export declare function jsCallable<Args extends ReadonlyArray<unknown>, Return>(fn: (...rest: Args) => Return | Promise<Return>): (...rest: Args) => Promise<Return>;

package/lib/types/atlaspack-v3/worker/compat/asset-symbols.d.ts

@@ -0,0 +1,51 @@
+import type { Symbol as NapiSymbol } from '@atlaspack/rust';
+import type { AssetSymbols as IAssetSymbols, MutableAssetSymbols as IMutableAssetSymbols, MutableDependencySymbols as IMutableDependencySymbols, Symbol, SourceLocation, Meta } from '@atlaspack/types';
+export declare class MutableDependencySymbols implements IMutableDependencySymbols {
+    #private;
+    get isCleared(): boolean;
+    constructor(inner: NapiSymbol[] | null | undefined | null);
+    ensure(): void;
+    get(exportSymbol: Symbol): DependencyAssetSymbol | null | undefined;
+    hasExportSymbol(exportSymbol: Symbol): boolean;
+    hasLocalSymbol(local: Symbol): boolean;
+    exportSymbols(): Iterable<Symbol>;
+    set(exportSymbol: Symbol, local: Symbol, loc?: SourceLocation | null, isWeak?: boolean | null): void;
+    delete(exportSymbol: Symbol): void;
+    [Symbol.iterator](): MapIterator<DependencyAssetSymbol>;
+}
+export declare class AssetSymbols implements IAssetSymbols {
+    #private;
+    get isCleared(): boolean;
+    constructor(inner: NapiSymbol[] | null | undefined | null);
+    get(exportSymbol: Symbol): AssetSymbol | null | undefined;
+    hasExportSymbol(exportSymbol: Symbol): boolean;
+    hasLocalSymbol(local: Symbol): boolean;
+    exportSymbols(): Iterable<Symbol>;
+    intoNapi(): NapiSymbol[];
+    [Symbol.iterator](): MapIterator<AssetSymbol>;
+}
+export declare class MutableAssetSymbols implements IMutableAssetSymbols {
+    #private;
+    get isCleared(): boolean;
+    constructor(inner: NapiSymbol[] | null | undefined | null);
+    intoNapi(): NapiSymbol[];
+    ensure(): void;
+    set(exportSymbol: Symbol, local: Symbol, loc?: SourceLocation | null, meta?: Meta | null): void;
+    get(exportSymbol: Symbol): AssetSymbol | null | undefined;
+    hasExportSymbol(exportSymbol: Symbol): boolean;
+    hasLocalSymbol(local: Symbol): boolean;
+    exportSymbols(): Iterable<Symbol>;
+    delete(exportSymbol: Symbol): void;
+    [Symbol.iterator](): MapIterator<AssetSymbol>;
+}
+export type AssetSymbol = {
+    local: Symbol;
+    loc: SourceLocation | null | undefined;
+    meta?: Meta | null | undefined;
+};
+export type DependencyAssetSymbol = {
+    local: Symbol;
+    loc: SourceLocation | null | undefined;
+    meta?: Meta | null | undefined;
+    isWeak: boolean;
+};

package/lib/types/atlaspack-v3/worker/compat/bitflags.d.ts

@@ -0,0 +1,15 @@
+import type { BundleBehavior, DependencyPriority, SpecifierType } from '@atlaspack/types';
+export declare class BitFlags<K, V> {
+    #private;
+    constructor(source: Partial<Record<K, V>>);
+    into(key: K): V;
+    intoNullable(key?: K | null): V | null | undefined;
+    intoArray(keys: K[]): V[];
+    from(key: V): K;
+    fromNullable(key?: V | null): K | null | undefined;
+    fromArray(keys: V[]): K[];
+}
+export declare const bundleBehaviorMap: BitFlags<BundleBehavior, number>;
+export declare const dependencyPriorityMap: BitFlags<DependencyPriority, number>;
+export declare const packageConditionsMap: BitFlags<string, number>;
+export declare const specifierTypeMap: BitFlags<SpecifierType, number>;

package/lib/types/atlaspack-v3/worker/compat/dependency.d.ts

@@ -0,0 +1,25 @@
+import type { Dependency as NapiDependency } from '@atlaspack/rust';
+import type { Dependency as IDependency, DependencySpecifier, SpecifierType, DependencyPriority, BundleBehavior, SourceLocation, Environment as IEnvironment, Meta, Target as ITarget, FilePath, SemverRange, MutableDependencySymbols as IMutableDependencySymbols } from '@atlaspack/types';
+export declare class Dependency implements IDependency {
+    env: IEnvironment;
+    meta: Meta;
+    target: ITarget | null | undefined;
+    symbols: IMutableDependencySymbols;
+    specifier: DependencySpecifier;
+    specifierType: SpecifierType;
+    priority: DependencyPriority;
+    bundleBehavior: BundleBehavior | null | undefined;
+    needsStableName: boolean;
+    isOptional: boolean;
+    isEntry: boolean;
+    loc: SourceLocation | null | undefined;
+    packageConditions: Array<string> | null | undefined;
+    sourceAssetId: string | null | undefined;
+    sourcePath: FilePath | null | undefined;
+    sourceAssetType: string | null | undefined;
+    resolveFrom: FilePath | null | undefined;
+    range: SemverRange | null | undefined;
+    pipeline: string | null | undefined;
+    get id(): string;
+    constructor(inner: NapiDependency, env: IEnvironment);
+}

package/lib/types/atlaspack-v3/worker/compat/environment.d.ts

@@ -0,0 +1,27 @@
+import type { Environment as NapiEnvironment } from '@atlaspack/rust';
+import type { Environment as IEnvironment, EnvironmentContext, Engines, PackageName, OutputFormat, SourceType, TargetSourceMapOptions, SourceLocation, VersionMap, EnvironmentFeature, EnvMap } from '@atlaspack/types';
+export declare class Environment implements IEnvironment {
+    id: string;
+    includeNodeModules: boolean | Array<PackageName> | Partial<Record<PackageName, boolean>>;
+    context: EnvironmentContext;
+    engines: Engines;
+    outputFormat: OutputFormat;
+    sourceType: SourceType;
+    isLibrary: boolean;
+    shouldOptimize: boolean;
+    shouldScopeHoist: boolean;
+    sourceMap: TargetSourceMapOptions | null | undefined;
+    loc: SourceLocation | null | undefined;
+    unstableSingleFileOutput: boolean;
+    customEnv: EnvMap | null | undefined;
+    constructor(inner: NapiEnvironment);
+    isBrowser(): boolean;
+    isNode(): boolean;
+    isElectron(): boolean;
+    isWorker(): boolean;
+    isWorklet(): boolean;
+    isTesseract(): boolean;
+    isIsolated(): boolean;
+    matchesEngines(minVersions: VersionMap, defaultValue?: boolean): boolean;
+    supports(feature: EnvironmentFeature, defaultValue?: boolean): boolean;
+}

package/{src/atlaspack-v3/worker/compat/index.js → lib/types/atlaspack-v3/worker/compat/index.d.ts}

@@ -1,4 +1,3 @@
-// @flow
 export * from './bitflags';
 export * from './dependency';
 export * from './environment';

package/lib/types/atlaspack-v3/worker/compat/mutable-asset.d.ts

@@ -0,0 +1,49 @@
+import SourceMap from '@parcel/source-map';
+import * as napi from '@atlaspack/rust';
+import { Readable } from 'stream';
+import type { MutableAsset as IMutableAsset, Stats, FileSystem, FilePath, Environment, Meta, BundleBehavior, ASTGenerator, AST, Dependency, DependencyOptions, FileCreateInvalidation, EnvironmentOptions } from '@atlaspack/types';
+import { MutableAssetSymbols } from './asset-symbols';
+export type InnerAsset = napi.Asset;
+export declare class MutableAsset implements IMutableAsset {
+    #private;
+    bundleBehavior: BundleBehavior | null | undefined;
+    env: Environment;
+    filePath: FilePath;
+    fs: FileSystem;
+    id: string;
+    isBundleSplittable: boolean;
+    isMapDirty: boolean;
+    isSource: boolean;
+    meta: Meta;
+    pipeline: string | null | undefined;
+    query: URLSearchParams;
+    sideEffects: boolean;
+    stats: Stats;
+    symbols: MutableAssetSymbols;
+    type: string;
+    uniqueKey: string | null | undefined;
+    get astGenerator(): ASTGenerator | null | undefined;
+    set astGenerator(value?: ASTGenerator | null);
+    constructor(asset: InnerAsset, contents: Buffer, env: Environment, fs: FileSystem, map: string | null | undefined, projectRoot: string);
+    getAST(): Promise<AST | null | undefined>;
+    setAST(ast: AST): void;
+    isASTDirty(): boolean;
+    getCode(): Promise<string>;
+    setCode(code: string): void;
+    getBuffer(): Promise<Buffer>;
+    setBuffer(buf: Buffer): void;
+    getStream(): Readable;
+    setStream(stream: Readable): void;
+    getMap(): Promise<SourceMap | null | undefined>;
+    setMap(sourceMap?: SourceMap | null): void;
+    getMapBuffer(): Promise<Buffer | null | undefined>;
+    getDependencies(): ReadonlyArray<Dependency>;
+    addDependency(options: DependencyOptions): string;
+    addURLDependency(url: string, opts: Partial<DependencyOptions>): string;
+    setEnvironment(opts: EnvironmentOptions): void;
+    invalidateOnFileChange(invalidation: FilePath): void;
+    invalidateOnFileCreate(invalidation: FileCreateInvalidation): void;
+    invalidateOnEnvChange(invalidation: string): void;
+    invalidateOnStartup(): void;
+    invalidateOnBuild(): void;
+}

package/lib/types/atlaspack-v3/worker/compat/plugin-config.d.ts

@@ -0,0 +1,37 @@
+import type { Config as IPluginConfig, DevDepOptions, FilePath, Environment, FileCreateInvalidation, ConfigResultWithFilePath, PackageJSON, PackageManager as IPackageManager } from '@atlaspack/types';
+import type { FileSystem as IFileSystem } from '@atlaspack/fs';
+export type PluginConfigOptions = {
+    isSource: boolean;
+    searchPath: FilePath;
+    projectRoot: FilePath;
+    env: Environment;
+    fs: IFileSystem;
+    packageManager: IPackageManager;
+};
+export declare class PluginConfig implements IPluginConfig {
+    #private;
+    isSource: boolean;
+    searchPath: FilePath;
+    env: Environment;
+    constructor({ env, isSource, searchPath, projectRoot, fs, packageManager, }: PluginConfigOptions);
+    invalidateOnFileChange(filePath: FilePath): void;
+    invalidateOnFileCreate(invalidations: FileCreateInvalidation): void;
+    invalidateOnEnvChange(invalidation: string): void;
+    invalidateOnStartup(): void;
+    invalidateOnBuild(): void;
+    addDevDependency(options: DevDepOptions): void;
+    setCacheKey(key: string): void;
+    getConfig<T>(filePaths: Array<FilePath>, options?: {
+        packageKey?: string;
+        parse?: boolean;
+        exclude?: boolean;
+    }): Promise<ConfigResultWithFilePath<T> | null | undefined>;
+    getConfigFrom<T>(searchPath: FilePath, filePaths: Array<FilePath>, options?: {
+        packageKey?: string;
+        parse?: boolean;
+        exclude?: boolean;
+    } | {
+        readTracking?: boolean;
+    }): Promise<ConfigResultWithFilePath<T> | null | undefined>;
+    getPackage(): Promise<PackageJSON | null | undefined>;
+}

package/lib/types/atlaspack-v3/worker/compat/plugin-logger.d.ts

@@ -0,0 +1,9 @@
+import type { PluginLogger as IPlguinLogger } from '@atlaspack/types';
+import type { Diagnostifiable, DiagnosticWithoutOrigin } from '@atlaspack/diagnostic';
+export declare class PluginLogger implements IPlguinLogger {
+    verbose(diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>): void;
+    info(diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>): void;
+    log(diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>): void;
+    warn(diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>): void;
+    error(input: Diagnostifiable | DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>): void;
+}

package/lib/types/atlaspack-v3/worker/compat/plugin-options.d.ts

@@ -0,0 +1,22 @@
+import type { PluginOptions as IPluginOptions, LogLevel, FileSystem, PackageManager, EnvMap, FilePath, HMROptions, ServerOptions, DetailedReportOptions, BuildMode } from '@atlaspack/types';
+import type { FeatureFlags } from '@atlaspack/feature-flags';
+export declare class PluginOptions implements IPluginOptions {
+    #private;
+    get env(): EnvMap;
+    get projectRoot(): FilePath;
+    get packageManager(): PackageManager;
+    get mode(): BuildMode;
+    get parcelVersion(): string;
+    get hmrOptions(): HMROptions | null | undefined;
+    get serveOptions(): ServerOptions | false;
+    get shouldBuildLazily(): boolean;
+    get shouldAutoInstall(): boolean;
+    get logLevel(): LogLevel;
+    get cacheDir(): string;
+    get inputFS(): FileSystem;
+    get outputFS(): FileSystem;
+    get instanceId(): string;
+    get detailedReport(): DetailedReportOptions | null | undefined;
+    get featureFlags(): FeatureFlags;
+    constructor(options: Partial<IPluginOptions>);
+}

package/lib/types/atlaspack-v3/worker/compat/plugin-tracer.d.ts

@@ -0,0 +1,5 @@
+import type { PluginTracer as IPluginTracer } from '@atlaspack/types';
+export declare class PluginTracer implements IPluginTracer {
+    enabled: false;
+    createMeasurement(): void;
+}

package/lib/types/atlaspack-v3/worker/compat/target.d.ts

@@ -0,0 +1,11 @@
+import type { Target as NapiTarget } from '@atlaspack/rust';
+import type { Target as ITarget, FilePath, Environment, SourceLocation } from '@atlaspack/types';
+export declare class Target implements ITarget {
+    distEntry: FilePath | null | undefined;
+    distDir: FilePath;
+    env: Environment;
+    name: string;
+    publicUrl: string;
+    loc: SourceLocation | null | undefined;
+    constructor(inner: NapiTarget, env: Environment);
+}

package/lib/types/atlaspack-v3/worker/worker.d.ts

@@ -0,0 +1,60 @@
+import * as napi from '@atlaspack/rust';
+import type { JsCallable } from '@atlaspack/rust';
+import type { FilePath } from '@atlaspack/types';
+import { FeatureFlags } from '@atlaspack/feature-flags';
+export declare class AtlaspackWorker {
+    #private;
+    constructor();
+    loadPlugin: JsCallable<[LoadPluginOptions], Promise<undefined>>;
+    runResolverResolve: JsCallable<[
+        RunResolverResolveOptions
+    ], Promise<RunResolverResolveResult>>;
+    runTransformerTransform: JsCallable<[
+        RunTransformerTransformOptions,
+        Buffer,
+        string | null | undefined
+    ], Promise<RunTransformerTransformResult>>;
+}
+type LoadPluginOptions = {
+    kind: 'resolver' | 'transformer';
+    specifier: string;
+    resolveFrom: string;
+    featureFlags?: FeatureFlags;
+};
+type RpcPluginOptions = {
+    projectRoot: string;
+    mode: string;
+};
+type RunResolverResolveOptions = {
+    key: string;
+    dependency: napi.Dependency;
+    specifier: FilePath;
+    pipeline: string | null | undefined;
+    pluginOptions: RpcPluginOptions;
+};
+type RunResolverResolveResult = {
+    invalidations: Array<any>;
+    resolution: {
+        type: 'unresolved';
+    } | {
+        type: 'excluded';
+    } | {
+        type: 'resolved';
+        canDefer: boolean;
+        filePath: string;
+        sideEffects: boolean;
+        code?: string;
+        meta?: unknown;
+        pipeline?: string;
+        priority?: number | null | undefined;
+        query?: string;
+    };
+};
+type RunTransformerTransformOptions = {
+    key: string;
+    env: napi.Environment;
+    options: RpcPluginOptions;
+    asset: napi.Asset;
+};
+type RunTransformerTransformResult = [napi.RpcAssetResult, Buffer, string];
+export {};

package/lib/types/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const ATLASPACK_VERSION: string;
+export declare const HASH_REF_PREFIX = "HASH_REF_";
+export declare const HASH_REF_HASH_LEN = 16;
+export declare const HASH_REF_REGEX: RegExp;
+export declare const VALID = 0;
+export declare const INITIAL_BUILD: number;
+export declare const FILE_CREATE: number;
+export declare const FILE_UPDATE: number;
+export declare const FILE_DELETE: number;
+export declare const ENV_CHANGE: number;
+export declare const OPTION_CHANGE: number;
+export declare const STARTUP: number;
+export declare const ERROR: number;

package/lib/types/dumpGraphToGraphViz.d.ts

@@ -0,0 +1,10 @@
+import type { Asset, BundleBehavior } from '@atlaspack/types';
+import type { Graph } from '@atlaspack/graph';
+import type { AssetGraphNode, BundleGraphNode } from './types';
+import { bundleGraphEdgeTypes } from './BundleGraph';
+import { requestGraphEdgeTypes } from './RequestTracker';
+export default function dumpGraphToGraphViz(graph: Graph<AssetGraphNode> | Graph<{
+    assets: Set<Asset>;
+    sourceBundles: Set<number>;
+    bundleBehavior?: BundleBehavior | null | undefined;
+}> | Graph<BundleGraphNode>, name: string, edgeTypes?: typeof bundleGraphEdgeTypes | typeof requestGraphEdgeTypes): Promise<void>;

package/lib/types/index.d.ts

@@ -0,0 +1,8 @@
+import * as EnvironmentManager from './EnvironmentManager';
+export { default, default as Atlaspack, default as Parcel, BuildError, createWorkerFarm, INTERNAL_RESOLVE, INTERNAL_TRANSFORM, WORKER_PATH, } from './Atlaspack';
+export { ATLASPACK_VERSION } from './constants';
+export { default as resolveOptions } from './resolveOptions';
+export { createEnvironment } from './Environment';
+export { default as Environment } from './public/Environment';
+export * from './atlaspack-v3';
+export { EnvironmentManager };

package/lib/types/loadAtlaspackPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { FilePath, PackageName, Semver } from '@atlaspack/types';
+import type { AtlaspackOptions } from './types';
+import { ProjectPath } from './projectPath';
+export default function loadPlugin<T>(pluginName: PackageName, configPath: FilePath, keyPath: string | null | undefined, options: AtlaspackOptions): Promise<{
+    plugin: T;
+    version: Semver;
+    resolveFrom: ProjectPath;
+}>;

package/lib/types/loadDotEnv.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystem } from '@atlaspack/fs';
+import type { EnvMap, FilePath } from '@atlaspack/types';
+export default function loadEnv(env: EnvMap, fs: FileSystem, filePath: FilePath, projectRoot: FilePath): Promise<EnvMap>;

package/lib/types/projectPath.d.ts

@@ -0,0 +1,19 @@
+import type { FilePath } from '@atlaspack/types';
+/**
+ * A path that's relative to the project root.
+ */
+export type ProjectPath = string;
+export declare const toProjectPath: ((projectRoot: FilePath, p: FilePath) => ProjectPath) & ((projectRoot: FilePath, p: FilePath | undefined) => ProjectPath | undefined) & ((projectRoot: FilePath, p?: FilePath | null | undefined) => ProjectPath | null | undefined);
+export declare const fromProjectPath: ((projectRoot: FilePath, p: ProjectPath) => FilePath) & ((projectRoot: FilePath, p?: ProjectPath | null | undefined) => FilePath | null | undefined);
+/**
+ * Returns a path relative to the project root. This should be used when computing cache keys
+ */
+export declare function fromProjectPathRelative(p: ProjectPath): FilePath;
+/**
+ * This function should be avoided, it doesn't change the actual value.
+ */
+export declare function toProjectPathUnsafe(p: FilePath): ProjectPath;
+/**
+ * Joins a project root with relative paths (similar to `path.join`)
+ */
+export declare function joinProjectPath(a: ProjectPath, ...b: Array<FilePath>): ProjectPath;

package/lib/types/public/Asset.d.ts

@@ -0,0 +1,74 @@
+import type SourceMap from '@parcel/source-map';
+import type { Readable } from 'stream';
+import type { FileSystem } from '@atlaspack/fs';
+import type { Asset as IAsset, AST, ASTGenerator, Dependency as IDependency, DependencyOptions, Environment as IEnvironment, EnvironmentOptions, FileCreateInvalidation, FilePath, Meta, MutableAsset as IMutableAsset, Stats, MutableAssetSymbols as IMutableAssetSymbols, AssetSymbols as IAssetSymbols, BundleBehavior } from '@atlaspack/types';
+import type { Asset as AssetValue, AtlaspackOptions } from '../types';
+import UncommittedAsset from '../UncommittedAsset';
+import CommittedAsset from '../CommittedAsset';
+declare const inspect: unique symbol;
+export declare function assetToAssetValue(asset: IAsset | IMutableAsset): AssetValue;
+export declare function mutableAssetToUncommittedAsset(mutableAsset: IMutableAsset): UncommittedAsset;
+export declare function assetFromValue(value: AssetValue, options: AtlaspackOptions): Asset;
+declare class BaseAsset {
+    #private;
+    constructor(asset: CommittedAsset | UncommittedAsset);
+    [inspect](): string;
+    get id(): string;
+    get type(): string;
+    get env(): IEnvironment;
+    get fs(): FileSystem;
+    get filePath(): FilePath;
+    get query(): URLSearchParams;
+    get meta(): Meta;
+    get bundleBehavior(): BundleBehavior | null | undefined;
+    get isBundleSplittable(): boolean;
+    get isSource(): boolean;
+    get sideEffects(): boolean;
+    get symbols(): IAssetSymbols;
+    get uniqueKey(): string | null | undefined;
+    get astGenerator(): ASTGenerator | null | undefined;
+    get pipeline(): string | null | undefined;
+    getDependencies(): ReadonlyArray<IDependency>;
+    getCode(): Promise<string>;
+    getBuffer(): Promise<Buffer>;
+    getStream(): Readable;
+    getMap(): Promise<SourceMap | null | undefined>;
+    getAST(): Promise<AST | null | undefined>;
+    getMapBuffer(): Promise<Buffer | null | undefined>;
+}
+export declare class Asset extends BaseAsset implements IAsset {
+    #private;
+    constructor(asset: CommittedAsset | UncommittedAsset);
+    get env(): IEnvironment;
+    get stats(): Stats;
+}
+export declare class MutableAsset extends BaseAsset implements IMutableAsset {
+    #private;
+    constructor(asset: UncommittedAsset);
+    setMap(map?: SourceMap | null): void;
+    get type(): string;
+    set type(type: string): void;
+    get bundleBehavior(): BundleBehavior | null | undefined;
+    set bundleBehavior(bundleBehavior?: BundleBehavior | null): void;
+    get isBundleSplittable(): boolean;
+    set isBundleSplittable(isBundleSplittable: boolean): void;
+    get sideEffects(): boolean;
+    set sideEffects(sideEffects: boolean): void;
+    get uniqueKey(): string | null | undefined;
+    set uniqueKey(uniqueKey?: string | null): void;
+    get symbols(): IMutableAssetSymbols;
+    addDependency(dep: DependencyOptions): string;
+    invalidateOnFileChange(filePath: FilePath): void;
+    invalidateOnFileCreate(invalidation: FileCreateInvalidation): void;
+    invalidateOnEnvChange(env: string): void;
+    invalidateOnStartup(): void;
+    invalidateOnBuild(): void;
+    isASTDirty(): boolean;
+    setBuffer(buffer: Buffer): void;
+    setCode(code: string): void;
+    setStream(stream: Readable): void;
+    setAST(ast: AST): void;
+    addURLDependency(url: string, opts: Partial<DependencyOptions>): string;
+    setEnvironment(env: EnvironmentOptions): void;
+}
+export {};

package/lib/types/public/Bundle.d.ts

@@ -0,0 +1,45 @@
+import type { Bundle as InternalBundle, AtlaspackOptions, PackagedBundleInfo } from '../types';
+import type { Asset as IAsset, Bundle as IBundle, BundleTraversable, Dependency as IDependency, Environment as IEnvironment, GraphVisitor, NamedBundle as INamedBundle, PackagedBundle as IPackagedBundle, Stats, Target as ITarget, BundleBehavior } from '@atlaspack/types';
+import type BundleGraph from '../BundleGraph';
+declare const inspect: unique symbol;
+export declare function bundleToInternalBundle(bundle: IBundle): InternalBundle;
+export declare function bundleToInternalBundleGraph(bundle: IBundle): BundleGraph;
+export declare class Bundle implements IBundle {
+    #private;
+    [inspect](): string;
+    constructor(sentinel: unknown, bundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions);
+    static get(internalBundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions): Bundle;
+    get id(): string;
+    get hashReference(): string;
+    get type(): string;
+    get env(): IEnvironment;
+    get needsStableName(): boolean | null | undefined;
+    get bundleBehavior(): BundleBehavior | null | undefined;
+    get isSplittable(): boolean | null | undefined;
+    get manualSharedBundle(): string | null | undefined;
+    get target(): ITarget;
+    hasAsset(asset: IAsset): boolean;
+    hasDependency(dep: IDependency): boolean;
+    getEntryAssets(): Array<IAsset>;
+    getMainEntry(): IAsset | null | undefined;
+    traverse<TContext>(visit: GraphVisitor<BundleTraversable, TContext>): TContext | null | undefined;
+    traverseAssets<TContext>(visit: GraphVisitor<IAsset, TContext>, startAsset?: IAsset): TContext | null | undefined;
+}
+export declare class NamedBundle extends Bundle implements INamedBundle {
+    #private;
+    constructor(sentinel: unknown, bundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions);
+    static get(internalBundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions): NamedBundle;
+    get name(): string;
+    get displayName(): string;
+    get publicId(): string;
+}
+export declare class PackagedBundle extends NamedBundle implements IPackagedBundle {
+    #private;
+    constructor(sentinel: unknown, bundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions);
+    static get(internalBundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions): PackagedBundle;
+    static getWithInfo(internalBundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions, bundleInfo?: PackagedBundleInfo | null): PackagedBundle;
+    get filePath(): string;
+    get type(): string;
+    get stats(): Stats;
+}
+export {};

package/lib/types/public/BundleGraph.d.ts

@@ -0,0 +1,70 @@
+import type { Asset as IAsset, Bundle as IBundle, BundleGraph as IBundleGraph, BundleGraphTraversable, BundleGroup as IBundleGroup, Dependency as IDependency, ExportSymbolResolution, FilePath, GraphVisitor, NamedBundle, SymbolResolution, Symbol, Target } from '@atlaspack/types';
+import type { Bundle as InternalBundle, AtlaspackOptions } from '../types';
+import type InternalBundleGraph from '../BundleGraph';
+import { Asset } from './Asset';
+export declare function bundleGraphToInternalBundleGraph(bundleGraph: IBundleGraph<IBundle>): InternalBundleGraph;
+type BundleFactory<TBundle extends IBundle> = (arg1: InternalBundle, arg2: InternalBundleGraph, arg3: AtlaspackOptions) => TBundle;
+export default class BundleGraph<TBundle extends IBundle> implements IBundleGraph<TBundle> {
+    #private;
+    constructor(graph: InternalBundleGraph, createBundle: BundleFactory<TBundle>, options: AtlaspackOptions);
+    getAssetById(id: string): Asset;
+    getAssetPublicId(asset: IAsset): string;
+    isDependencySkipped(dep: IDependency): boolean;
+    getResolvedAsset(dep: IDependency, bundle?: IBundle | null): IAsset | null | undefined;
+    getIncomingDependencies(asset: IAsset): Array<IDependency>;
+    getAssetWithDependency(dep: IDependency): IAsset | null | undefined;
+    getBundleGroupsContainingBundle(bundle: IBundle): Array<IBundleGroup>;
+    getReferencedBundles(bundle: IBundle, opts?: {
+        recursive?: boolean;
+        includeInline?: boolean;
+    }): Array<TBundle>;
+    getReferencingBundles(bundle: IBundle): Array<TBundle>;
+    resolveAsyncDependency(dependency: IDependency, bundle?: IBundle | null): {
+        type: 'bundle_group';
+        value: IBundleGroup;
+    } | {
+        type: 'asset';
+        value: IAsset;
+    } | null | undefined;
+    getReferencedBundle(dependency: IDependency, bundle: IBundle): TBundle | null | undefined;
+    getDependencies(asset: IAsset): Array<IDependency>;
+    isAssetReachableFromBundle(asset: IAsset, bundle: IBundle): boolean;
+    isAssetReferenced(bundle: IBundle, asset: IAsset): boolean;
+    hasParentBundleOfType(bundle: IBundle, type: string): boolean;
+    getBundlesInBundleGroup(bundleGroup: IBundleGroup, opts?: {
+        includeInline: boolean;
+    }): Array<TBundle>;
+    getBundles(opts?: {
+        includeInline: boolean;
+    }): Array<TBundle>;
+    isEntryBundleGroup(bundleGroup: IBundleGroup): boolean;
+    getChildBundles(bundle: IBundle): Array<TBundle>;
+    getParentBundles(bundle: IBundle): Array<TBundle>;
+    getSymbolResolution(asset: IAsset, symbol: Symbol, boundary?: IBundle | null): SymbolResolution;
+    getExportedSymbols(asset: IAsset, boundary?: IBundle | null): Array<ExportSymbolResolution>;
+    traverse<TContext>(visit: GraphVisitor<BundleGraphTraversable, TContext>, start?: IAsset | null, opts?: {
+        skipUnusedDependencies?: boolean;
+    } | null): TContext | null | undefined;
+    traverseBundles<TContext>(visit: GraphVisitor<TBundle, TContext>, startBundle?: IBundle | null): TContext | null | undefined;
+    getBundlesWithAsset(asset: IAsset): Array<TBundle>;
+    getBundlesWithDependency(dependency: IDependency): Array<TBundle>;
+    getUsedSymbols(v: IAsset | IDependency): ReadonlySet<Symbol> | null | undefined;
+    getEntryRoot(target: Target): FilePath;
+    getConditionsForDependencies(deps: Array<IDependency>, bundle: NamedBundle): Set<{
+        publicId: string;
+        key: string;
+        ifTrueDependency: IDependency;
+        ifFalseDependency: IDependency;
+        ifTrueBundles: Array<TBundle>;
+        ifFalseBundles: Array<TBundle>;
+        ifTrueAssetId: string;
+        ifFalseAssetId: string;
+    }>;
+    getConditionalBundleMapping(): Map<string, Map<string, {
+        bundle: TBundle;
+        ifTrueBundles: Array<TBundle>;
+        ifFalseBundles: Array<TBundle>;
+    }>>;
+    getReferencedConditionalBundles(bundle: IBundle): Array<TBundle>;
+}
+export {};

package/lib/types/public/BundleGroup.d.ts

@@ -0,0 +1,12 @@
+import type { BundleGroup as IBundleGroup, Target as ITarget } from '@atlaspack/types';
+import type { BundleGroup as InternalBundleGroup, AtlaspackOptions } from '../types';
+export declare function bundleGroupToInternalBundleGroup(target: IBundleGroup): InternalBundleGroup;
+declare const inspect: unique symbol;
+export default class BundleGroup implements IBundleGroup {
+    #private;
+    constructor(bundleGroup: InternalBundleGroup, options: AtlaspackOptions);
+    get target(): ITarget;
+    get entryAssetId(): string;
+    [inspect](): string;
+}
+export {};