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

package/lib/types/Dependency.d.ts

@@ -0,0 +1,44 @@
+import type { FilePath, Meta, DependencySpecifier, SourceLocation, BundleBehavior as IBundleBehavior, SemverRange } from '@atlaspack/types';
+import type { Dependency, Target } from './types';
+import { SpecifierType, Priority } from './types';
+import type { EnvironmentRef } from './EnvironmentManager';
+type DependencyOpts = {
+    id?: string;
+    sourcePath?: FilePath;
+    sourceAssetId?: string;
+    specifier: DependencySpecifier;
+    specifierType: keyof typeof SpecifierType;
+    priority?: keyof typeof Priority;
+    needsStableName?: boolean;
+    bundleBehavior?: IBundleBehavior | null | undefined;
+    isEntry?: boolean;
+    isOptional?: boolean;
+    loc?: SourceLocation;
+    env: EnvironmentRef;
+    packageConditions?: Array<string>;
+    meta?: Meta;
+    resolveFrom?: FilePath;
+    range?: SemverRange;
+    target?: Target;
+    symbols?: Map<symbol, {
+        local: symbol;
+        loc: SourceLocation | null | undefined;
+        isWeak: boolean;
+        meta?: Meta | null | undefined;
+    }> | null | undefined;
+    pipeline?: string | null | undefined;
+};
+export declare function createDependencyId({ sourceAssetId, specifier, env, target, pipeline, specifierType, bundleBehavior, priority, packageConditions, }: {
+    sourceAssetId?: string | undefined;
+    specifier: DependencySpecifier;
+    env: EnvironmentRef;
+    target?: Target | undefined;
+    pipeline?: string | null | undefined;
+    specifierType: keyof typeof SpecifierType;
+    bundleBehavior?: IBundleBehavior | null | undefined;
+    priority?: keyof typeof Priority | undefined;
+    packageConditions?: Array<string> | undefined;
+}): string;
+export declare function createDependency(projectRoot: FilePath, opts: DependencyOpts): Dependency;
+export declare function mergeDependencies(a: Dependency, b: Dependency): void;
+export {};

package/lib/types/Environment.d.ts

@@ -0,0 +1,11 @@
+import type { EnvironmentOptions, Environment as IEnvironment, FilePath, EnvMap } from '@atlaspack/types';
+import type { Environment, InternalSourceLocation } from './types';
+import type { EnvironmentRef } from './EnvironmentManager';
+type EnvironmentOpts = EnvironmentOptions & {
+    loc?: InternalSourceLocation | null | undefined;
+    customEnv?: EnvMap | null | undefined;
+};
+export declare function createEnvironment({ context, engines, includeNodeModules, outputFormat, sourceType, shouldOptimize, isLibrary, shouldScopeHoist, sourceMap, unstableSingleFileOutput, loc, customEnv, }?: EnvironmentOpts): EnvironmentRef;
+export declare function mergeEnvironments(projectRoot: FilePath, a: Environment, b?: EnvironmentOptions | IEnvironment | null): EnvironmentRef;
+export declare function getEnvironmentHash(env: Environment): string;
+export {};

package/lib/types/EnvironmentManager.d.ts

