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

package/lib/types/requests/AssetGraphRequest.d.ts

@@ -0,0 +1,76 @@
+import type { NodeId } from '@atlaspack/graph';
+import type { Async } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { Asset, AssetGroup, Dependency, Entry, AtlaspackOptions } from '../types';
+import type { StaticRunOpts, RunAPI } from '../RequestTracker';
+import type { Diagnostic } from '@atlaspack/diagnostic';
+import { PromiseQueue } from '@atlaspack/utils';
+import AssetGraph from '../AssetGraph';
+import { ProjectPath } from '../projectPath';
+import { requestTypes } from '../RequestTracker';
+export type AssetGraphRequestInput = {
+    entries?: Array<ProjectPath>;
+    assetGroups?: Array<AssetGroup>;
+    optionsRef: SharedReference;
+    name: string;
+    shouldBuildLazily?: boolean;
+    lazyIncludes?: RegExp[];
+    lazyExcludes?: RegExp[];
+    requestedAssetIds?: Set<string>;
+    skipSymbolProp?: boolean;
+};
+export type AssetGraphRequestResult = {
+    assetGraph: AssetGraph;
+    /** Assets added/modified since the last successful build. */
+    changedAssets: Map<string, Asset>;
+    /** Assets added/modified since the last symbol propagation invocation. */
+    changedAssetsPropagation: Set<string>;
+    assetGroupsWithRemovedParents: Set<NodeId> | null | undefined;
+    previousSymbolPropagationErrors: Map<NodeId, Array<Diagnostic>> | null | undefined;
+    assetRequests: Array<AssetGroup>;
+};
+type RunInput = {
+    input: AssetGraphRequestInput;
+} & StaticRunOpts<AssetGraphRequestResult>;
+type AssetGraphRequest = {
+    id: string;
+    readonly type: typeof requestTypes.asset_graph_request;
+    run: (arg1: RunInput) => Async<AssetGraphRequestResult>;
+    input: AssetGraphRequestInput;
+};
+export default function createAssetGraphRequest(requestInput: AssetGraphRequestInput): AssetGraphRequest;
+export declare class AssetGraphBuilder {
+    assetGraph: AssetGraph;
+    assetRequests: Array<AssetGroup>;
+    queue: PromiseQueue<unknown>;
+    changedAssets: Map<string, Asset>;
+    changedAssetsPropagation: Set<string>;
+    prevChangedAssetsPropagation: Set<string> | null | undefined;
+    optionsRef: SharedReference;
+    options: AtlaspackOptions;
+    api: RunAPI<AssetGraphRequestResult>;
+    name: string;
+    cacheKey: string;
+    shouldBuildLazily: boolean;
+    lazyIncludes: RegExp[];
+    lazyExcludes: RegExp[];
+    requestedAssetIds: Set<string>;
+    isSingleChangeRebuild: boolean;
+    assetGroupsWithRemovedParents: Set<NodeId>;
+    previousSymbolPropagationErrors: Map<NodeId, Array<Diagnostic>>;
+    skipSymbolProp: boolean;
+    constructor({ input, api, options }: RunInput, prevResult?: AssetGraphRequestResult | null);
+    build(): Promise<AssetGraphRequestResult>;
+    shouldVisitChild(nodeId: NodeId, childNodeId: NodeId): boolean;
+    shouldSkipRequest(nodeId: NodeId): boolean;
+    queueCorrespondingRequest(nodeId: NodeId, errors: Array<Error>): Promise<null>;
+    runEntryRequest(input: ProjectPath): Promise<void>;
+    runTargetRequest(input: Entry): Promise<void>;
+    runPathRequest(input: Dependency): Promise<void>;
+    runAssetRequest(input: AssetGroup): Promise<void>;
+    /**
+     * Used for incremental bundling of modified assets
+     */
+    _areDependenciesEqualForAssets(asset: Asset, otherAsset: Asset): boolean;
+}
+export {};

package/lib/types/requests/AssetGraphRequestRust.d.ts

