@atlaspack/core 2.16.2-canary.21 → 2.16.2-canary.211

package/lib/types/RequestTracker.d.ts

@@ -0,0 +1,385 @@
+import { Cache } from '@atlaspack/cache';
+import { ContentGraph } from '@atlaspack/graph';
+import type { ContentGraphOpts, ContentKey, NodeId, SerializedContentGraph, Graph } from '@atlaspack/graph';
+import type { Async, EnvMap } from '@atlaspack/types';
+import { Deferred } from '@atlaspack/utils';
+import type { Options as WatcherOptions, Event } from '@parcel/watcher';
+import type WorkerFarm from '@atlaspack/workers';
+import type { AtlaspackV3 } from './atlaspack-v3/AtlaspackV3';
+import { ProjectPath } from './projectPath';
+import type { AssetGraphRequestResult } from './requests/AssetGraphRequest';
+import type { PackageRequestResult } from './requests/PackageRequest';
+import type { ConfigRequestResult } from './requests/ConfigRequest';
+import type { DevDepRequestResult } from './requests/DevDepRequest';
+import type { WriteBundlesRequestResult } from './requests/WriteBundlesRequest';
+import type { WriteBundleRequestResult } from './requests/WriteBundleRequest';
+import type { TargetRequestResult } from './requests/TargetRequest';
+import type { PathRequestResult } from './requests/PathRequest';
+import type { AtlaspackConfigRequestResult } from './requests/AtlaspackConfigRequest';
+import type { AtlaspackBuildRequestResult } from './requests/AtlaspackBuildRequest';
+import type { EntryRequestResult } from './requests/EntryRequest';
+import type { BundleGraphResult } from './requests/BundleGraphRequest';
+import type { AssetRequestResult, AtlaspackOptions, RequestInvalidation, InternalFileCreateInvalidation, InternalGlob } from './types';
+export declare const requestGraphEdgeTypes: {
+    readonly subrequest: 2;
+    readonly invalidated_by_update: 3;
+    readonly invalidated_by_delete: 4;
+    readonly invalidated_by_create: 5;
+    readonly invalidated_by_create_above: 6;
+    readonly dirname: 7;
+};
+export type RequestGraphEdgeType = (typeof requestGraphEdgeTypes)[keyof typeof requestGraphEdgeTypes];
+type RequestGraphOpts = ContentGraphOpts<RequestGraphNode, RequestGraphEdgeType> & {
+    invalidNodeIds: Set<NodeId>;
+    incompleteNodeIds: Set<NodeId>;
+    globNodeIds: Set<NodeId>;
+    envNodeIds: Set<NodeId>;
+    optionNodeIds: Set<NodeId>;
+    unpredicatableNodeIds: Set<NodeId>;
+    invalidateOnBuildNodeIds: Set<NodeId>;
+    cachedRequestChunks: Set<number>;
+    configKeyNodes: Map<ProjectPath, Set<NodeId>>;
+};
+type SerializedRequestGraph = SerializedContentGraph<RequestGraphNode, RequestGraphEdgeType> & {
+    invalidNodeIds: Set<NodeId>;
+    incompleteNodeIds: Set<NodeId>;
+    globNodeIds: Set<NodeId>;
+    envNodeIds: Set<NodeId>;
+    optionNodeIds: Set<NodeId>;
+    unpredicatableNodeIds: Set<NodeId>;
+    invalidateOnBuildNodeIds: Set<NodeId>;
+    cachedRequestChunks: Set<number>;
+    configKeyNodes: Map<ProjectPath, Set<NodeId>>;
+};
+declare const FILE: 0;
+declare const REQUEST: 1;
+declare const FILE_NAME: 2;
+declare const ENV: 3;
+declare const OPTION: 4;
+declare const GLOB: 5;
+declare const CONFIG_KEY: 6;
+type FileNode = {
+    id: ContentKey;
+    readonly type: typeof FILE;
+};
+type GlobNode = {
+    id: ContentKey;
+    readonly type: typeof GLOB;
+    value: InternalGlob;
+};
+type FileNameNode = {
+    id: ContentKey;
+    readonly type: typeof FILE_NAME;
+};
+type EnvNode = {
+    id: ContentKey;
+    readonly type: typeof ENV;
+    value: string | undefined;
+};
+type OptionNode = {
+    id: ContentKey;
+    readonly type: typeof OPTION;
+    hash: string;
+};
+type ConfigKeyNode = {
+    id: ContentKey;
+    readonly type: typeof CONFIG_KEY;
+    configKey: string[];
+    contentHash: string;
+};
+type Request<TInput, TResult> = {
+    id: string;
+    readonly type: RequestType;
+    input: TInput;
+    run: (arg1: {
+        input: TInput;
+    } & StaticRunOpts<TResult>) => Async<TResult>;
+};
+export type RequestResult = AssetGraphRequestResult | PackageRequestResult | ConfigRequestResult | DevDepRequestResult | WriteBundlesRequestResult | WriteBundleRequestResult | TargetRequestResult | PathRequestResult | AtlaspackConfigRequestResult | AtlaspackBuildRequestResult | EntryRequestResult | BundleGraphResult | AssetRequestResult;
+type InvalidateReason = number;
+type RequestNode = {
+    id: ContentKey;
+    readonly type: typeof REQUEST;
+    readonly requestType: RequestType;
+    invalidateReason: InvalidateReason;
+    result?: RequestResult;
+    resultCacheKey?: string | null | undefined;
+    hash?: string;
+};
+export declare const requestTypes: {
+    readonly atlaspack_build_request: 1;
+    readonly bundle_graph_request: 2;
+    readonly asset_graph_request: 3;
+    readonly entry_request: 4;
+    readonly target_request: 5;
+    readonly atlaspack_config_request: 6;
+    readonly path_request: 7;
+    readonly dev_dep_request: 8;
+    readonly asset_request: 9;
+    readonly config_request: 10;
+    readonly write_bundles_request: 11;
+    readonly package_request: 12;
+    readonly write_bundle_request: 13;
+    readonly validation_request: 14;
+};
+type RequestType = (typeof requestTypes)[keyof typeof requestTypes];
+type RequestGraphNode = RequestNode | FileNode | GlobNode | FileNameNode | EnvNode | OptionNode | ConfigKeyNode;
+export type RunAPI<TResult extends RequestResult> = {
+    invalidateOnFileCreate: (arg1: InternalFileCreateInvalidation) => void;
+    invalidateOnFileDelete: (arg1: ProjectPath) => void;
+    invalidateOnFileUpdate: (arg1: ProjectPath) => void;
+    invalidateOnConfigKeyChange: (filePath: ProjectPath, configKey: string[], contentHash: string) => void;
+    invalidateOnStartup: () => void;
+    invalidateOnBuild: () => void;
+    invalidateOnEnvChange: (arg1: string) => void;
+    invalidateOnOptionChange: (arg1: string) => void;
+    getInvalidations(): Array<RequestInvalidation>;
+    storeResult(result: TResult, cacheKey?: string): void;
+    getRequestResult<T extends RequestResult>(contentKey: ContentKey): Async<T | null | undefined>;
+    getPreviousResult<T extends RequestResult>(ifMatch?: string): Async<T | null | undefined>;
+    getSubRequests(): Array<RequestNode>;
+    getInvalidSubRequests(): Array<RequestNode>;
+    canSkipSubrequest(arg1: ContentKey): boolean;
+    runRequest: <TInput, TResult extends RequestResult>(subRequest: Request<TInput, TResult>, opts?: RunRequestOpts) => Promise<TResult>;
+};
+type RunRequestOpts = {
+    force: boolean;
+};
+export type StaticRunOpts<TResult> = {
+    api: RunAPI<TResult>;
+    farm: WorkerFarm;
+    invalidateReason: InvalidateReason;
+    options: AtlaspackOptions;
+    rustAtlaspack: AtlaspackV3 | null | undefined;
+};
+export declare class RequestGraph extends ContentGraph<RequestGraphNode, RequestGraphEdgeType> {
+    invalidNodeIds: Set<NodeId>;
+    incompleteNodeIds: Set<NodeId>;
+    incompleteNodePromises: Map<NodeId, Promise<boolean>>;
+    globNodeIds: Set<NodeId>;
+    envNodeIds: Set<NodeId>;
+    optionNodeIds: Set<NodeId>;
+    unpredicatableNodeIds: Set<NodeId>;
+    invalidateOnBuildNodeIds: Set<NodeId>;
+    cachedRequestChunks: Set<number>;
+    configKeyNodes: Map<ProjectPath, Set<NodeId>>;
+    nodesPerBlob: number;
+    static deserialize(opts: RequestGraphOpts): RequestGraph;
+    serialize(): SerializedRequestGraph;
+    addNode(node: RequestGraphNode): NodeId;
+    removeNode(nodeId: NodeId, removeOrphans?: boolean): void;
+    getRequestNode(nodeId: NodeId): RequestNode;
+    replaceSubrequests(requestNodeId: NodeId, subrequestContentKeys: Array<ContentKey>): void;
+    invalidateNode(nodeId: NodeId, reason: InvalidateReason): void;
+    /**
+     * Nodes that are invalidated on start-up, such as JavaScript babel configuration files which are
+     * imported when the build kicks-off and might doing arbitrary work such as reading from the file
+     * system.
+     */
+    invalidateUnpredictableNodes(): void;
+    /**
+     * Effectively uncacheable nodes.
+     */
+    invalidateOnBuildNodes(): void;
+    /**
+     * Nodes invalidated by environment changes, corresponds to `env: ...` inputs.
+     */
+    invalidateEnvNodes(env: EnvMap): string[];
+    /**
+     * Nodes invalidated by option changes.
+     */
+    invalidateOptionNodes(options: AtlaspackOptions): string[];
+    invalidateOnConfigKeyChange(requestNodeId: NodeId, filePath: ProjectPath, configKey: string[], contentHash: string): void;
+    invalidateOnFileUpdate(requestNodeId: NodeId, filePath: ProjectPath): void;
+    invalidateOnFileDelete(requestNodeId: NodeId, filePath: ProjectPath): void;
+    invalidateOnFileCreate(requestNodeId: NodeId, input: InternalFileCreateInvalidation): void;
+    invalidateOnStartup(requestNodeId: NodeId): void;
+    invalidateOnBuild(requestNodeId: NodeId): void;
+    invalidateOnEnvChange(requestNodeId: NodeId, env: string, value?: string): void;
+    invalidateOnOptionChange(requestNodeId: NodeId, option: string, value: unknown): void;
+    clearInvalidations(nodeId: NodeId): void;
+    getInvalidations(requestNodeId: NodeId): Array<RequestInvalidation>;
+    getSubRequests(requestNodeId: NodeId): Array<RequestNode>;
+    getInvalidSubRequests(requestNodeId: NodeId): Array<RequestNode>;
+    invalidateFileNameNode(node: FileNameNode, filePath: ProjectPath, matchNodes: Array<FileNode>, invalidateNode: (arg1: NodeId, arg2: InvalidateReason) => void): void;
+    respondToFSEvents(events: Array<Event>, options: AtlaspackOptions, threshold: number, 
+    /**
+     * True if this is the start-up (loading phase) invalidation.
+     */
+    isInitialBuild?: boolean): Promise<{
+        didInvalidate: boolean;
+        invalidationsByPath: Map<string, number>;
+    }>;
+    hasCachedRequestChunk(index: number): boolean;
+    setCachedRequestChunk(index: number): void;
+    removeCachedRequestChunkForNode(nodeId: number): void;
+    /**
+     * Returns the number of invalidated nodes in the graph.
+     */
+    getInvalidNodeCount(): number;
+}
+export default class RequestTracker {
+    graph: RequestGraph;
+    farm: WorkerFarm;
+    options: AtlaspackOptions;
+    rustAtlaspack: AtlaspackV3 | null | undefined;
+    stats: Map<RequestType, number>;
+    constructor({ graph, farm, options, rustAtlaspack, }: {
+        graph?: RequestGraph;
+        farm: WorkerFarm;
+        options: AtlaspackOptions;
+        rustAtlaspack?: AtlaspackV3;
+    });
+    startRequest(request: RequestNode): {
+        requestNodeId: NodeId;
+        deferred: Deferred<boolean>;
+    };
+    storeResult(nodeId: NodeId, result: RequestResult, cacheKey?: string | null): void;
+    hasValidResult(nodeId: NodeId): boolean;
+    getRequestResult<T extends RequestResult>(contentKey: ContentKey, ifMatch?: string): Promise<T | null | undefined>;
+    completeRequest(nodeId: NodeId): void;
+    rejectRequest(nodeId: NodeId): void;
+    respondToFSEvents(events: Array<Event>, threshold: number): Promise<{
+        didInvalidate: boolean;
+        invalidationsByPath: Map<string, number>;
+    }>;
+    hasInvalidRequests(): boolean;
+    getInvalidRequests(): Array<RequestNode>;
+    replaceSubrequests(requestNodeId: NodeId, subrequestContextKeys: Array<ContentKey>): void;
+    runRequest<TInput, TResult extends RequestResult>(request: Request<TInput, TResult>, opts?: RunRequestOpts | null): Promise<TResult>;
+    flushStats(): {
+        [requestType: string]: number;
+    };
+    createAPI<TResult extends RequestResult>(requestId: NodeId, previousInvalidations: Array<RequestInvalidation>): {
+        api: RunAPI<TResult>;
+        subRequestContentKeys: Set<ContentKey>;
+    };
+    writeToCache(signal?: AbortSignal): Promise<void>;
+    static init({ farm, options, rustAtlaspack, }: {
+        farm: WorkerFarm;
+        options: AtlaspackOptions;
+        rustAtlaspack?: AtlaspackV3;
+    }): Promise<Async<RequestTracker>>;
+}
+export declare function getWatcherOptions({ watchIgnore, cacheDir, watchDir, watchBackend, }: AtlaspackOptions): WatcherOptions;
+export declare function readAndDeserializeRequestGraph(cache: Cache, requestGraphKey: string, cacheKey: string): Promise<Async<{
+    requestGraph: RequestGraph;
+    bufferLength: number;
+}>>;
+/**
+ * A wrapper around an invalidation type / method
+ */
+type InvalidationFn = {
+    key: string;
+    fn: () => InvalidationDetail | Promise<InvalidationDetail> | undefined | Promise<undefined>;
+};
+type InvalidationStats = {
+    /**
+     * Total number of request graph nodes
+     */
+    nodeCount: number;
+    /**
+     * Number of requests in RequestGraph
+     */
+    requestCount: number;
+    /**
+     * Number of nodes that have been invalidated.
+     */
+    invalidatedCount: number;
+    /**
+     * Percentage of requests that have been invalidated
+     */
+    requestInvalidationRatio: number;
+    /**
+     * Percentage of nodes that have been invalidated
+     */
+    nodeInvalidationRatio: number;
+    /**
+     * Details for each invalidation type
+     */
+    invalidations: InvalidationFnStats[];
+};
+/**
+ * Details about an invalidation.
+ *
+ * If this is a fs events invalidation, this key will contain statistics about invalidations
+ * by path.
+ *
+ * If this is a env or option invalidation, this key will contain the list of changed environment
+ * variables or options.
+ */
+type InvalidationDetail = string[] | FSInvalidationStats;
+/**
+ * Number of invalidations for a given file-system event.
+ */
+type FSInvalidation = {
+    path: string;
+    count: number;
+};
+type FSInvalidationStats = {
+    /**
+     * This list will be sorted by the number of nodes invalidated and only the top 10 will be
+     * included.
+     */
+    biggestInvalidations: FSInvalidation[];
+};
+/**
+ * Information about a certain cache invalidation type.
+ */
+type InvalidationFnStats = {
+    /**
+     * Invalidation type, one of:
+     *
+     * - unpredictable
+     * - onBuild
+     * - env
+     * - option
+     * - fsEvents
+     */
+    key: string;
+    /**
+     * Number of invalidated nodes coming from this invalidation type.
+     */
+    count: number;
+    /**
+     * If this is a env or option invalidation, this key will contain the list of changed values.
+     *
+     * If this is a fs events invalidation, this key will contain statistics about invalidations
+     */
+    detail: null | InvalidationDetail;
+    /**
+     * Time in milliseconds it took to run the invalidation.
+     */
+    duration: number;
+};
+/**
+ * Respond to unpredictable, build, environment changes, option changes and file-system events
+ * invalidating RequestGraph nodes.
+ *
+ * Returns the count of nodes invalidated by each invalidation type.
+ */
+export declare function invalidateRequestGraph(requestGraph: RequestGraph, options: AtlaspackOptions, events: Event[]): Promise<InvalidationStats>;
+interface InvalidateRequestGraphFSEventsInput {
+    respondToFSEvents(events: Event[], options: AtlaspackOptions, timeout: number, shouldLog: boolean): Promise<{
+        invalidationsByPath: Map<string, number>;
+    }>;
+}
+/**
+ * Invalidate the request graph based on file-system events.
+ *
+ * Returns statistics about the invalidations.
+ */
+export declare function invalidateRequestGraphFSEvents(requestGraph: InvalidateRequestGraphFSEventsInput, options: AtlaspackOptions, events: Event[]): Promise<FSInvalidationStats>;
+interface RunInvalidationInput {
+    getInvalidNodeCount(): number;
+}
+/**
+ * Runs an invalidation function and reports metrics.
+ */
+export declare function runInvalidation(requestGraph: RunInvalidationInput, invalidationFn: InvalidationFn): Promise<InvalidationFnStats>;
+export declare function cleanUpOrphans<N, E extends number>(graph: Graph<N, E>): NodeId[];
+/**
+ * Returns paths that invalidated the most nodes
+ */
+export declare function getBiggestFSEventsInvalidations(invalidationsByPath: Map<string, number>, limit?: number): Array<FSInvalidation>;
+export {};

