@atlaspack/workers 2.14.21 → 2.14.22-typescript-5ad950d33.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2024 Atlassian US., Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/index.d.ts

@@ -1,5 +1,6 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import type {FilePath} from '@atlaspack/types';
+import type EventEmitter from 'events';
 
 type BackendType = 'process' | 'threads';
 
@@ -15,10 +16,101 @@ export type FarmOptions = {
   shouldTrace?: boolean;
 };
 
-declare class WorkerFarm {
-  constructor(options: FarmOptions);
+export class Bus extends EventEmitter {
+  emit(event: string, ...args: Array<any>): boolean;
+}
+
+export const bus: Bus;
 
+export declare class WorkerFarm {
+  ending: boolean;
+  workerApi: {
+    callChild: (
+      childId: number,
+      request: HandleCallRequest,
+    ) => Promise<unknown>;
+    callMaster: (
+      request: CallRequest,
+      awaitResponse?: boolean | null | undefined,
+    ) => Promise<unknown>;
+    createReverseHandle: (fn: HandleFunction) => Handle;
+    getSharedReference: (ref: SharedReference) => unknown;
+    resolveSharedReference: (value: unknown) => undefined | SharedReference;
+    runHandle: (handle: Handle, args: Array<any>) => Promise<unknown>;
+  };
+  constructor(options: Partial<FarmOptions>);
+  createSharedReference(
+    value: unknown,
+    isCacheable?: boolean,
+  ): {
+    ref: SharedReference;
+    dispose(): Promise<unknown>;
+  };
+  startProfile(): Promise<void>;
+  endProfile(): Promise<void>;
+  takeHeapSnapshot(): Promise<void>;
+  createHandle(method: string, useMainThread?: boolean): HandleFunction;
+  createReverseHandle(fn: HandleFunction): Handle;
+  callAllWorkers(method: string, args: Array<any>): Promise<void>;
+  static getWorkerApi(): {
+    callMaster: (
+      request: CallRequest,
+      awaitResponse?: boolean | null | undefined,
+    ) => Promise<unknown>;
+    createReverseHandle: (fn: (...args: Array<any>) => unknown) => Handle;
+    getSharedReference: (ref: SharedReference) => unknown;
+    resolveSharedReference: (value: unknown) => undefined | SharedReference;
+    runHandle: (handle: Handle, args: Array<any>) => Promise<unknown>;
+  };
   end(): Promise<void>;
+  static isWorker(): boolean;
 }
 
 export default WorkerFarm;
+
+export type SharedReference = number;
+
+export type WorkerApi = {
+  callMaster(
+    arg1: CallRequest,
+    arg2?: boolean | null | undefined,
+  ): Promise<unknown>;
+  createReverseHandle(fn: HandleFunction): Handle;
+  getSharedReference(ref: SharedReference): unknown;
+  resolveSharedReference(value: unknown): SharedReference | null | undefined;
+  callChild?: (childId: number, request: HandleCallRequest) => Promise<unknown>;
+};
+
+export type HandleFunction = (...args: Array<any>) => any;
+
+export type LocationCallRequest = {
+  args: ReadonlyArray<unknown>;
+  location: string;
+  method?: string;
+};
+
+export type HandleCallRequest = {
+  args: ReadonlyArray<unknown>;
+  handle: number;
+};
+
+export type CallRequest = LocationCallRequest | HandleCallRequest;
+
+type HandleOpts = {
+  fn?: HandleFunction;
+  childId?: number | null | undefined;
+  id?: number;
+};
+
+export declare class Handle {
+  id: number;
+  childId: number | null | undefined;
+  fn: HandleFunction | null | undefined;
+  constructor(opts: HandleOpts);
+  dispose(): void;
+  serialize(): {
+    childId: number | null | undefined;
+    id: number;
+  };
+  static deserialize(opts: HandleOpts): Handle;
+}

package/lib/Handle.d.ts

@@ -0,0 +1,19 @@
+export type HandleFunction = (...args: Array<any>) => any;
+type HandleOpts = {
+    fn?: HandleFunction;
+    childId?: number | null | undefined;
+    id?: number;
+};
+export default class Handle {
+    id: number;
+    childId: number | null | undefined;
+    fn: HandleFunction | null | undefined;
+    constructor(opts: HandleOpts);
+    dispose(): void;
+    serialize(): {
+        childId: number | null | undefined;
+        id: number;
+    };
+    static deserialize(opts: HandleOpts): Handle;
+}
+export {};

package/lib/Handle.js

@@ -13,10 +13,7 @@ function _buildCache() {
 }
 var _package = _interopRequireDefault(require("../package.json"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// $FlowFixMe
 let HANDLE_ID = 0;
-// $FlowFixMe
-
 const handleById = new Map();
 class Handle {
   constructor(opts) {

package/lib/Worker.d.ts

@@ -0,0 +1,40 @@
+import type { FilePath } from '@atlaspack/types-internal';
+import type { BackendType, WorkerImpl, WorkerMessage } from './types';
+import type { SharedReference } from './WorkerFarm';
+import EventEmitter from 'events';
+export type WorkerCall = {
+    method?: string;
+    handle?: number;
+    args: ReadonlyArray<any>;
+    retries: number;
+    skipReadyCheck?: boolean;
+    resolve: (result: Promise<any> | any) => void;
+    reject: (error?: any) => void;
+};
+type WorkerOpts = {
+    forcedKillTime: number;
+    backend: BackendType;
+    shouldPatchConsole?: boolean;
+    shouldTrace?: boolean;
+    sharedReferences: ReadonlyMap<SharedReference, unknown>;
+};
+export default class Worker extends EventEmitter {
+    readonly options: WorkerOpts;
+    worker: WorkerImpl;
+    id: number;
+    sentSharedReferences: Set<SharedReference>;
+    calls: Map<number, WorkerCall>;
+    exitCode: number | null | undefined;
+    callId: number;
+    ready: boolean;
+    stopped: boolean;
+    isStopping: boolean;
+    constructor(options: WorkerOpts);
+    fork(forkModule: FilePath): Promise<void>;
+    sendSharedReference(ref: SharedReference, value: unknown): Promise<any>;
+    send(data: WorkerMessage): void;
+    call(call: WorkerCall): void;
+    receive(message: WorkerMessage): void;
+    stop(): Promise<void>;
+}
+export {};

package/lib/Worker.js

@@ -29,6 +29,8 @@ var _backend = require("./backend");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 let WORKER_ID = 0;
 class Worker extends _events().default {
+  // @ts-expect-error TS2564
+
   id = WORKER_ID++;
   sentSharedReferences = new Set();
   calls = new Map();
@@ -105,7 +107,9 @@ class Worker extends _events().default {
     let refsShared = new Set();
     // in case more refs are created while initial refs are sending
     while (refsShared.size < sharedRefs.size) {
-      await Promise.all([...sharedRefs].filter(([ref]) => !refsShared.has(ref)).map(async ([ref, value]) => {
+      await Promise.all([...sharedRefs]
+      // @ts-expect-error TS2769
+      .filter(([ref]) => !refsShared.has(ref)).map(async ([ref, value]) => {
         await this.sendSharedReference(ref, value);
         refsShared.add(ref);
       }));
@@ -144,8 +148,10 @@ class Worker extends _events().default {
       args: call.args
     };
     if (this.ready || call.skipReadyCheck === true) {
+      // @ts-expect-error TS2345
       this.send(msg);
     } else {
+      // @ts-expect-error TS2345
       this.once('ready', () => this.send(msg));
     }
   }

package/lib/WorkerFarm.d.ts

@@ -0,0 +1,93 @@
+import type { ErrorWithCode, FilePath } from '@atlaspack/types-internal';
+import type { CallRequest, HandleCallRequest, WorkerRequest, BackendType } from './types';
+import type { HandleFunction } from './Handle';
+import EventEmitter from 'events';
+import Worker, { WorkerCall } from './Worker';
+import Handle from './Handle';
+import { SamplingProfiler } from '@atlaspack/profiler';
+export type SharedReference = number;
+export type FarmOptions = {
+    maxConcurrentWorkers: number;
+    maxConcurrentCallsPerWorker: number;
+    forcedKillTime: number;
+    useLocalWorker: boolean;
+    warmWorkers: boolean;
+    workerPath?: FilePath;
+    backend: BackendType;
+    shouldPatchConsole?: boolean;
+    shouldTrace?: boolean;
+};
+type WorkerModule = {
+    readonly [key: string]: (...args: Array<unknown>) => Promise<unknown>;
+};
+export type WorkerApi = {
+    callMaster(arg1: CallRequest, arg2?: boolean | null | undefined): Promise<unknown>;
+    createReverseHandle(fn: HandleFunction): Handle;
+    getSharedReference(ref: SharedReference): unknown;
+    resolveSharedReference(value: unknown): SharedReference | null | undefined;
+    callChild?: (childId: number, request: HandleCallRequest) => Promise<unknown>;
+};
+export { Handle };
+/**
+ * workerPath should always be defined inside farmOptions
+ */
+export default class WorkerFarm extends EventEmitter {
+    callQueue: Array<WorkerCall>;
+    ending: boolean;
+    localWorker: WorkerModule;
+    localWorkerInit: Promise<undefined> | null | undefined;
+    options: FarmOptions;
+    run: HandleFunction;
+    warmWorkers: number;
+    readyWorkers: number;
+    workers: Map<number, Worker>;
+    handles: Map<number, Handle>;
+    sharedReferences: Map<SharedReference, unknown>;
+    sharedReferencesByValue: Map<unknown, SharedReference>;
+    serializedSharedReferences: Map<SharedReference, ArrayBuffer | null | undefined>;
+    profiler: SamplingProfiler | null | undefined;
+    constructor(farmOptions?: Partial<FarmOptions>);
+    workerApi: {
+        callChild: (childId: number, request: HandleCallRequest) => Promise<unknown>;
+        callMaster: (request: CallRequest, awaitResponse?: boolean | null | undefined) => Promise<unknown>;
+        createReverseHandle: (fn: HandleFunction) => Handle;
+        getSharedReference: (ref: SharedReference) => unknown;
+        resolveSharedReference: (value: unknown) => undefined | SharedReference;
+        runHandle: (handle: Handle, args: Array<any>) => Promise<unknown>;
+    };
+    warmupWorker(method: string, args: Array<any>): void;
+    shouldStartRemoteWorkers(): boolean;
+    createHandle(method: string, useMainThread?: boolean): HandleFunction;
+    onError(error: ErrorWithCode, worker: Worker): undefined | Promise<undefined>;
+    startChild(): void;
+    stopWorker(worker: Worker): Promise<void>;
+    processQueue(): void;
+    callWorker(worker: Worker, call: WorkerCall): Promise<void>;
+    processRequest(data: {
+        location: FilePath;
+    } & Partial<WorkerRequest>, worker?: Worker): Promise<string | null | undefined>;
+    addCall(method: string, args: Array<any>): Promise<any>;
+    end(): Promise<void>;
+    startMaxWorkers(): void;
+    shouldUseRemoteWorkers(): boolean;
+    createReverseHandle(fn: HandleFunction): Handle;
+    createSharedReference(value: unknown, isCacheable?: boolean): {
+        ref: SharedReference;
+        dispose(): Promise<unknown>;
+    };
+    getSerializedSharedReference(ref: SharedReference): ArrayBuffer;
+    startProfile(): Promise<void>;
+    endProfile(): Promise<void>;
+    callAllWorkers(method: string, args: Array<any>): Promise<void>;
+    takeHeapSnapshot(): Promise<void>;
+    static getNumWorkers(): number;
+    static isWorker(): boolean;
+    static getWorkerApi(): {
+        callMaster: (request: CallRequest, awaitResponse?: boolean | null | undefined) => Promise<unknown>;
+        createReverseHandle: (fn: (...args: Array<any>) => unknown) => Handle;
+        getSharedReference: (ref: SharedReference) => unknown;
+        resolveSharedReference: (value: unknown) => undefined | SharedReference;
+        runHandle: (handle: Handle, args: Array<any>) => Promise<unknown>;
+    };
+    static getConcurrentCallsPerWorker(defaultValue?: number): number;
+}

package/lib/WorkerFarm.js

@@ -108,9 +108,9 @@ class WorkerFarm extends _events().default {
     if (!this.options.workerPath) {
       throw new Error('Please provide a worker path!');
     }
-
-    // $FlowFixMe
     this.localWorker = require(this.options.workerPath);
+
+    // @ts-expect-error TS2322
     this.localWorkerInit = this.localWorker.childInit != null ? this.localWorker.childInit() : null;
     this.run = this.createHandle('run');
 
@@ -127,9 +127,9 @@ class WorkerFarm extends _events().default {
   }
   workerApi = {
     callMaster: async (request, awaitResponse = true) => {
-      // $FlowFixMe
       let result = await this.processRequest({
         ...request,
+        // @ts-expect-error TS2322
         awaitResponse
       });
       return (0, _buildCache().deserialize)((0, _buildCache().serialize)(result));
@@ -203,6 +203,7 @@ class WorkerFarm extends _events().default {
   onError(error, worker) {
     // Handle ipc errors
     if (error.code === 'ERR_IPC_CHANNEL_CLOSED') {
+      // @ts-expect-error TS2322
       return this.stopWorker(worker);
     } else {
       _logger().default.error(error, '@atlaspack/workers');
@@ -261,6 +262,7 @@ class WorkerFarm extends _events().default {
         continue;
       }
       if (worker.calls.size < this.options.maxConcurrentCallsPerWorker) {
+        // @ts-expect-error TS2345
         this.callWorker(worker, this.callQueue.shift());
       }
     }
@@ -287,7 +289,7 @@ class WorkerFarm extends _events().default {
       var _this$handles$get;
       mod = (0, _nullthrows().default)((_this$handles$get = this.handles.get(handleId)) === null || _this$handles$get === void 0 ? void 0 : _this$handles$get.fn);
     } else if (location) {
-      // $FlowFixMe
+      // @ts-expect-error TS2339
       if (process.browser) {
         if (location === '@atlaspack/workers/bus') {
           mod = bus;
@@ -295,7 +297,6 @@ class WorkerFarm extends _events().default {
           throw new Error('No dynamic require possible: ' + location);
         }
       } else {
-        // $FlowFixMe this must be dynamic
         mod = require(location);
       }
     } else {
@@ -316,6 +317,7 @@ class WorkerFarm extends _events().default {
     let result;
     if (method == null) {
       try {
+        // @ts-expect-error TS2488
         result = responseFromContent(await mod(...args));
       } catch (e) {
         result = errorResponseFromError(e);
@@ -326,7 +328,6 @@ class WorkerFarm extends _events().default {
         mod = mod.default;
       }
       try {
-        // $FlowFixMe
         result = responseFromContent(await mod[method](...args));
       } catch (e) {
         result = errorResponseFromError(e);
@@ -435,8 +436,11 @@ class WorkerFarm extends _events().default {
     // If the reference was created with the isCacheable option set to false,
     // serializedSharedReferences will contain `null` as the value.
     if (cached !== null) {
+      // @ts-expect-error TS2345
       this.serializedSharedReferences.set(ref, buf);
     }
+
+    // @ts-expect-error TS2322
     return buf;
   }
   async startProfile() {
@@ -481,6 +485,7 @@ class WorkerFarm extends _events().default {
     let filename = `profile-${getTimeId()}.trace`;
     let stream = trace.pipe(_fs().default.createWriteStream(filename));
     for (let profile of profiles) {
+      // @ts-expect-error TS2345
       trace.addCPUProfile(names.shift(), profile);
     }
     trace.flush();
@@ -489,6 +494,7 @@ class WorkerFarm extends _events().default {
     });
     _logger().default.info({
       origin: '@atlaspack/workers',
+      // @ts-expect-error TS2345
       message: (0, _diagnostic().md)`Wrote profile to ${filename}`
     });
   }
@@ -523,6 +529,7 @@ class WorkerFarm extends _events().default {
       })));
       _logger().default.info({
         origin: '@atlaspack/workers',
+        // @ts-expect-error TS2345
         message: (0, _diagnostic().md)`Wrote heap snapshots to the following paths:\n${snapshotPaths.join('\n')}`
       });
     } catch {
@@ -543,7 +550,10 @@ class WorkerFarm extends _events().default {
     return _childState.child.workerApi;
   }
   static getConcurrentCallsPerWorker(defaultValue = DEFAULT_MAX_CONCURRENT_CALLS) {
-    return parseInt(process.env.ATLASPACK_MAX_CONCURRENT_CALLS, 10) || defaultValue;
+    return (
+      // @ts-expect-error TS2345
+      parseInt(process.env.ATLASPACK_MAX_CONCURRENT_CALLS, 10) || defaultValue
+    );
   }
 }
 exports.default = WorkerFarm;

package/lib/backend.d.ts

@@ -0,0 +1,4 @@
+import type { BackendType, WorkerImpl } from './types';
+export type Class<T> = new (...args: any[]) => T;
+export declare function detectBackend(): BackendType;
+export declare function getWorkerBackend(backend: BackendType): Class<WorkerImpl>;

package/lib/backend.js

@@ -5,8 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.detectBackend = detectBackend;
 exports.getWorkerBackend = getWorkerBackend;
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
+
 function detectBackend() {
-  // $FlowFixMe
+  // @ts-expect-error TS2339
   if (process.browser) return 'web';
   switch (process.env.ATLASPACK_WORKER_BACKEND) {
     case 'threads':

package/lib/bus.d.ts

@@ -0,0 +1,6 @@
+import EventEmitter from 'events';
+declare class Bus extends EventEmitter {
+    emit(event: string, ...args: Array<any>): boolean;
+}
+declare const _default: Bus;
+export default _default;

package/lib/bus.js

@@ -17,7 +17,7 @@ class Bus extends _events().default {
   emit(event, ...args) {
     if (_childState.child) {
       _childState.child.workerApi.callMaster({
-        // $FlowFixMe
+        // @ts-expect-error TS2339
         location: process.browser ? '@atlaspack/workers/bus' : __filename,
         method: 'emit',
         args: [event, ...args]