@@ -0,0 +1,21 @@
+import type { Async } from '@atlaspack/types';
+import AssetGraph from '../AssetGraph';
+import type { AtlaspackV3 } from '../atlaspack-v3';
+import { requestTypes, StaticRunOpts } from '../RequestTracker';
+import type { Asset } from '../types';
+import type { AssetGraphRequestInput, AssetGraphRequestResult } from './AssetGraphRequest';
+type RunInput = {
+    input: AssetGraphRequestInput;
+} & StaticRunOpts<AssetGraphRequestResult>;
+type AssetGraphRequest = {
+    id: string;
+    readonly type: typeof requestTypes.asset_graph_request;
+    run: (arg1: RunInput) => Async<AssetGraphRequestResult>;
+    input: AssetGraphRequestInput;
+};
+export declare function createAssetGraphRequestRust(rustAtlaspack: AtlaspackV3): (input: AssetGraphRequestInput) => AssetGraphRequest;
+export declare function getAssetGraph(serializedGraph: any, prevAssetGraph?: AssetGraph): {
+    assetGraph: AssetGraph;
+    changedAssets: Map<string, Asset>;
+};
+export {};

package/lib/types/requests/AssetRequest.d.ts

@@ -0,0 +1,16 @@
+import type { ContentKey } from '@atlaspack/graph';
+import type { Async } from '@atlaspack/types';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { AssetRequestInput, AssetRequestResult } from '../types';
+import { requestTypes } from '../RequestTracker';
+type RunInput<TResult> = {
+    input: AssetRequestInput;
+} & StaticRunOpts<TResult>;
+export type AssetRequest = {
+    id: ContentKey;
+    readonly type: typeof requestTypes.asset_request;
+    run: (arg1: RunInput<AssetRequestResult>) => Async<AssetRequestResult>;
+    input: AssetRequestInput;
+};
+export default function createAssetRequest(input: AssetRequestInput): AssetRequest;
+export {};

package/lib/types/requests/AtlaspackBuildRequest.d.ts

@@ -0,0 +1,33 @@
+import type { ContentKey } from '@atlaspack/graph';
+import type { Async } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { Asset, AssetGroup, PackagedBundleInfo } from '../types';
+import type BundleGraph from '../BundleGraph';
+import { requestTypes } from '../RequestTracker';
+type AtlaspackBuildRequestInput = {
+    optionsRef: SharedReference;
+    requestedAssetIds: Set<string>;
+    signal?: AbortSignal;
+};
+export type AtlaspackBuildRequestResult = {
+    bundleGraph: BundleGraph;
+    bundleInfo: Map<string, PackagedBundleInfo>;
+    changedAssets: Map<string, Asset>;
+    assetRequests: Array<AssetGroup>;
+    scopeHoistingStats?: {
+        totalAssets: number;
+        wrappedAssets: number;
+    };
+};
+type RunInput<TResult> = {
+    input: AtlaspackBuildRequestInput;
+} & StaticRunOpts<TResult>;
+export type AtlaspackBuildRequest = {
+    id: ContentKey;
+    readonly type: typeof requestTypes.atlaspack_build_request;
+    run: (arg1: RunInput<AtlaspackBuildRequestResult>) => Async<AtlaspackBuildRequestResult>;
+    input: AtlaspackBuildRequestInput;
+};
+export default function createAtlaspackBuildRequest(input: AtlaspackBuildRequestInput): AtlaspackBuildRequest;
+export {};

package/lib/types/requests/AtlaspackConfigRequest.d.ts