package/lib/types/SymbolPropagation.d.ts

@@ -0,0 +1,11 @@
+import type { NodeId } from '@atlaspack/graph';
+import type { Diagnostic } from '@atlaspack/diagnostic';
+import type { AtlaspackOptions } from './types';
+import { default as AssetGraph } from './AssetGraph';
+export declare function propagateSymbols({ options, assetGraph, changedAssetsPropagation, assetGroupsWithRemovedParents, previousErrors, }: {
+    options: AtlaspackOptions;
+    assetGraph: AssetGraph;
+    changedAssetsPropagation: Set<string>;
+    assetGroupsWithRemovedParents: Set<NodeId>;
+    previousErrors?: Map<NodeId, Array<Diagnostic>> | null | undefined;
+}): Map<NodeId, Array<Diagnostic>>;

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

@@ -0,0 +1,5 @@
+import type { SchemaEntity, SchemaObject } from '@atlaspack/utils';
+export declare const ENGINES_SCHEMA: SchemaEntity;
+export declare const PACKAGE_DESCRIPTOR_SCHEMA: SchemaObject;
+export declare const DESCRIPTOR_SCHEMA: SchemaEntity;
+export declare const COMMON_TARGET_DESCRIPTOR_SCHEMA: SchemaEntity;

package/lib/types/Transformation.d.ts

