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

package/src/requests/WriteBundleRequest.ts

@@ -0,0 +1,734 @@
+import type {FileSystem, FileOptions} from '@atlaspack/fs';
+import type {ContentKey} from '@atlaspack/graph';
+import type {Async, FilePath, Compressor} from '@atlaspack/types';
+
+import type {RunAPI, StaticRunOpts} from '../RequestTracker';
+import type {Bundle, PackagedBundleInfo, AtlaspackOptions} from '../types';
+import type BundleGraph from '../BundleGraph';
+import type {BundleInfo} from '../PackagerRunner';
+import type {ConfigAndCachePath} from './AtlaspackConfigRequest';
+import type {LoadedPlugin} from '../AtlaspackConfig';
+import type {ProjectPath} from '../projectPath';
+
+import {HASH_REF_HASH_LEN, HASH_REF_PREFIX} from '../constants';
+import nullthrows from 'nullthrows';
+import path from 'path';
+import url from 'url';
+import {NamedBundle} from '../public/Bundle';
+import {blobToStream, TapStream} from '@atlaspack/utils';
+import {Readable, Transform, pipeline} from 'stream';
+import {
+  fromProjectPath,
+  fromProjectPathRelative,
+  toProjectPath,
+  joinProjectPath,
+  toProjectPathUnsafe,
+} from '../projectPath';
+import createAtlaspackConfigRequest, {
+  getCachedAtlaspackConfig,
+} from './AtlaspackConfigRequest';
+import PluginOptions from '../public/PluginOptions';
+import {PluginLogger} from '@atlaspack/logger';
+import {
+  getDevDepRequests,
+  invalidateDevDeps,
+  createDevDependency,
+  runDevDepRequest,
+} from './DevDepRequest';
+import {AtlaspackConfig} from '../AtlaspackConfig';
+import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
+import {PluginTracer, tracer} from '@atlaspack/profiler';
+import {requestTypes} from '../RequestTracker';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {fromEnvironmentId} from '../EnvironmentManager';
+import SourceMap, {decodeVLQ, encodeVLQ} from '@atlaspack/source-map';
+
+const HASH_REF_PREFIX_LEN = HASH_REF_PREFIX.length;
+const BOUNDARY_LENGTH = HASH_REF_PREFIX.length + 32 - 1;
+const HASH_REF_PLACEHOLDER_LEN = HASH_REF_PREFIX_LEN + HASH_REF_HASH_LEN;
+
+// The JSON key prefix we scan for in the source map stream.
+const MAPPINGS_KEY_BUF = Buffer.from('"mappings":"');
+
+export type HashRefReplacement = {
+  line: number;
+  column: number;
+  originalLength: number;
+  newLength: number;
+};
+
+type WriteBundleRequestInput = {
+  bundleGraph: BundleGraph;
+  bundle: Bundle;
+  info: BundleInfo;
+  hashRefToNameHash: Map<string, string>;
+};
+
+export type WriteBundleRequestResult = PackagedBundleInfo;
+
+type RunInput<TResult> = {
+  input: WriteBundleRequestInput;
+} & StaticRunOpts<TResult>;
+
+export type WriteBundleRequest = {
+  id: ContentKey;
+  readonly type: typeof requestTypes.write_bundle_request;
+  run: (arg1: RunInput<PackagedBundleInfo>) => Async<PackagedBundleInfo>;
+  input: WriteBundleRequestInput;
+};
+
+/**
+ * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
+ */
+export default function createWriteBundleRequest(
+  input: WriteBundleRequestInput,
+): WriteBundleRequest {
+  let name = nullthrows(input.bundle.name);
+  let nameHash = nullthrows(
+    input.hashRefToNameHash.get(input.bundle.hashReference),
+  );
+  return {
+    id: `${input.bundle.id}:${input.info.hash}:${nameHash}:${name}`,
+    type: requestTypes.write_bundle_request,
+    run,
+    input,
+  };
+}
+
+// @ts-expect-error TS7031
+async function run({input, options, api}) {
+  let {bundleGraph, bundle, info, hashRefToNameHash} = input;
+  let {inputFS, outputFS} = options;
+  let name = nullthrows(bundle.name);
+  let thisHashReference = bundle.hashReference;
+
+  if (info.type !== bundle.type) {
+    name = name.slice(0, -path.extname(name).length) + '.' + info.type;
+  }
+
+  if (name.includes(thisHashReference)) {
+    let thisNameHash = nullthrows(hashRefToNameHash.get(thisHashReference));
+    name = name.replace(thisHashReference, thisNameHash);
+  }
+
+  let filePath = joinProjectPath(bundle.target.distDir, name);
+
+  // Watch the bundle and source map for deletion.
+  // Also watch the dist dir because invalidateOnFileDelete does not currently
+  // invalidate when a parent directory is deleted.
+  // TODO: do we want to also watch for file edits?
+  api.invalidateOnFileDelete(bundle.target.distDir);
+  api.invalidateOnFileDelete(filePath);
+
+  let cacheKeys = info.cacheKeys;
+  let mapKey = cacheKeys.map;
+  let fullPath = fromProjectPath(options.projectRoot, filePath);
+  const env = fromEnvironmentId(bundle.env);
+
+  if (mapKey && env.sourceMap && !env.sourceMap.inline) {
+    api.invalidateOnFileDelete(
+      toProjectPath(options.projectRoot, fullPath + '.map'),
+    );
+  }
+
+  let dir = path.dirname(fullPath);
+  await outputFS.mkdirp(dir); // ? Got rid of dist exists, is this an expensive operation
+
+  // Use the file mode from the entry asset as the file mode for the bundle.
+  // Don't do this for browser builds, as the executable bit in particular is unnecessary.
+  let publicBundle = NamedBundle.get(bundle, bundleGraph, options);
+  let mainEntry = publicBundle.getMainEntry();
+  let writeOptions =
+    publicBundle.env.isBrowser() || !mainEntry
+      ? undefined
+      : {
+          mode: (await inputFS.stat(mainEntry.filePath)).mode,
+        };
+  let contentStream: Readable;
+  if (info.isLargeBlob) {
+    contentStream = options.cache.getStream(cacheKeys.content);
+  } else {
+    contentStream = blobToStream(
+      await options.cache.getBlob(cacheKeys.content),
+    );
+  }
+  let size = 0;
+  contentStream = contentStream.pipe(
+    // @ts-expect-error TS2554
+    new TapStream((buf: Buffer) => {
+      size += buf.length;
+    }),
+  );
+
+  let configResult = nullthrows(
+    // @ts-expect-error TS2347
+    await api.runRequest<null, ConfigAndCachePath>(
+      createAtlaspackConfigRequest(),
+    ),
+  );
+  let config = getCachedAtlaspackConfig(configResult, options);
+
+  let {devDeps, invalidDevDeps} = await getDevDepRequests(api);
+  invalidateDevDeps(invalidDevDeps, options, config);
+
+  const bundleReplacements = getFeatureFlag('fixSourceMapHashRefs')
+    ? []
+    : undefined;
+  await writeFiles(
+    contentStream,
+    info,
+    hashRefToNameHash,
+    options,
+    config,
+    outputFS,
+    filePath,
+    writeOptions,
+    devDeps,
+    api,
+    bundleReplacements,
+  );
+
+  const hasSourceMap = await options.cache.has(mapKey);
+  if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
+    const mapEntry = await options.cache.getBlob(mapKey);
+    let mapStream: Readable;
+    if (
+      getFeatureFlag('fixSourceMapHashRefs') &&
+      bundleReplacements &&
+      bundleReplacements.length > 0
+    ) {
+      mapStream = blobToStream(mapEntry).pipe(
+        new SourceMapHashRefRewriteStream(bundleReplacements),
+      );
+    } else {
+      mapStream = blobToStream(mapEntry);
+    }
+    await writeFiles(
+      mapStream,
+      info,
+      hashRefToNameHash,
+      options,
+      config,
+      outputFS,
+      toProjectPathUnsafe(fromProjectPathRelative(filePath) + '.map'),
+      writeOptions,
+      devDeps,
+      api,
+    );
+  }
+
+  let res = {
+    filePath,
+    bundleId: bundle.id,
+    type: info.type,
+    stats: {
+      size,
+      time: info.time ?? 0,
+    },
+  };
+
+  api.storeResult(res);
+  return res;
+}
+
+export function applyReplacementsToSourceMap(
+  sourceMap: SourceMap,
+  replacements: HashRefReplacement[],
+): void {
+  if (replacements.length === 0) return;
+  const sorted = [...replacements].sort(
+    (a, b) => a.line - b.line || a.column - b.column,
+  );
+  for (const r of sorted) {
+    const delta = r.newLength - r.originalLength;
+    if (delta !== 0) {
+      // r.column is in post-replacement coordinates (matching the already-shifted
+      // source map state after previous offsetColumns calls). The end of the
+      // placeholder in these coordinates is simply r.column + r.originalLength.
+      const offsetStartColumn = r.column + r.originalLength;
+      const line1Based = r.line + 1;
+      if (line1Based >= 1 && offsetStartColumn + delta >= 0) {
+        sourceMap.offsetColumns(line1Based, offsetStartColumn, delta);
+      }
+    }
+  }
+}
+
+/**
+ * Applies hash-ref replacement column offsets directly to a VLQ mappings
+ * string without deserializing the full source map into a native struct.
+ *
+ * Each replacement r describes a hash-ref that was substituted in the output
+ * file.  r.column is in the progressively-shifted post-replacement coordinate
+ * space (matching the already-shifted source map state after all previous
+ * offsetColumns calls), so thresholds are applied sequentially against the
+ * running absCol values exactly as the native offsetColumns implementation does.
+ */
+export function applyReplacementsToVLQMappings(
+  mappings: string,
+  replacements: HashRefReplacement[],
+): string {
+  if (replacements.length === 0) return mappings;
+
+  // Group replacements by line (0-indexed), sorted by column ascending.
+  const byLine = new Map<number, HashRefReplacement[]>();
+  for (const r of replacements) {
+    let arr = byLine.get(r.line);
+    if (!arr) {
+      arr = [];
+      byLine.set(r.line, arr);
+    }
+    arr.push(r);
+  }
+  for (const arr of byLine.values()) {
+    arr.sort((a, b) => a.column - b.column);
+  }
+
+  const lines = mappings.split(';');
+  const resultLines: string[] = [];
+
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const lineReps = byLine.get(lineIdx);
+    if (!lineReps || lineReps.length === 0) {
+      resultLines.push(lines[lineIdx]);
+      continue;
+    }
+
+    const line = lines[lineIdx];
+    if (!line) {
+      resultLines.push('');
+      continue;
+    }
+
+    // Decode segment column deltas to absolute columns.
+    const segments = line.split(',');
+    const colVlqEnds: number[] = [];
+    const absCols: number[] = [];
+    let absCol = 0;
+    for (const seg of segments) {
+      const {value: colDelta, nextPos} = decodeVLQ(seg, 0);
+      absCol += colDelta;
+      colVlqEnds.push(nextPos);
+      absCols.push(absCol);
+    }
+
+    // Apply each replacement's column shift sequentially against the
+    // current absCol values (which have already been adjusted by previous
+    // replacements on this line), mirroring the sequential offsetColumns calls.
+    for (const r of lineReps) {
+      const delta = r.newLength - r.originalLength;
+      if (delta === 0) continue;
+      const threshold = r.column + r.originalLength;
+      for (let i = 0; i < absCols.length; i++) {
+        if (absCols[i] >= threshold) {
+          absCols[i] += delta;
+        }
+      }
+    }
+
+    // Re-encode with updated absolute columns; only the leading column VLQ
+    // field of each segment changes – the tail bytes are sliced unchanged.
+    const resultSegments: string[] = [];
+    let prevAbsCol = 0;
+    for (let i = 0; i < segments.length; i++) {
+      const newDelta = absCols[i] - prevAbsCol;
+      prevAbsCol = absCols[i];
+      resultSegments.push(
+        encodeVLQ(newDelta) + segments[i].slice(colVlqEnds[i]),
+      );
+    }
+
+    resultLines.push(resultSegments.join(','));
+  }
+
+  return resultLines.join(';');
+}
+
+type StreamState = 'scanning' | 'buffering' | 'passthrough';
+
+/**
+ * A Transform stream that rewrites the "mappings" VLQ field of a source map
+ * JSON to account for hash-ref replacements, without ever loading the full
+ * JSON object or the native Rust SourceMapInner into memory.
+ *
+ * Field order in cached source maps (from partialVlqMapToSourceMap / toVLQ):
+ *   mappings → sources → sourcesContent → names → version → file → sourceRoot
+ *
+ * "mappings" is the very first field, so we scan only a tiny header before
+ * switching to zero-copy passthrough for the bulk sourcesContent bytes.
+ */
+export class SourceMapHashRefRewriteStream extends Transform {
+  private replacements: HashRefReplacement[];
+  private state: StreamState;
+  private scanBuf: Buffer;
+  private mappingsBufs: Buffer[];
+
+  constructor(replacements: HashRefReplacement[]) {
+    super();
+    this.replacements = replacements;
+    this.state = 'scanning';
+    this.scanBuf = Buffer.alloc(0);
+    this.mappingsBufs = [];
+  }
+
+  // @ts-expect-error TS7006
+  _transform(chunk: Buffer, _encoding: string, cb): void {
+    if (this.state === 'passthrough') {
+      this.push(chunk);
+      cb();
+      return;
+    }
+
+    if (this.state === 'scanning') {
+      const combined = Buffer.concat([this.scanBuf, chunk]);
+      const idx = combined.indexOf(MAPPINGS_KEY_BUF);
+
+      if (idx === -1) {
+        // Key not yet found – hold back enough bytes to handle a split key.
+        const keepLen = Math.min(combined.length, MAPPINGS_KEY_BUF.length - 1);
+        if (combined.length > keepLen) {
+          this.push(combined.slice(0, combined.length - keepLen));
+        }
+        this.scanBuf = combined.slice(combined.length - keepLen);
+        cb();
+        return;
+      }
+
+      // Emit everything up to and including the key.
+      const keyEnd = idx + MAPPINGS_KEY_BUF.length;
+      this.push(combined.slice(0, keyEnd));
+      this.scanBuf = Buffer.alloc(0);
+      this.state = 'buffering';
+      this._bufferingTransform(combined.slice(keyEnd), cb);
+      return;
+    }
+
+    // state === 'buffering'
+    this._bufferingTransform(chunk, cb);
+  }
+
+  // @ts-expect-error TS7006
+  private _bufferingTransform(chunk: Buffer, cb): void {
+    // Mappings values contain only base64 chars, ';', and ',' – no escaping –
+    // so scanning for the closing '"' (0x22) is safe.
+    const closeIdx = chunk.indexOf(0x22);
+
+    if (closeIdx === -1) {
+      this.mappingsBufs.push(chunk);
+      cb();
+      return;
+    }
+
+    this.mappingsBufs.push(chunk.slice(0, closeIdx));
+
+    // VLQ chars are all ASCII (<128), so latin1 round-trips without loss.
+    const mappingsStr = Buffer.concat(this.mappingsBufs).toString('latin1');
+    const rewritten = applyReplacementsToVLQMappings(
+      mappingsStr,
+      this.replacements,
+    );
+    this.push(Buffer.from(rewritten, 'latin1'));
+
+    // Emit the closing '"' and everything remaining in one push.
+    this.push(chunk.slice(closeIdx));
+
+    this.state = 'passthrough';
+    this.mappingsBufs = [];
+    cb();
+  }
+
+  // @ts-expect-error TS7006
+  _flush(cb): void {
+    if (this.state === 'scanning' && this.scanBuf.length > 0) {
+      this.push(this.scanBuf);
+    } else if (this.state === 'buffering') {
+      // Malformed JSON – flush whatever we buffered as-is.
+      this.push(Buffer.concat(this.mappingsBufs));
+    }
+    cb();
+  }
+}
+
+/**
+ * Computes the sourceRoot for a source map file. This is the relative path from
+ * the output directory back to the project root, so that source paths (stored
+ * relative to projectRoot) resolve correctly from the .map file location.
+ *
+ * Returns undefined when sources are inlined (inlineSources), since the browser
+ * doesn't need to fetch them and sourceRoot would be unnecessary.
+ *
+ * This logic must stay in sync with PackagerRunner.generateSourceMap.
+ */
+export function computeSourceMapRoot(
+  bundle: Bundle,
+  options: AtlaspackOptions,
+): string | undefined {
+  let name = nullthrows(bundle.name);
+  let filePath = joinProjectPath(bundle.target.distDir, name);
+  let fullPath = fromProjectPath(options.projectRoot, filePath);
+  let sourceRoot: string = path.relative(
+    path.dirname(fullPath),
+    options.projectRoot,
+  );
+
+  let inlineSources = false;
+
+  const bundleEnv = fromEnvironmentId(bundle.env);
+  if (bundle.target) {
+    const bundleTargetEnv = fromEnvironmentId(bundle.target.env);
+
+    if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
+      sourceRoot = bundleEnv.sourceMap.sourceRoot;
+    } else if (options.serveOptions && bundleTargetEnv.context === 'browser') {
+      sourceRoot = '/__parcel_source_root';
+    }
+
+    if (
+      bundleEnv.sourceMap &&
+      bundleEnv.sourceMap.inlineSources !== undefined
+    ) {
+      inlineSources = bundleEnv.sourceMap.inlineSources;
+    } else if (bundleTargetEnv.context !== 'node') {
+      inlineSources = options.mode === 'production';
+    }
+  }
+
+  let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
+
+  if (getFeatureFlag('omitSourcesContentInMemory') && !isInlineMap) {
+    if (!(bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources === false)) {
+      inlineSources = true;
+    }
+  }
+
+  if (inlineSources) {
+    return undefined;
+  }
+
+  return url.format(url.parse(sourceRoot + '/'));
+}
+
+async function writeFiles(
+  // @ts-expect-error TS2503
+  inputStream: stream.Readable,
+  info: BundleInfo,
+  hashRefToNameHash: Map<string, string>,
+  options: AtlaspackOptions,
+  config: AtlaspackConfig,
+  outputFS: FileSystem,
+  filePath: ProjectPath,
+  writeOptions: FileOptions | null | undefined,
+  devDeps: Map<string, string>,
+  api: RunAPI<PackagedBundleInfo>,
+  bundleReplacements?: HashRefReplacement[],
+) {
+  let compressors = await config.getCompressors(
+    fromProjectPathRelative(filePath),
+  );
+  let fullPath = fromProjectPath(options.projectRoot, filePath);
+
+  let stream = info.hashReferences.length
+    ? inputStream.pipe(replaceStream(hashRefToNameHash, bundleReplacements))
+    : inputStream;
+
+  let promises: Array<Promise<undefined>> = [];
+  for (let compressor of compressors) {
+    promises.push(
+      // @ts-expect-error TS2345
+      runCompressor(
+        compressor,
+        cloneStream(stream),
+        options,
+        outputFS,
+        fullPath,
+        writeOptions,
+        devDeps,
+        api,
+      ),
+    );
+  }
+
+  await Promise.all(promises);
+}
+
+async function runCompressor(
+  compressor: LoadedPlugin<Compressor>,
+  // @ts-expect-error TS2503
+  stream: stream.Readable,
+  options: AtlaspackOptions,
+  outputFS: FileSystem,
+  filePath: FilePath,
+  writeOptions: FileOptions | null | undefined,
+  devDeps: Map<string, string>,
+  api: RunAPI<PackagedBundleInfo>,
+) {
+  let measurement;
+  try {
+    measurement = tracer.createMeasurement(
+      compressor.name,
+      'compress',
+      path.relative(options.projectRoot, filePath),
+    );
+    let res = await compressor.plugin.compress({
+      stream,
+      options: new PluginOptions(options),
+      logger: new PluginLogger({origin: compressor.name}),
+      tracer: new PluginTracer({origin: compressor.name, category: 'compress'}),
+    });
+
+    if (res != null) {
+      await new Promise(
+        (
+          resolve: (result: Promise<undefined> | undefined) => void,
+          reject: (error?: any) => void,
+        ) =>
+          pipeline(
+            res.stream,
+            outputFS.createWriteStream(
+              filePath + (res.type != null ? '.' + res.type : ''),
+              writeOptions,
+            ),
+            (err) => {
+              if (err) reject(err);
+              // @ts-expect-error TS2794
+              else resolve();
+            },
+          ),
+      );
+    }
+  } catch (err: any) {
+    throw new ThrowableDiagnostic({
+      diagnostic: errorToDiagnostic(err, {
+        origin: compressor.name,
+      }),
+    });
+  } finally {
+    measurement && measurement.end();
+    // Add dev deps for compressor plugins AFTER running them, to account for lazy require().
+    let devDepRequest = await createDevDependency(
+      {
+        specifier: compressor.name,
+        resolveFrom: compressor.resolveFrom,
+      },
+      devDeps,
+      options,
+    );
+    await runDevDepRequest(api, devDepRequest);
+  }
+}
+
+function advanceLineColumn(
+  line: number,
+  column: number,
+  buf: Buffer,
+): {line: number; column: number} {
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] === 0x0a) {
+      line++;
+      column = 0;
+    } else {
+      column++;
+    }
+  }
+  return {line, column};
+}
+
+function replaceStream(
+  hashRefToNameHash: Map<string, string>,
+  replacements?: HashRefReplacement[],
+) {
+  let boundaryStr = Buffer.alloc(0);
+  let replaced = Buffer.alloc(0);
+  let outputLine = 0;
+  let outputColumn = 0;
+  return new Transform({
+    transform(
+      chunk: Buffer | string,
+      encoding: string,
+      cb: (
+        error?: Error | null | undefined,
+        data?: Buffer | string | null | undefined,
+      ) => void,
+    ) {
+      let str = Buffer.concat([boundaryStr, Buffer.from(chunk)]);
+      let lastMatchI = 0;
+      if (replaced.length < str.byteLength) {
+        replaced = Buffer.alloc(str.byteLength);
+      }
+      let replacedLength = 0;
+
+      while (lastMatchI < str.byteLength) {
+        let matchI = str.indexOf(HASH_REF_PREFIX, lastMatchI);
+        if (matchI === -1) {
+          replaced.set(
+            str.subarray(lastMatchI, str.byteLength),
+            replacedLength,
+          );
+          replacedLength += str.byteLength - lastMatchI;
+          break;
+        } else {
+          let match = str
+            .subarray(matchI, matchI + HASH_REF_PREFIX_LEN + HASH_REF_HASH_LEN)
+            .toString();
+          let replacement = Buffer.from(hashRefToNameHash.get(match) ?? match);
+          // Copy pre-match content FIRST so position calculation includes it
+          replaced.set(str.subarray(lastMatchI, matchI), replacedLength);
+          replacedLength += matchI - lastMatchI;
+          if (replacements) {
+            const pos = advanceLineColumn(
+              outputLine,
+              outputColumn,
+              replaced.subarray(0, replacedLength),
+            );
+            replacements.push({
+              line: pos.line,
+              column: pos.column,
+              originalLength: HASH_REF_PLACEHOLDER_LEN,
+              newLength: replacement.byteLength,
+            });
+          }
+          replaced.set(replacement, replacedLength);
+          replacedLength += replacement.byteLength;
+          lastMatchI = matchI + HASH_REF_PREFIX_LEN + HASH_REF_HASH_LEN;
+        }
+      }
+
+      const pushLen = replacedLength - BOUNDARY_LENGTH;
+      const pushed = advanceLineColumn(
+        outputLine,
+        outputColumn,
+        replaced.subarray(0, pushLen),
+      );
+      outputLine = pushed.line;
+      outputColumn = pushed.column;
+
+      boundaryStr = replaced.subarray(
+        replacedLength - BOUNDARY_LENGTH,
+        replacedLength,
+      );
+      let strUpToBoundary = replaced.subarray(0, pushLen);
+      cb(null, strUpToBoundary);
+    },
+
+    flush(
+      cb: (
+        error?: Error | null | undefined,
+        data?: Buffer | string | null | undefined,
+      ) => void,
+    ) {
+      cb(null, boundaryStr);
+    },
+  });
+}
+
+// @ts-expect-error TS2503
+function cloneStream(readable: stream.Readable | stream.Transform) {
+  let res = new Readable();
+  res._read = () => {};
+  // @ts-expect-error TS7006
+  readable.on('data', (chunk) => res.push(chunk));
+  readable.on('end', () => res.push(null));
+  // @ts-expect-error TS7006
+  readable.on('error', (err) => res.emit('error', err));
+  return res;
+}