@@ -0,0 +1,45 @@
+import type { Async, FilePath, RawAtlaspackConfig, ResolvedAtlaspackConfigFile } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { ExtendableAtlaspackConfigPipeline, AtlaspackOptions, ProcessedAtlaspackConfig } from '../types';
+import { AtlaspackConfig } from '../AtlaspackConfig';
+import { requestTypes } from '../RequestTracker';
+type ConfigMap<K, V> = Partial<Record<K, V>>;
+export type ConfigAndCachePath = {
+    config: ProcessedAtlaspackConfig;
+    cachePath: string;
+};
+type RunOpts<TResult> = {
+    input: null;
+} & StaticRunOpts<TResult>;
+export type AtlaspackConfigRequest = {
+    id: string;
+    type: typeof requestTypes.atlaspack_config_request;
+    input: null;
+    run: (arg1: RunOpts<AtlaspackConfigRequestResult>) => Async<AtlaspackConfigRequestResult>;
+};
+export type AtlaspackConfigRequestResult = ConfigAndCachePath;
+type AtlaspackConfigChain = {
+    config: ProcessedAtlaspackConfig;
+    extendedFiles: Array<FilePath>;
+};
+export default function createAtlaspackConfigRequest(): AtlaspackConfigRequest;
+export declare function getCachedAtlaspackConfig(result: ConfigAndCachePath, options: AtlaspackOptions): AtlaspackConfig;
+export declare function loadAtlaspackConfig(options: AtlaspackOptions): Promise<AtlaspackConfigChain & {
+    usedDefault: boolean;
+}>;
+export declare function resolveAtlaspackConfig(options: AtlaspackOptions): Promise<(AtlaspackConfigChain & {
+    usedDefault: boolean;
+}) | null | undefined>;
+export declare function create(config: ResolvedAtlaspackConfigFile, options: AtlaspackOptions): Promise<AtlaspackConfigChain>;
+export declare function parseAndProcessConfig(configPath: FilePath, contents: string, options: AtlaspackOptions): Promise<AtlaspackConfigChain>;
+export declare function processConfig(configFile: ResolvedAtlaspackConfigFile, options: AtlaspackOptions): Promise<ProcessedAtlaspackConfig>;
+export declare function processConfigChain(configFile: RawAtlaspackConfig | ResolvedAtlaspackConfigFile, filePath: FilePath, options: AtlaspackOptions): Promise<AtlaspackConfigChain>;
+export declare function resolveExtends(ext: string, configPath: FilePath, extendsKey: string, options: AtlaspackOptions): Promise<FilePath>;
+export declare function validateConfigFile(config: RawAtlaspackConfig | ResolvedAtlaspackConfigFile, relativePath: FilePath): void;
+export declare function validateNotEmpty(config: RawAtlaspackConfig | ResolvedAtlaspackConfigFile, relativePath: FilePath): void;
+export declare function mergeConfigs(base: ProcessedAtlaspackConfig, ext: ProcessedAtlaspackConfig): ProcessedAtlaspackConfig;
+export declare function getResolveFrom(fs: FileSystem, projectRoot: FilePath): FilePath;
+export declare function mergePipelines(base?: ExtendableAtlaspackConfigPipeline | null, ext?: ExtendableAtlaspackConfigPipeline | null): ExtendableAtlaspackConfigPipeline;
+export declare function mergeMaps<K extends string, V>(base?: ConfigMap<K, V> | null, ext?: ConfigMap<K, V> | null, merger?: (a: V, b: V) => V): ConfigMap<K, V>;
+export {};

package/lib/types/requests/BundleGraphRequest.d.ts

@@ -0,0 +1,28 @@
+import type { Async } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { Asset, AssetGroup } from '../types';
+import InternalBundleGraph from '../BundleGraph';
+import { requestTypes } from '../RequestTracker';
+type BundleGraphRequestInput = {
+    requestedAssetIds: Set<string>;
+    signal?: AbortSignal;
+    optionsRef: SharedReference;
+};
+type RunInput = {
+    input: BundleGraphRequestInput;
+} & StaticRunOpts<BundleGraphResult>;
+export type BundleGraphResult = {
+    bundleGraph: InternalBundleGraph;
+    changedAssets: Map<string, Asset>;
+    assetRequests: Array<AssetGroup>;
+    didIncrementallyBundle: boolean;
+};
+type BundleGraphRequest = {
+    id: string;
+    readonly type: typeof requestTypes.bundle_graph_request;
+    run: (arg1: RunInput) => Async<BundleGraphResult>;
+    input: BundleGraphRequestInput;
+};
+export default function createBundleGraphRequest(input: BundleGraphRequestInput): BundleGraphRequest;
+export {};

package/lib/types/requests/BundleGraphRequestRust.d.ts