@@ -0,0 +1,72 @@
+import type { GenerateOutput, Transformer, TransformerResult, PackageName, SemverRange } from '@atlaspack/types';
+import type { WorkerApi } from '@atlaspack/workers';
+import type { Asset as AssetValue, TransformationRequest, Config, DevDepRequest, AtlaspackOptions, InternalDevDepOptions, Invalidations, DevDepRequestRef } from './types';
+import type { LoadedPlugin } from './AtlaspackConfig';
+import { Diagnostic } from '@atlaspack/diagnostic';
+import { AtlaspackConfig } from './AtlaspackConfig';
+import { ResolverRunner } from './requests/PathRequest';
+import UncommittedAsset from './UncommittedAsset';
+import PluginOptions from './public/PluginOptions';
+import { ConfigRequest } from './requests/ConfigRequest';
+import { ProjectPath } from './projectPath';
+type GenerateFunc = (input: UncommittedAsset) => Promise<GenerateOutput>;
+type PostProcessFunc = (arg1: Array<UncommittedAsset>) => Promise<Array<UncommittedAsset> | null>;
+export type TransformationOpts = {
+    options: AtlaspackOptions;
+    config: AtlaspackConfig;
+    request: TransformationRequest;
+    workerApi: WorkerApi;
+};
+export type TransformationResult = {
+    assets?: Array<AssetValue>;
+    error?: Array<Diagnostic>;
+    configRequests: Array<ConfigRequest>;
+    invalidations: Invalidations;
+    devDepRequests: Array<DevDepRequest | DevDepRequestRef>;
+};
+export default class Transformation {
+    request: TransformationRequest;
+    configs: Map<string, Config>;
+    devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>;
+    pluginDevDeps: Array<InternalDevDepOptions>;
+    options: AtlaspackOptions;
+    pluginOptions: PluginOptions;
+    workerApi: WorkerApi;
+    atlaspackConfig: AtlaspackConfig;
+    invalidations: Invalidations;
+    resolverRunner: ResolverRunner;
+    constructor({ request, options, config, workerApi }: TransformationOpts);
+    run(): Promise<TransformationResult>;
+    loadAsset(): Promise<UncommittedAsset>;
+    runPipelines(pipeline: Pipeline, initialAsset: UncommittedAsset): Promise<Array<UncommittedAsset>>;
+    addDevDependency(opts: InternalDevDepOptions): Promise<void>;
+    runPipeline(pipeline: Pipeline, initialAsset: UncommittedAsset): Promise<Array<UncommittedAsset>>;
+    loadPipeline(filePath: ProjectPath, isSource: boolean, pipeline?: string | null): Promise<Pipeline>;
+    loadNextPipeline({ filePath, isSource, newType, newPipeline, currentPipeline, }: {
+        filePath: ProjectPath;
+        isSource: boolean;
+        newType: string;
+        newPipeline: string | null | undefined;
+        currentPipeline: Pipeline;
+    }): Promise<Pipeline | null | undefined>;
+    loadTransformerConfig(transformer: LoadedPlugin<Transformer<unknown>>, isSource: boolean): Promise<Config | null | undefined>;
+    runTransformer(pipeline: Pipeline, asset: UncommittedAsset, transformer: Transformer<unknown>, transformerName: string, preloadedConfig: Config | null | undefined, configKeyPath: string | null | undefined, atlaspackConfig: AtlaspackConfig): Promise<ReadonlyArray<TransformerResult | UncommittedAsset>>;
+}
+type Pipeline = {
+    id: string;
+    transformers: Array<TransformerWithNameAndConfig>;
+    options: AtlaspackOptions;
+    pluginOptions: PluginOptions;
+    workerApi: WorkerApi;
+    postProcess?: PostProcessFunc;
+    generate?: GenerateFunc;
+};
+type TransformerWithNameAndConfig = {
+    name: PackageName;
+    plugin: Transformer<unknown>;
+    config: Config | null | undefined;
+    configKeyPath?: string;
+    resolveFrom: ProjectPath;
+    range?: SemverRange | null | undefined;
+};
+export {};

