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

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 '@atlaspack/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,35 @@
+import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions, CacheStats, PackageOptions } from '@atlaspack/rust';
+import { Diagnostic } from '@atlaspack/diagnostic';
+import type { Event } from '@parcel/watcher';
+import type { NapiWorkerPool as INapiWorkerPool } from '@atlaspack/types';
+import type BundleGraph from '../BundleGraph';
+import { RunPackagerRunnerResult } from '../PackagerRunner';
+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(progressCallback?: (eventJson: string) => void): Promise<any>;
+    buildBundleGraph(progressCallback?: (eventJson: string) => void): Promise<any>;
+    build(progressCallback: (eventJson: string) => void): Promise<any>;
+    loadBundleGraph(bundleGraph: BundleGraph): Promise<void>;
+    updateBundleGraph(bundleGraph: BundleGraph, changedAssetIds: string[]): Promise<void>;
+    package(bundleId: string, options?: PackageOptions): Promise<[RunPackagerRunnerResult, Diagnostic | null]>;
+    respondToFsEvents(events: Array<Event>): Promise<boolean>;
+    completeCacheSession(): Promise<CacheStats>;
+}

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

@@ -0,0 +1,13 @@
+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);
+    clearAllWorkerState(): Promise<void[]>;
+    workerCount(): number;
+    getWorkers(): Promise<Array<Transferable>>;
+    shutdown(): void;
+}

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

@@ -0,0 +1,13 @@
+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>;
+    writeFile: JsCallable<[FilePath, number[]], Promise<void>>;
+}

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

@@ -0,0 +1,6 @@
+export { FileSystemV3 } from './fs';
+export { AtlaspackV3 } from './AtlaspackV3';
+export { NapiWorkerPool } from './NapiWorkerPool';
+export * from './AtlaspackV3';
+export * from './NapiWorkerPool';
+export type { CacheStats } from '@atlaspack/rust';

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

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,10 +1,8 @@
-// @flow
 export * from './bitflags';
 export * from './dependency';
 export * from './environment';
 export * from './target';
 export * from './plugin-config';
 export * from './plugin-tracer';
-export * from './plugin-logger';
 export * from './plugin-options';
 export * from './mutable-asset';

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

@@ -0,0 +1,49 @@
+import SourceMap from '@atlaspack/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,29 @@
+import type { Config as IPluginConfig, DevDepOptions, FilePath, Environment, FileCreateInvalidation, ConfigResultWithFilePath, PackageJSON } from '@atlaspack/types';
+import { type ConfigOpts } from '../../../InternalConfig';
+export declare class PluginConfig implements IPluginConfig {
+    #private;
+    isSource: boolean;
+    searchPath: FilePath;
+    env: Environment;
+    constructor(configOpts: ConfigOpts, options: any);
+    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-options.d.ts

@@ -0,0 +1,23 @@
+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;
+    used: boolean;
+    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/side-effect-detector.d.ts

@@ -0,0 +1,76 @@
+import type { Async } from '@atlaspack/types';
+export interface FsUsage {
+    method: string;
+    path?: string;
+}
+export interface EnvUsage {
+    vars: Set<string>;
+    didEnumerate: boolean;
+}
+export interface SideEffects {
+    fsUsage: FsUsage[];
+    envUsage: EnvUsage;
+    packageName: string;
+}
+/**
+ * Side effect detector using AsyncLocalStorage to track filesystem and environment variable
+ * access across concurrent async operations in a Node.js worker thread.
+ *
+ * Usage:
+ *   const detector = new SideEffectDetector();
+ *   detector.install();
+ *
+ *   const [result, sideEffects] = await detector.monitorSideEffects(async () => {
+ *     return await someOperation();
+ *   });
+ *
+ *   console.log(sideEffects.fsUsage);   // Array of filesystem accesses
+ *   console.log(sideEffects.envUsage);  // Array of environment variable accesses
+ */
+export declare class SideEffectDetector {
+    private asyncStorage;
+    private patchesInstalled;
+    private originalMethods;
+    constructor();
+    /**
+     * Install global patches for filesystem and environment variable monitoring.
+     * This should be called once when the worker starts up.
+     */
+    install(): void;
+    /**
+     * Monitor side effects for an async operation.
+     *
+     * @param {Function} fn - Async function to monitor
+     * @param {Object} options - Optional configuration
+     * @param {string} options.label - Optional label for debugging
+     * @returns {Promise<[any, SideEffects]>} Tuple of [result, sideEffects]
+     */
+    monitorSideEffects<T>(packageName: string, fn: () => Async<T>): Async<[T, SideEffects]>;
+    /**
+     * Get the current monitoring context, if any.
+     * Useful for debugging or custom instrumentation.
+     *
+     * @returns {Object|null} Current context or null if not monitoring
+     */
+    getCurrentContext(): SideEffects | null;
+    /**
+     * Check if currently monitoring side effects.
+     *
+     * @returns {boolean}
+     */
+    isMonitoring(): boolean;
+    /**
+     * Patch filesystem methods to record access.
+     * @private
+     */
+    private _patchFilesystem;
+    /**
+     * Patch process.env to record environment variable access.
+     * @private
+     */
+    private _patchProcessEnv;
+}
+/**
+ * Default instance for convenience. Most workers will only need one detector.
+ */
+export declare const defaultDetector: SideEffectDetector;