@@ -0,0 +1,34 @@
+import type { Async } from '@atlaspack/types';
+import InternalBundleGraph from '../BundleGraph';
+import { requestTypes, StaticRunOpts } from '../RequestTracker';
+import type { BundleGraphResult } from './BundleGraphRequest';
+import type { Asset } from '../types';
+type BundleGraphRequestInput = {
+    requestedAssetIds: Set<string>;
+    signal?: AbortSignal;
+    optionsRef: any;
+};
+type RunInput = {
+    input: BundleGraphRequestInput;
+} & StaticRunOpts<BundleGraphResult>;
+type BundleGraphRequestRust = {
+    id: string;
+    readonly type: typeof requestTypes.bundle_graph_request;
+    run: (arg1: RunInput) => Async<BundleGraphResult>;
+    input: BundleGraphRequestInput;
+};
+type SerializedBundleGraph = {
+    nodes: Array<any>;
+    edges: Array<number>;
+    publicIdByAssetId: {
+        [k: string]: string;
+    };
+    assetPublicIds: Array<string>;
+    hadPreviousGraph: boolean;
+};
+export default function createBundleGraphRequestRust(input: BundleGraphRequestInput): BundleGraphRequestRust;
+export declare function getBundleGraph(serializedGraph: SerializedBundleGraph): {
+    bundleGraph: InternalBundleGraph;
+    changedAssets: Map<string, Asset>;
+};
+export {};

package/lib/types/requests/BundleGraphRequestUtils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared utilities for BundleGraphRequest and BundleGraphRequestRust.
+ *
+ * This module contains common functionality used by both the JS and native
+ * bundling paths, such as bundle validation, naming, and configuration loading.
+ */
+import type { Namer } from '@atlaspack/types';
+import type { LoadedPlugin } from '../AtlaspackConfig';
+import type { RunAPI } from '../RequestTracker';
+import type { Bundle as InternalBundle, Config, DevDepRequest, AtlaspackOptions, DevDepRequestRef } from '../types';
+import InternalBundleGraph from '../BundleGraph';
+import PluginOptions from '../public/PluginOptions';
+import { PluginWithLoadConfig } from './ConfigRequest';
+import type { BundleGraphResult } from './BundleGraphRequest';
+/**
+ * Validates that all bundles have unique names.
+ * Throws an assertion error if duplicate bundle names are found.
+ */
+export declare function validateBundles(bundleGraph: InternalBundleGraph): void;
+/**
+ * Dump a canonical JSON snapshot of the bundle graph for parity comparison.
+ * Gated by ATLASPACK_DUMP_BUNDLE_GRAPH environment variable which specifies the output directory.
+ * The snapshot captures bundle identity, type, contained assets, and bundle group structure
+ * in a deterministic, sorted format suitable for diffing.
+ */
+export declare function dumpBundleGraphSnapshot(bundleGraph: InternalBundleGraph, variant: 'js' | 'rust'): void;
+/**
+ * Names a bundle by running through the configured namers until one returns a name.
+ */
+export declare function nameBundle(namers: Array<LoadedPlugin<Namer<unknown>>>, internalBundle: InternalBundle, internalBundleGraph: InternalBundleGraph, options: AtlaspackOptions, pluginOptions: PluginOptions, configs: Map<string, Config>): Promise<void>;
+/**
+ * Loads configuration for a plugin and tracks its dev dependencies.
+ */
+export declare function loadPluginConfigWithDevDeps<T extends PluginWithLoadConfig>(plugin: LoadedPlugin<T>, options: AtlaspackOptions, api: RunAPI<BundleGraphResult>, previousDevDeps: Map<string, string>, devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>, configs: Map<string, Config>): Promise<void>;
+/**
+ * Runs a dev dependency request and tracks it in the devDepRequests map.
+ */
+export declare function runDevDepRequest(api: RunAPI<BundleGraphResult>, devDepRequest: DevDepRequest | DevDepRequestRef, devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>): Promise<void>;

package/lib/types/requests/ConfigRequest.d.ts