package/lib/types/UncommittedAsset.d.ts

@@ -0,0 +1,61 @@
+import type { AST, Blob, DependencyOptions, FileCreateInvalidation, GenerateOutput, PackageName, TransformerResult } from '@atlaspack/types';
+import type { Asset, Dependency, AtlaspackOptions, Invalidations } from './types';
+import { Readable } from 'stream';
+import SourceMap from '@parcel/source-map';
+import { ProjectPath } from './projectPath';
+type UncommittedAssetOptions = {
+    value: Asset;
+    options: AtlaspackOptions;
+    content?: Blob | null | undefined;
+    mapBuffer?: Buffer | null | undefined;
+    ast?: AST | null | undefined;
+    isASTDirty?: boolean | null | undefined;
+    code?: string | null | undefined;
+    invalidations?: Invalidations;
+};
+export default class UncommittedAsset {
+    value: Asset;
+    options: AtlaspackOptions;
+    content: Blob | Promise<Buffer> | null | undefined;
+    mapBuffer: Buffer | null | undefined;
+    sourceContent: string | null | undefined;
+    map: SourceMap | null | undefined;
+    ast: AST | null | undefined;
+    isASTDirty: boolean;
+    code: string | null | undefined;
+    invalidations: Invalidations;
+    generate: (() => Promise<GenerateOutput>) | null | undefined;
+    constructor({ value, options, content, mapBuffer, ast, isASTDirty, code, invalidations, }: UncommittedAssetOptions);
+    commit(): Promise<void>;
+    commitContent(contentKey: string): Promise<{
+        size: number;
+        hash: string;
+    }>;
+    getCode(): Promise<string>;
+    getBuffer(): Promise<Buffer>;
+    getStream(): Readable;
+    setCode(code: string): void;
+    setBuffer(buffer: Buffer): void;
+    /**
+     * @deprecated This has been broken on any cache other than FSCache for a long time.
+     */
+    setStream(stream: Readable): void;
+    loadExistingSourcemap(): Promise<SourceMap | null | undefined>;
+    getMapBuffer(): Promise<Buffer | null | undefined>;
+    getMap(): Promise<SourceMap | null | undefined>;
+    setMap(map?: SourceMap | null): void;
+    getAST(): Promise<AST | null | undefined>;
+    setAST(ast: AST): void;
+    clearAST(): void;
+    getCacheKey(key: string): string;
+    addDependency(opts: DependencyOptions): string;
+    invalidateOnFileChange(filePath: ProjectPath): void;
+    invalidateOnFileCreate(invalidation: FileCreateInvalidation): void;
+    invalidateOnEnvChange(key: string): void;
+    invalidateOnBuild(): void;
+    invalidateOnStartup(): void;
+    getDependencies(): Array<Dependency>;
+    createChildAsset(result: TransformerResult, plugin: PackageName, configPath: ProjectPath, configKeyPath?: string): UncommittedAsset;
+    updateId(): void;
+}
+export {};