@@ -0,0 +1,37 @@
+/*!
+ * At the moment we're doing this change for `CoreEnvironment`,
+ * but the same change must be made for `TypesEnvironment` in @atlaspack/types.
+ */
+import type { Environment as CoreEnvironment } from './types';
+import { Cache } from '@atlaspack/cache';
+export type EnvironmentId = string;
+/**
+ * When deduplication is cleaned-up this will always be a string.
+ */
+export type EnvironmentRef = EnvironmentId | CoreEnvironment;
+/**
+ * Convert environment to a ref.
+ * This is what we should be using to store environments.
+ */
+export declare function toEnvironmentRef(env: CoreEnvironment): EnvironmentRef;
+/**
+ * Convert environment to a string ID
+ */
+export declare function toEnvironmentId(
+/**
+ * Redundant type during roll-out
+ */
+env: CoreEnvironment | EnvironmentRef): string;
+export declare function fromEnvironmentId(id: EnvironmentRef): CoreEnvironment;
+/**
+ * Writes all environments and their IDs to the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+export declare function writeEnvironmentsToCache(cache: Cache): Promise<void>;
+/**
+ * Loads all environments and their IDs from the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+export declare function loadEnvironmentsFromCache(cache: Cache): Promise<void>;

package/lib/types/IdentifierRegistry.d.ts

@@ -0,0 +1,6 @@
+export declare class IdentifierRegistry {
+    #private;
+    constructor(enabled: boolean);
+    addIdentifier(type: string, identifier: string, data: unknown): void;
+}
+export declare const identifierRegistry: IdentifierRegistry;

package/lib/types/InternalConfig.d.ts

@@ -0,0 +1,23 @@
+import type { PackageName, ConfigResult } from '@atlaspack/types';
+import type { Config, InternalFileCreateInvalidation, InternalDevDepOptions } from './types';
+import type { ProjectPath } from './projectPath';
+import type { EnvironmentRef } from './EnvironmentManager';
+export type ConfigOpts = {
+    plugin: PackageName;
+    searchPath: ProjectPath;
+    isSource?: boolean;
+    env?: EnvironmentRef;
+    result?: ConfigResult;
+    invalidateOnFileChange?: Set<ProjectPath>;
+    invalidateOnConfigKeyChange?: Array<{
+        filePath: ProjectPath;
+        configKey: string[];
+    }>;
+    invalidateOnFileCreate?: Array<InternalFileCreateInvalidation>;
+    invalidateOnEnvChange?: Set<string>;
+    invalidateOnOptionChange?: Set<string>;
+    devDeps?: Array<InternalDevDepOptions>;
+    invalidateOnStartup?: boolean;
+    invalidateOnBuild?: boolean;
+};
+export declare function createConfig({ plugin, isSource, searchPath, env, result, invalidateOnFileChange, invalidateOnConfigKeyChange, invalidateOnFileCreate, invalidateOnEnvChange, invalidateOnOptionChange, devDeps, invalidateOnStartup, invalidateOnBuild, }: ConfigOpts): Config;

package/lib/types/PackagerRunner.d.ts

@@ -0,0 +1,85 @@
+import type { Blob, FilePath, BundleResult, Async } from '@atlaspack/types';
+import type SourceMap from '@atlaspack/source-map';
+import type { Bundle as InternalBundle, Config, DevDepRequest, AtlaspackOptions, ReportFn, RequestInvalidation, DevDepRequestRef } from './types';
+import type { AtlaspackConfig, LoadedPlugin } from './AtlaspackConfig';
+import type InternalBundleGraph from './BundleGraph';
+import type { ConfigRequest } from './requests/ConfigRequest';
+import type { DevDepSpecifier } from './requests/DevDepRequest';
+import { Readable } from 'stream';
+import { NamedBundle } from './public/Bundle';
+import PluginOptions from './public/PluginOptions';
+import { PluginWithBundleConfig } from './requests/ConfigRequest';
+type Opts = {
+    config: AtlaspackConfig;
+    options: AtlaspackOptions;
+    report: ReportFn;
+    previousDevDeps: Map<string, string>;
+    previousInvalidations: Array<RequestInvalidation>;
+};
+export type RunPackagerRunnerResult = {
+    bundleInfo: BundleInfo;
+    configRequests: Array<ConfigRequest>;
+    devDepRequests: Array<DevDepRequest | DevDepRequestRef>;
+    invalidations: Array<RequestInvalidation>;
+};
+export type BundleInfo = {
+    readonly type: string;
+    readonly size: number;
+    readonly hash: string;
+    readonly hashReferences: Array<string>;
+    readonly time?: number;
+    readonly cacheKeys: CacheKeyMap;
+    readonly isLargeBlob: boolean;
+    readonly scopeHoistingStats?: {
+        totalAssets: number;
+        wrappedAssets: number;
+    };
+};
+type CacheKeyMap = {
+    content: string;
+    map: string;
+    info: string;
+};
+export default class PackagerRunner {
+    config: AtlaspackConfig;
+    options: AtlaspackOptions;
+    pluginOptions: PluginOptions;
+    distDir: FilePath;
+    distExists: Set<FilePath>;
+    report: ReportFn;
+    previousDevDeps: Map<string, string>;
+    devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>;
+    invalidations: Map<string, RequestInvalidation>;
+    previousInvalidations: Array<RequestInvalidation>;
+    constructor({ config, options, report, previousDevDeps, previousInvalidations, }: Opts);
+    run(bundleGraph: InternalBundleGraph, bundle: InternalBundle, invalidDevDeps: Array<DevDepSpecifier>): Promise<RunPackagerRunnerResult>;
+    loadConfigs(bundleGraph: InternalBundleGraph, bundle: InternalBundle): Promise<{
+        configs: Map<string, Config>;
+        bundleConfigs: Map<string, Config>;
+    }>;
+    loadConfig(bundleGraph: InternalBundleGraph, bundle: InternalBundle, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<void>;
+    loadPluginConfig<T extends PluginWithBundleConfig>(bundleGraph: InternalBundleGraph, bundle: InternalBundle, plugin: LoadedPlugin<T>, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<void>;
+    getBundleInfoFromCache(bundleGraph: InternalBundleGraph, bundle: InternalBundle, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<Async<BundleInfo | null | undefined>>;
+    getBundleInfo(bundle: InternalBundle, bundleGraph: InternalBundleGraph, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<BundleInfo>;
+    getBundleResult(bundle: InternalBundle, bundleGraph: InternalBundleGraph, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<{
+        type: string;
+        contents: Blob;
+        map: string | null | undefined;
+        scopeHoistingStats?: BundleResult['scopeHoistingStats'];
+    }>;
+    getSourceMapReference(bundle: NamedBundle, map?: SourceMap | null): Async<string | null | undefined>;
+    package(internalBundle: InternalBundle, bundleGraph: InternalBundleGraph, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<BundleResult>;
+    optimize(internalBundle: InternalBundle, internalBundleGraph: InternalBundleGraph, type: string, contents: Blob, map: SourceMap | null | undefined, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<BundleResult>;
+    generateSourceMap(bundle: InternalBundle, map: SourceMap): Promise<string>;
+    getCacheKey(bundle: InternalBundle, bundleGraph: InternalBundleGraph, configs: Map<string, Config>, bundleConfigs: Map<string, Config>, invalidations: Array<RequestInvalidation>): Promise<string>;
+    getDevDepHashes(bundle: InternalBundle): Promise<string>;
+    readFromCache(cacheKey: string): Promise<{
+        contents: Readable;
+        map: Readable | null | undefined;
+    } | null | undefined>;
+    writeToCache(cacheKeys: CacheKeyMap, type: string, contents: Blob, map?: string | null): Promise<BundleInfo>;
+    static getContentKey(cacheKey: string): string;
+    static getMapKey(cacheKey: string): string;
+    static getInfoKey(cacheKey: string): string;
+}
+export {};

package/lib/types/ReporterRunner.d.ts

@@ -0,0 +1,25 @@
+import type { ReporterEvent, Reporter } from '@atlaspack/types';
+import type { WorkerApi } from '@atlaspack/workers';
+import type { AtlaspackOptions } from './types';
+import type { LoadedPlugin } from './AtlaspackConfig';
+import WorkerFarm from '@atlaspack/workers';
+import PluginOptions from './public/PluginOptions';
+type Opts = {
+    options: AtlaspackOptions;
+    reporters: Array<LoadedPlugin<Reporter>>;
+    workerFarm: WorkerFarm;
+};
+export default class ReporterRunner {
+    workerFarm: WorkerFarm;
+    errors: Error[];
+    options: AtlaspackOptions;
+    pluginOptions: PluginOptions;
+    reporters: Array<LoadedPlugin<Reporter>>;
+    constructor(opts: Opts);
+    eventHandler: (arg1: ReporterEvent) => void;
+    report(unsanitisedEvent: ReporterEvent): Promise<void>;
+    dispose(): void;
+}
+export declare function reportWorker(workerApi: WorkerApi, event: ReporterEvent): void;
+export declare function report(event: ReporterEvent): Promise<void>;
+export {};

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;