@@ -0,0 +1,67 @@
+import type { Async, Config as IConfig, PluginOptions as IPluginOptions, PluginLogger as IPluginLogger, PluginTracer as IPluginTracer, NamedBundle as INamedBundle, BundleGraph as IBundleGraph, TransformerSetup } from '@atlaspack/types';
+import type { Config, AtlaspackOptions, InternalFileCreateInvalidation } from '../types';
+import type { LoadedPlugin } from '../AtlaspackConfig';
+import type { RequestResult, RunAPI } from '../RequestTracker';
+import type { ProjectPath } from '../projectPath';
+type Setup<T> = (arg1: {
+    config: IConfig;
+    options: IPluginOptions;
+    logger: IPluginLogger;
+    tracer: IPluginTracer;
+}) => Async<TransformerSetup<T>>;
+export type PluginWithLoadConfig = {
+    loadConfig?: (arg1: {
+        config: IConfig;
+        options: IPluginOptions;
+        logger: IPluginLogger;
+        tracer: IPluginTracer;
+    }) => Async<unknown>;
+};
+export type PluginWithBundleConfig = {
+    loadConfig?: (arg1: {
+        config: IConfig;
+        options: IPluginOptions;
+        logger: IPluginLogger;
+        tracer: IPluginTracer;
+    }) => Async<unknown>;
+    loadBundleConfig?: (arg1: {
+        bundle: INamedBundle;
+        bundleGraph: IBundleGraph<INamedBundle>;
+        config: IConfig;
+        options: IPluginOptions;
+        logger: IPluginLogger;
+        tracer: IPluginTracer;
+    }) => Async<unknown>;
+};
+export type ConfigRequest = {
+    id: string;
+    invalidateOnFileChange: Set<ProjectPath>;
+    invalidateOnConfigKeyChange: Array<{
+        filePath: ProjectPath;
+        configKey: string[];
+    }>;
+    invalidateOnFileCreate: Array<InternalFileCreateInvalidation>;
+    invalidateOnEnvChange: Set<string>;
+    invalidateOnOptionChange: Set<string>;
+    invalidateOnStartup: boolean;
+    invalidateOnBuild: boolean;
+};
+export type ConfigRequestResult = undefined;
+export declare function loadPluginConfig<T extends PluginWithLoadConfig>(loadedPlugin: LoadedPlugin<T>, config: Config, options: AtlaspackOptions): Promise<void>;
+export declare function loadPluginSetup<T>(pluginName: string, setup: Setup<T>, config: Config, options: AtlaspackOptions): Promise<void>;
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+export declare function getValueAtPath(obj: any, key: string[]): any;
+export declare function getConfigKeyContentHash(filePath: ProjectPath, configKey: string[], options: AtlaspackOptions): Promise<Async<string>>;
+export declare function runConfigRequest<TResult extends RequestResult>(api: RunAPI<TResult>, configRequest: ConfigRequest): Promise<void>;
+export declare function getConfigHash(config: Config, pluginName: string, options: AtlaspackOptions): Promise<string>;
+export declare function getConfigRequests(configs: Array<Config>): Array<ConfigRequest>;
+export {};

package/lib/types/requests/DevDepRequest.d.ts

@@ -0,0 +1,30 @@
+import type { DependencySpecifier, SemverRange } from '@atlaspack/types';
+import type { AtlaspackConfig } from '../AtlaspackConfig';
+import type { DevDepRequest, AtlaspackOptions, InternalDevDepOptions, DevDepRequestRef } from '../types';
+import type { RequestResult, RunAPI } from '../RequestTracker';
+import type { ProjectPath } from '../projectPath';
+export declare function createDevDependency(opts: InternalDevDepOptions, requestDevDeps: Map<string, string>, options: AtlaspackOptions): Promise<DevDepRequest | DevDepRequestRef>;
+export type DevDepSpecifier = {
+    specifier: DependencySpecifier;
+    resolveFrom: ProjectPath;
+};
+type DevDepRequests = {
+    devDeps: Map<string, string>;
+    invalidDevDeps: Array<DevDepSpecifier>;
+};
+export declare function getDevDepRequests<TResult extends RequestResult>(api: RunAPI<TResult>): Promise<DevDepRequests>;
+export declare function invalidateDevDeps(invalidDevDeps: Array<DevDepSpecifier>, options: AtlaspackOptions, config: AtlaspackConfig): void;
+export type DevDepRequestResult = {
+    specifier: DependencySpecifier;
+    resolveFrom: ProjectPath;
+    hash: string;
+    additionalInvalidations: undefined | Array<{
+        range?: SemverRange | null | undefined;
+        resolveFrom: ProjectPath;
+        specifier: DependencySpecifier;
+    }>;
+};
+export declare function resolveDevDepRequestRef(devDepRequestRef: DevDepRequest | DevDepRequestRef): DevDepRequest;
+export declare function runDevDepRequest<TResult extends RequestResult>(api: RunAPI<TResult>, devDepRequestRef: DevDepRequest | DevDepRequestRef): Promise<void>;
+export declare function getWorkerDevDepRequests(devDepRequests: Array<DevDepRequest | DevDepRequestRef>): Array<DevDepRequest | DevDepRequestRef>;
+export {};