package/lib/types/Validation.d.ts

@@ -0,0 +1,37 @@
+import type { WorkerApi } from '@atlaspack/workers';
+import type { AssetGroup, AtlaspackOptions, ReportFn } from './types';
+import type { Validator, ValidateResult } from '@atlaspack/types';
+import { AtlaspackConfig } from './AtlaspackConfig';
+import UncommittedAsset from './UncommittedAsset';
+export type ValidationOpts = {
+    config: AtlaspackConfig;
+    /**
+     * If true, this Validation instance will run all validators that implement the single-threaded "validateAll" method.
+     * If falsy, it will run validators that implement the one-asset-at-a-time "validate" method.
+     */
+    dedicatedThread?: boolean;
+    options: AtlaspackOptions;
+    requests: AssetGroup[];
+    report: ReportFn;
+    workerApi?: WorkerApi;
+};
+export default class Validation {
+    allAssets: {
+        [validatorName: string]: UncommittedAsset[];
+    };
+    allValidators: {
+        [validatorName: string]: Validator;
+    };
+    dedicatedThread: boolean;
+    impactfulOptions: Partial<AtlaspackOptions>;
+    options: AtlaspackOptions;
+    atlaspackConfig: AtlaspackConfig;
+    report: ReportFn;
+    requests: AssetGroup[];
+    workerApi: WorkerApi | null | undefined;
+    constructor({ config, dedicatedThread, options, requests, report, workerApi, }: ValidationOpts);
+    run(): Promise<void>;
+    buildAssetsAndValidators(): Promise<void>;
+    handleResults(validatorResults: Array<ValidateResult | null | undefined>): void;
+    loadAsset(request: AssetGroup): Promise<UncommittedAsset>;
+}

package/lib/types/applyRuntimes.d.ts

@@ -0,0 +1,25 @@
+import type { SharedReference } from '@atlaspack/workers';
+import type { Asset, Config, DevDepRequest, AtlaspackOptions, DevDepRequestRef } from './types';
+import type { AtlaspackConfig } from './AtlaspackConfig';
+import type PluginOptions from './public/PluginOptions';
+import type { RequestResult, RunAPI } from './RequestTracker';
+import InternalBundleGraph from './BundleGraph';
+/**
+ * The applyRuntimes function is responsible for generating all the runtimes
+ * (assets created during the build that don't actually exist on disk) and then
+ * linking them into the bundle graph.
+ *
+ * Introduction of manifest bundles: https://github.com/parcel-bundler/parcel/pull/8837
+ * Introduction of reverse topology: https://github.com/parcel-bundler/parcel/pull/8981
+ */
+export default function applyRuntimes<TResult extends RequestResult>({ bundleGraph, config, options, pluginOptions, api, optionsRef, previousDevDeps, devDepRequests, configs, }: {
+    bundleGraph: InternalBundleGraph;
+    config: AtlaspackConfig;
+    options: AtlaspackOptions;
+    optionsRef: SharedReference;
+    pluginOptions: PluginOptions;
+    api: RunAPI<TResult>;
+    previousDevDeps: Map<string, string>;
+    devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>;
+    configs: Map<string, Config>;
+}): Promise<Map<string, Asset>>;