package/lib/types/requests/EntryRequest.d.ts

@@ -0,0 +1,36 @@
+import type { Async, FilePath, PackageJSON, Glob } from '@atlaspack/types';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { Entry, InternalFile, AtlaspackOptions } from '../types';
+import { Mapping } from '@mischnic/json-sourcemap';
+import { requestTypes } from '../RequestTracker';
+import { ProjectPath } from '../projectPath';
+type RunOpts<TResult> = {
+    input: ProjectPath;
+} & StaticRunOpts<TResult>;
+export type EntryRequest = {
+    id: string;
+    readonly type: typeof requestTypes.entry_request;
+    run: (arg1: RunOpts<EntryRequestResult>) => Async<EntryRequestResult>;
+    input: ProjectPath;
+};
+export type EntryRequestResult = {
+    entries: Array<Entry>;
+    files: Array<InternalFile>;
+    globs: Array<Glob>;
+};
+export default function createEntryRequest(input: ProjectPath): EntryRequest;
+export declare class EntryResolver {
+    options: AtlaspackOptions;
+    constructor(options: AtlaspackOptions);
+    resolveEntry(entry: FilePath): Promise<EntryRequestResult>;
+    readPackage(entry: FilePath): Promise<(PackageJSON & {
+        filePath: FilePath;
+        map: {
+            data: unknown;
+            pointers: {
+                [key: string]: Mapping;
+            };
+        };
+    }) | null | undefined>;
+}
+export {};

package/lib/types/requests/PackageRequest.d.ts

@@ -0,0 +1,27 @@
+import type { ContentKey } from '@atlaspack/graph';
+import type { Async } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { StaticRunOpts } from '../RequestTracker';
+import { requestTypes } from '../RequestTracker';
+import type { Bundle } from '../types';
+import type BundleGraph from '../BundleGraph';
+import type { BundleInfo } from '../PackagerRunner';
+type PackageRequestInput = {
+    bundleGraph: BundleGraph;
+    bundle: Bundle;
+    bundleGraphReference: SharedReference;
+    optionsRef: SharedReference;
+    useMainThread?: boolean;
+};
+export type PackageRequestResult = BundleInfo;
+type RunInput<TResult> = {
+    input: PackageRequestInput;
+} & StaticRunOpts<TResult>;
+export type PackageRequest = {
+    id: ContentKey;
+    readonly type: typeof requestTypes.package_request;
+    run: (arg1: RunInput<BundleInfo>) => Async<BundleInfo>;
+    input: PackageRequestInput;
+};
+export declare function createPackageRequest(input: PackageRequestInput): PackageRequest;
+export {};

package/lib/types/requests/PathRequest.d.ts

@@ -0,0 +1,48 @@
+import type { Diagnostic } from '@atlaspack/diagnostic';
+import type { Async, FileCreateInvalidation, FilePath, Resolver } from '@atlaspack/types';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { AssetGroup, Config, Dependency, DevDepRequest, AtlaspackOptions, DevDepRequestRef } from '../types';
+import PluginOptions from '../public/PluginOptions';
+import { AtlaspackConfig, LoadedPlugin } from '../AtlaspackConfig';
+import { requestTypes } from '../RequestTracker';
+export type PathRequest = {
+    id: string;
+    readonly type: typeof requestTypes.path_request;
+    run: (arg1: RunOpts<PathRequestResult>) => Async<PathRequestResult>;
+    input: PathRequestInput;
+};
+export type PathRequestResult = null | undefined | AssetGroup;
+export type PathRequestInput = {
+    dependency: Dependency;
+    name: string;
+};
+type RunOpts<TResult> = {
+    input: PathRequestInput;
+} & StaticRunOpts<TResult>;
+export default function createPathRequest(input: PathRequestInput): PathRequest;
+type ResolverRunnerOpts = {
+    config: AtlaspackConfig;
+    options: AtlaspackOptions;
+    previousDevDeps: Map<string, string>;
+};
+type ResolverResult = {
+    assetGroup: AssetGroup | null | undefined;
+    invalidateOnFileCreate?: Array<FileCreateInvalidation>;
+    invalidateOnFileChange?: Array<FilePath>;
+    invalidateOnEnvChange?: Array<string>;
+    diagnostics?: Array<Diagnostic>;
+};
+export declare class ResolverRunner {
+    config: AtlaspackConfig;
+    options: AtlaspackOptions;
+    pluginOptions: PluginOptions;
+    previousDevDeps: Map<string, string>;
+    devDepRequests: Map<string, DevDepRequest>;
+    configs: Map<string, Config>;
+    constructor({ config, options, previousDevDeps }: ResolverRunnerOpts);
+    getDiagnostic(dependency: Dependency, message: string): Promise<Async<Diagnostic>>;
+    loadConfigs(resolvers: Array<LoadedPlugin<Resolver<unknown>>>): Promise<void>;
+    runDevDepRequest(devDepRequest: DevDepRequest | DevDepRequestRef): void;
+    resolve(dependency: Dependency): Promise<ResolverResult>;
+}
+export {};

package/lib/types/requests/TargetRequest.d.ts

@@ -0,0 +1,48 @@
+import type { FileSystem } from '@atlaspack/fs';
+import type { Async, FilePath, PackageJSON, PackageTargetDescriptor, OutputFormat } from '@atlaspack/types';
+import type { StaticRunOpts, RunAPI } from '../RequestTracker';
+import type { Entry, AtlaspackOptions, Target } from '../types';
+import { requestTypes } from '../RequestTracker';
+type RunOpts<TResult> = {
+    input: Entry;
+} & StaticRunOpts<TResult>;
+export type TargetRequest = {
+    id: string;
+    readonly type: typeof requestTypes.target_request;
+    run: (arg1: RunOpts<TargetRequestResult>) => Async<TargetRequestResult>;
+    input: Entry;
+};
+export type TargetRequestResult = Target[];
+export default function createTargetRequest(input: Entry): TargetRequest;
+export declare function skipTarget(targetName: string, exclusiveTarget?: FilePath, descriptorSource?: FilePath | Array<FilePath>): boolean;
+type TargetInfo = {
+    output: TargetKeyInfo;
+    engines: TargetKeyInfo;
+    context: TargetKeyInfo;
+    includeNodeModules: TargetKeyInfo;
+    outputFormat: TargetKeyInfo;
+    isLibrary: TargetKeyInfo;
+    shouldOptimize: TargetKeyInfo;
+    shouldScopeHoist: TargetKeyInfo;
+};
+type TargetKeyInfo = {
+    path: string;
+    type?: 'key' | 'value';
+} | {
+    inferred: string;
+    type?: 'key' | 'value';
+    message: string;
+} | {
+    message: string;
+};
+export declare class TargetResolver {
+    fs: FileSystem;
+    api: RunAPI<Array<Target>>;
+    options: AtlaspackOptions;
+    targetInfo: Map<string, TargetInfo>;
+    constructor(api: RunAPI<Array<Target>>, options: AtlaspackOptions);
+    resolve(rootDir: FilePath, exclusiveTarget?: string): Promise<Array<Target>>;
+    resolvePackageTargets(rootDir: FilePath, exclusiveTarget?: string): Promise<Map<string, Target | null>>;
+    inferOutputFormat(distEntry: FilePath | null | undefined, descriptor: PackageTargetDescriptor, targetName: string, pkg: PackageJSON, pkgFilePath?: FilePath | null, pkgContents?: string | null): [OutputFormat | null | undefined, string | null | undefined];
+}
+export {};

package/lib/types/requests/ValidationRequest.d.ts