package/lib/types/assetUtils.d.ts

@@ -0,0 +1,42 @@
+import type { ASTGenerator, BundleBehavior, FilePath, GenerateOutput, Meta, PackageName, Stats, SourceLocation } from '@atlaspack/types';
+import type { Asset, RequestInvalidation, Dependency, AtlaspackOptions } from './types';
+import CommittedAsset from './CommittedAsset';
+import UncommittedAsset from './UncommittedAsset';
+import { ProjectPath } from './projectPath';
+import type { EnvironmentRef } from './EnvironmentManager';
+export type AssetOptions = {
+    id?: string;
+    committed?: boolean;
+    code: string | undefined | null;
+    filePath: ProjectPath;
+    query?: string | null | undefined;
+    type: string;
+    contentKey?: string | null | undefined;
+    mapKey?: string | null | undefined;
+    astKey?: string | null | undefined;
+    astGenerator?: ASTGenerator | null | undefined;
+    dependencies?: Map<string, Dependency>;
+    bundleBehavior?: BundleBehavior | null | undefined;
+    isBundleSplittable?: boolean | null | undefined;
+    isSource: boolean;
+    env: EnvironmentRef;
+    meta?: Meta;
+    outputHash?: string | null | undefined;
+    pipeline?: string | null | undefined;
+    stats: Stats;
+    symbols?: Map<symbol, {
+        local: symbol;
+        loc: SourceLocation | null | undefined;
+        meta?: Meta | null | undefined;
+    }> | null | undefined;
+    sideEffects?: boolean;
+    uniqueKey?: string | null | undefined;
+    plugin?: PackageName;
+    configPath?: ProjectPath;
+    configKeyPath?: string;
+};
+export declare function createAssetIdFromOptions(options: AssetOptions): string;
+export declare function createAsset(projectRoot: FilePath, options: AssetOptions): Asset;
+export declare function generateFromAST(asset: CommittedAsset | UncommittedAsset): Promise<GenerateOutput>;
+export declare function getInvalidationId(invalidation: RequestInvalidation): string;
+export declare function getInvalidationHash(invalidations: Array<RequestInvalidation>, options: AtlaspackOptions): Promise<string>;

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