@@ -0,0 +1,20 @@
+import type { Async } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { AssetGroup } from '../types';
+import { requestTypes } from '../RequestTracker';
+type ValidationRequest = {
+    id: string;
+    readonly type: typeof requestTypes.validation_request;
+    run: (arg1: RunOpts<undefined>) => Async<void>;
+    input: ValidationRequestInput;
+};
+type RunOpts<TResult> = {
+    input: ValidationRequestInput;
+} & StaticRunOpts<TResult>;
+type ValidationRequestInput = {
+    assetRequests: Array<AssetGroup>;
+    optionsRef: SharedReference;
+};
+export default function createValidationRequest(input: ValidationRequestInput): ValidationRequest;
+export {};

package/lib/types/requests/WriteBundleRequest.d.ts

@@ -0,0 +1,80 @@
+import type { ContentKey } from '@atlaspack/graph';
+import type { Async } from '@atlaspack/types';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { Bundle, PackagedBundleInfo, AtlaspackOptions } from '../types';
+import type BundleGraph from '../BundleGraph';
+import type { BundleInfo } from '../PackagerRunner';
+import { Transform } from 'stream';
+import { requestTypes } from '../RequestTracker';
+import SourceMap from '@atlaspack/source-map';
+export type HashRefReplacement = {
+    line: number;
+    column: number;
+    originalLength: number;
+    newLength: number;
+};
+type WriteBundleRequestInput = {
+    bundleGraph: BundleGraph;
+    bundle: Bundle;
+    info: BundleInfo;
+    hashRefToNameHash: Map<string, string>;
+};
+export type WriteBundleRequestResult = PackagedBundleInfo;
+type RunInput<TResult> = {
+    input: WriteBundleRequestInput;
+} & StaticRunOpts<TResult>;
+export type WriteBundleRequest = {
+    id: ContentKey;
+    readonly type: typeof requestTypes.write_bundle_request;
+    run: (arg1: RunInput<PackagedBundleInfo>) => Async<PackagedBundleInfo>;
+    input: WriteBundleRequestInput;
+};
+/**
+ * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
+ */
+export default function createWriteBundleRequest(input: WriteBundleRequestInput): WriteBundleRequest;
+export declare function applyReplacementsToSourceMap(sourceMap: SourceMap, replacements: HashRefReplacement[]): void;
+/**
+ * Applies hash-ref replacement column offsets directly to a VLQ mappings
+ * string without deserializing the full source map into a native struct.
+ *
+ * Each replacement r describes a hash-ref that was substituted in the output
+ * file.  r.column is in the progressively-shifted post-replacement coordinate
+ * space (matching the already-shifted source map state after all previous
+ * offsetColumns calls), so thresholds are applied sequentially against the
+ * running absCol values exactly as the native offsetColumns implementation does.
+ */
+export declare function applyReplacementsToVLQMappings(mappings: string, replacements: HashRefReplacement[]): string;
+/**
+ * A Transform stream that rewrites the "mappings" VLQ field of a source map
+ * JSON to account for hash-ref replacements, without ever loading the full
+ * JSON object or the native Rust SourceMapInner into memory.
+ *
+ * Field order in cached source maps (from partialVlqMapToSourceMap / toVLQ):
+ *   mappings → sources → sourcesContent → names → version → file → sourceRoot
+ *
+ * "mappings" is the very first field, so we scan only a tiny header before
+ * switching to zero-copy passthrough for the bulk sourcesContent bytes.
+ */
+export declare class SourceMapHashRefRewriteStream extends Transform {
+    private replacements;
+    private state;
+    private scanBuf;
+    private mappingsBufs;
+    constructor(replacements: HashRefReplacement[]);
+    _transform(chunk: Buffer, _encoding: string, cb: any): void;
+    private _bufferingTransform;
+    _flush(cb: any): void;
+}
+/**
+ * Computes the sourceRoot for a source map file. This is the relative path from
+ * the output directory back to the project root, so that source paths (stored
+ * relative to projectRoot) resolve correctly from the .map file location.
+ *
+ * Returns undefined when sources are inlined (inlineSources), since the browser
+ * doesn't need to fetch them and sourceRoot would be unnecessary.
+ *
+ * This logic must stay in sync with PackagerRunner.generateSourceMap.
+ */
+export declare function computeSourceMapRoot(bundle: Bundle, options: AtlaspackOptions): string | undefined;
+export {};