@@ -0,0 +1,26 @@
+import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions } from '@atlaspack/rust';
+import type { Event } from '@parcel/watcher';
+import type { NapiWorkerPool as INapiWorkerPool } from '@atlaspack/types';
+export type AtlaspackV3Options = {
+    fs?: AtlaspackNapiOptions['fs'];
+    packageManager?: AtlaspackNapiOptions['packageManager'];
+    threads?: number;
+    /**
+     * A reference to LMDB lite's rust object
+     */
+    lmdb: Lmdb;
+    featureFlags?: {
+        [key: string]: string | boolean;
+    };
+    napiWorkerPool?: INapiWorkerPool;
+} & AtlaspackNapiOptions['options'];
+export declare class AtlaspackV3 {
+    _atlaspack_napi: AtlaspackNapi;
+    _napiWorkerPool: INapiWorkerPool;
+    _isDefaultNapiWorkerPool: boolean;
+    constructor(atlaspack_napi: AtlaspackNapi, napiWorkerPool: INapiWorkerPool, isDefaultNapiWorkerPool: boolean);
+    static create({ fs, packageManager, threads, lmdb, napiWorkerPool, ...options }: AtlaspackV3Options): Promise<AtlaspackV3>;
+    end(): void;
+    buildAssetGraph(): Promise<any>;
+    respondToFsEvents(events: Array<Event>): Promise<boolean>;
+}