rn-update-cli 1.0.0

package/lib/utils/runtime.d.ts

@@ -0,0 +1,54 @@
+/**
+ * [INPUT]: 依赖 Node/Bun 子进程、HTTP agent、代理环境变量与包管理器运行时布局
+ * [OUTPUT]: 对外提供代理感知请求、网络延迟探测、包管理器/JavaScript runtime 选择及进程启动函数
+ * [POS]: CLI 跨运行时基础设施，统一网络和子进程行为，供 API、bundle 与安装命令复用
+ */
+import { type ChildProcessWithoutNullStreams, type SpawnOptionsWithoutStdio, type SpawnSyncOptions } from 'child_process';
+import type { Agent as HttpAgent } from 'http';
+export type RuntimeRequestInit = {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: any;
+    signal?: AbortSignal;
+};
+export type RuntimeResponse = {
+    status: number;
+    statusText: string;
+    text: () => Promise<string>;
+};
+export type PackageManager = 'bun' | 'npm' | 'pnpm' | 'yarn';
+export type JavaScriptRuntime = 'bun' | 'node';
+export declare const isBunRuntime: boolean;
+export declare function runtimeFetch(url: string, options?: RuntimeRequestInit): Promise<RuntimeResponse>;
+/**
+ * The proxy url for `targetUrl` from the environment, or undefined for a
+ * direct connection (no proxy configured, NO_PROXY exempts the host, or the
+ * proxy is not an http(s) url).
+ */
+export declare function resolveProxy(targetUrl: string, env?: NodeJS.ProcessEnv): string | undefined;
+/**
+ * fetch with the WHATWG Response, through the environment's proxy when one
+ * applies to `url`. The proxy path goes through undici's own fetch (Node's
+ * built-in one cannot take a dispatcher), loaded only then.
+ */
+export declare function webFetch(url: string, init?: RequestInit): Promise<Response>;
+/**
+ * An http.Agent routing `targetUrl` through its proxy, for the core
+ * http/https APIs and node-fetch (the streaming uploads); undefined when the
+ * connection is direct. Always a CONNECT tunnel (also for http targets, like
+ * undici's ProxyAgent above): the absolute-form alternative rewrites the
+ * request head after it was buffered, which garbles a streaming body.
+ */
+export declare function proxyAgentFor(targetUrl: string): HttpAgent | undefined;
+export declare function measureTcpLatency(input: string, { attempts, timeout, }?: {
+    attempts?: number;
+    timeout?: number;
+}): Promise<number>;
+export declare function detectPackageManager(cwd?: string, env?: NodeJS.ProcessEnv): PackageManager;
+export declare function getInstallCommand(installArgs: string[], cwd?: string): {
+    command: string;
+    args: string[];
+};
+export declare function getJavaScriptRuntime(env?: NodeJS.ProcessEnv): JavaScriptRuntime;
+export declare function spawnJavaScript(args: string[], options?: SpawnOptionsWithoutStdio, env?: NodeJS.ProcessEnv): ChildProcessWithoutNullStreams;
+export declare function spawnJavaScriptSync(args: string[], options?: SpawnSyncOptions, env?: NodeJS.ProcessEnv): import("node:child_process").SpawnSyncReturns<string | NonSharedBuffer>;

package/lib/utils/runtime.js

@@ -0,0 +1,263 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 Node/Bun 子进程、HTTP agent、代理环境变量与包管理器运行时布局
+ * [OUTPUT]: 对外提供代理感知请求、网络延迟探测、包管理器/JavaScript runtime 选择及进程启动函数
+ * [POS]: CLI 跨运行时基础设施，统一网络和子进程行为，供 API、bundle 与安装命令复用
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBunRuntime = void 0;
+exports.runtimeFetch = runtimeFetch;
+exports.resolveProxy = resolveProxy;
+exports.webFetch = webFetch;
+exports.proxyAgentFor = proxyAgentFor;
+exports.measureTcpLatency = measureTcpLatency;
+exports.detectPackageManager = detectPackageManager;
+exports.getInstallCommand = getInstallCommand;
+exports.getJavaScriptRuntime = getJavaScriptRuntime;
+exports.spawnJavaScript = spawnJavaScript;
+exports.spawnJavaScriptSync = spawnJavaScriptSync;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const net_1 = require("net");
+const path_1 = __importDefault(require("path"));
+exports.isBunRuntime = typeof process.versions.bun ===
+    'string';
+function runtimeFetch(url, options) {
+    return webFetch(url, options);
+}
+// ---------------------------------------------------------------------------
+// proxies
+//
+// Node's built-in fetch ignores HTTP(S)_PROXY, so behind a corporate proxy or
+// a VPN every request of the CLI used to fail with a connection error. Every
+// network path (API, uploads, source map / Hermes base downloads, the registry
+// version check) resolves its proxy here, with the conventions curl, npm and
+// undici share: HTTPS_PROXY for https targets (falling back to HTTP_PROXY),
+// HTTP_PROXY for http targets, NO_PROXY to exempt hosts.
+// ---------------------------------------------------------------------------
+function firstEnv(env, ...names) {
+    for (const name of names) {
+        const value = env[name]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+/**
+ * NO_PROXY: comma/space separated hosts; `*` exempts everything; a leading
+ * `.` (or `*.`) matches sub-domains, a plain host matches itself and its
+ * sub-domains, `host:port` only that port.
+ */
+function matchesNoProxy(target, noProxy) {
+    if (!noProxy)
+        return false;
+    const host = target.hostname.toLowerCase();
+    const port = target.port || (target.protocol === 'https:' ? '443' : '80');
+    for (const raw of noProxy.split(/[\s,]+/)) {
+        let entry = raw.trim().toLowerCase();
+        if (!entry)
+            continue;
+        if (entry === '*')
+            return true;
+        let entryPort;
+        const withPort = /^([^:]+):(\d+)$/.exec(entry);
+        if (withPort) {
+            entry = withPort[1];
+            entryPort = withPort[2];
+        }
+        if (entryPort && entryPort !== port)
+            continue;
+        if (entry.startsWith('*.'))
+            entry = entry.slice(1);
+        if (entry.startsWith('.'))
+            entry = entry.slice(1);
+        if (host === entry || host.endsWith(`.${entry}`))
+            return true;
+    }
+    return false;
+}
+/**
+ * The proxy url for `targetUrl` from the environment, or undefined for a
+ * direct connection (no proxy configured, NO_PROXY exempts the host, or the
+ * proxy is not an http(s) url).
+ */
+function resolveProxy(targetUrl, env = process.env) {
+    let target;
+    try {
+        target = new URL(targetUrl);
+    }
+    catch {
+        return undefined;
+    }
+    if (target.protocol !== 'http:' && target.protocol !== 'https:') {
+        return undefined;
+    }
+    const proxy = target.protocol === 'https:'
+        ? firstEnv(env, 'HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy')
+        : firstEnv(env, 'HTTP_PROXY', 'http_proxy');
+    if (!proxy || matchesNoProxy(target, firstEnv(env, 'NO_PROXY', 'no_proxy'))) {
+        return undefined;
+    }
+    try {
+        const parsed = new URL(proxy);
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return proxy;
+}
+const proxyDispatchers = new Map();
+/**
+ * fetch with the WHATWG Response, through the environment's proxy when one
+ * applies to `url`. The proxy path goes through undici's own fetch (Node's
+ * built-in one cannot take a dispatcher), loaded only then.
+ */
+function webFetch(url, init = {}) {
+    const proxy = resolveProxy(url);
+    if (proxy) {
+        const undici = require('undici');
+        let dispatcher = proxyDispatchers.get(proxy);
+        if (!dispatcher) {
+            dispatcher = new undici.ProxyAgent(proxy);
+            proxyDispatchers.set(proxy, dispatcher);
+        }
+        return undici.fetch(url, {
+            ...init,
+            dispatcher,
+        });
+    }
+    if (typeof globalThis.fetch === 'function') {
+        return globalThis.fetch(url, init);
+    }
+    // Node < 18 only. Loaded on demand so the built-in fetch path never pays
+    // for node-fetch (nor for the punycode deprecation warning it triggers on
+    // Node ≥ 21).
+    const mod = require('node-fetch');
+    const nodeFetch = (mod.default ?? mod);
+    return nodeFetch(url, init);
+}
+const proxyAgents = new Map();
+/**
+ * An http.Agent routing `targetUrl` through its proxy, for the core
+ * http/https APIs and node-fetch (the streaming uploads); undefined when the
+ * connection is direct. Always a CONNECT tunnel (also for http targets, like
+ * undici's ProxyAgent above): the absolute-form alternative rewrites the
+ * request head after it was buffered, which garbles a streaming body.
+ */
+function proxyAgentFor(targetUrl) {
+    const proxy = resolveProxy(targetUrl);
+    if (!proxy)
+        return undefined;
+    let agent = proxyAgents.get(proxy);
+    if (!agent) {
+        const { HttpsProxyAgent } = require('https-proxy-agent');
+        agent = new HttpsProxyAgent(proxy);
+        proxyAgents.set(proxy, agent);
+    }
+    return agent;
+}
+function resolveTcpTarget(input) {
+    try {
+        const parsed = new URL(input);
+        const port = parsed.port || (parsed.protocol === 'http:' ? '80' : '443');
+        return {
+            host: parsed.hostname,
+            port: Number(port),
+        };
+    }
+    catch {
+        const [host, port] = input.split(':');
+        return {
+            host,
+            port: port ? Number(port) : 443,
+        };
+    }
+}
+function measureTcpConnectOnce(host, port, timeout) {
+    return new Promise((resolve) => {
+        const startedAt = Date.now();
+        const socket = (0, net_1.createConnection)({ host, port });
+        const finish = (latency) => {
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve(latency);
+        };
+        socket.setTimeout(timeout);
+        socket.once('connect', () => {
+            finish(Date.now() - startedAt);
+        });
+        socket.once('timeout', () => {
+            finish(Number.POSITIVE_INFINITY);
+        });
+        socket.once('error', () => {
+            finish(Number.POSITIVE_INFINITY);
+        });
+    });
+}
+async function measureTcpLatency(input, { attempts = 4, timeout = 1000, } = {}) {
+    const { host, port } = resolveTcpTarget(input);
+    const promises = Array.from({ length: attempts }, () => measureTcpConnectOnce(host, port, timeout));
+    const results = await Promise.all(promises);
+    const latencies = results.filter(Number.isFinite);
+    if (latencies.length === 0) {
+        return Number.POSITIVE_INFINITY;
+    }
+    return (latencies.reduce((sum, latency) => sum + latency, 0) / latencies.length);
+}
+function detectPackageManager(cwd = process.cwd(), env = process.env) {
+    const lockFiles = [
+        ['bun.lock', 'bun'],
+        ['bun.lockb', 'bun'],
+        ['pnpm-lock.yaml', 'pnpm'],
+        ['yarn.lock', 'yarn'],
+        ['package-lock.json', 'npm'],
+    ];
+    for (const [lockFile, manager] of lockFiles) {
+        if (fs_1.default.existsSync(path_1.default.join(cwd, lockFile))) {
+            return manager;
+        }
+    }
+    const userAgent = env.npm_config_user_agent ?? '';
+    if (userAgent.startsWith('bun/')) {
+        return 'bun';
+    }
+    if (userAgent.startsWith('pnpm/')) {
+        return 'pnpm';
+    }
+    if (userAgent.startsWith('yarn/')) {
+        return 'yarn';
+    }
+    if (userAgent.startsWith('npm/')) {
+        return 'npm';
+    }
+    return exports.isBunRuntime ? 'bun' : 'npm';
+}
+function getInstallCommand(installArgs, cwd = process.cwd()) {
+    const packageManager = detectPackageManager(cwd);
+    if (packageManager === 'npm') {
+        return { command: 'npm', args: ['install', ...installArgs] };
+    }
+    return { command: packageManager, args: ['add', ...installArgs] };
+}
+function getJavaScriptRuntime(env = process.env) {
+    const configured = env.RNU_JS_RUNTIME?.toLowerCase();
+    if (configured === 'bun') {
+        return 'bun';
+    }
+    if (configured === 'auto') {
+        return exports.isBunRuntime ? 'bun' : 'node';
+    }
+    return 'node';
+}
+function spawnJavaScript(args, options, env = process.env) {
+    return (0, child_process_1.spawn)(getJavaScriptRuntime(env), args, options ?? {});
+}
+function spawnJavaScriptSync(args, options, env = process.env) {
+    return (0, child_process_1.spawnSync)(getJavaScriptRuntime(env), args, options ?? {});
+}

package/lib/utils/slim-sourcemap.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shrink a source map before archiving it with a version, without losing the
+ * ability to locate any frame:
+ *
+ * - absolute source paths under the project root become relative (build
+ *   machine paths do not belong in an uploaded artifact);
+ * - `sourcesContent` of node_modules sources is dropped. Mappings and the
+ *   source paths stay, so frames inside dependencies still symbolicate to
+ *   `node_modules/...:line:column` — only the inline code snippet for those
+ *   frames is lost, and dependency sources are recoverable from the lockfile
+ *   anyway. On an RN app this is the bulk of the map's bytes.
+ *
+ * Returns null when the content is not a usable plain source map (invalid
+ * JSON, or an indexed map with `sections`); the caller then uploads the
+ * original file untouched.
+ */
+export declare function slimSourceMap(content: string, projectRoot: string): string | null;
+/**
+ * Build the bytes actually archived with a version: the slimmed map (when it
+ * is a plain map we understand), gzipped. Source maps are JSON and compress
+ * about 5x, which is the difference between a multi-megabyte upload on every
+ * publish and a small one. Readers detect the gzip magic bytes rather than
+ * trusting a file name, so plain maps archived by older CLI versions keep
+ * working unchanged.
+ */
+export declare function packSourceMap(content: string, projectRoot: string): Buffer;
+/** Decode an archived source map: gzip when the magic bytes say so. */
+export declare function unpackSourceMap(data: Buffer): string;

package/lib/utils/slim-sourcemap.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slimSourceMap = slimSourceMap;
+exports.packSourceMap = packSourceMap;
+exports.unpackSourceMap = unpackSourceMap;
+/**
+ * [INPUT]: 依赖 Node path/zlib 与 source map JSON，接收构建机项目根和待归档 map
+ * [OUTPUT]: 对外提供 source map 瘦身、gzip 归档与兼容解包函数
+ * [POS]: CLI source map 归档边界，清除机器绝对路径与依赖源码内容但保留符号定位
+ */
+const path_1 = __importDefault(require("path"));
+const zlib_1 = __importDefault(require("zlib"));
+/**
+ * Shrink a source map before archiving it with a version, without losing the
+ * ability to locate any frame:
+ *
+ * - absolute source paths under the project root become relative (build
+ *   machine paths do not belong in an uploaded artifact);
+ * - `sourcesContent` of node_modules sources is dropped. Mappings and the
+ *   source paths stay, so frames inside dependencies still symbolicate to
+ *   `node_modules/...:line:column` — only the inline code snippet for those
+ *   frames is lost, and dependency sources are recoverable from the lockfile
+ *   anyway. On an RN app this is the bulk of the map's bytes.
+ *
+ * Returns null when the content is not a usable plain source map (invalid
+ * JSON, or an indexed map with `sections`); the caller then uploads the
+ * original file untouched.
+ */
+function slimSourceMap(content, projectRoot) {
+    let map;
+    try {
+        map = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    if (!map || typeof map !== 'object' || Array.isArray(map)) {
+        return null;
+    }
+    if (map.sections !== undefined) {
+        return null;
+    }
+    if (!Array.isArray(map.sources)) {
+        return null;
+    }
+    const rootPrefix = resolveProjectRoot(projectRoot);
+    const sources = map.sources.map((source) => typeof source === 'string' ? relativizeSource(source, rootPrefix) : source);
+    map.sources = sources;
+    if (Array.isArray(map.sourcesContent)) {
+        map.sourcesContent = map.sourcesContent.map((item, index) => {
+            const source = sources[index];
+            if (typeof source === 'string' && isDependencySource(source)) {
+                return null;
+            }
+            return item;
+        });
+    }
+    return JSON.stringify(map);
+}
+function normalizeSlashes(value) {
+    return value.replace(/\\/g, '/');
+}
+function resolveProjectRoot(value) {
+    const normalized = normalizeSlashes(value);
+    // Source-map fixtures and CI metadata may use POSIX roots even when the
+    // CLI itself runs on Windows. Do not reinterpret `/work/app` as a drive
+    // rooted path; real Windows paths still use the host resolver below.
+    return normalized.startsWith('/')
+        ? normalizeSlashes(path_1.default.posix.resolve(normalized))
+        : normalizeSlashes(path_1.default.resolve(value));
+}
+function relativizeSource(source, rootPrefix) {
+    const normalized = normalizeSlashes(source);
+    if (normalized === rootPrefix) {
+        return '';
+    }
+    if (normalized.startsWith(`${rootPrefix}/`)) {
+        return normalized.slice(rootPrefix.length + 1);
+    }
+    return normalized;
+}
+function isDependencySource(source) {
+    return (source.startsWith('node_modules/') || source.includes('/node_modules/'));
+}
+/**
+ * Build the bytes actually archived with a version: the slimmed map (when it
+ * is a plain map we understand), gzipped. Source maps are JSON and compress
+ * about 5x, which is the difference between a multi-megabyte upload on every
+ * publish and a small one. Readers detect the gzip magic bytes rather than
+ * trusting a file name, so plain maps archived by older CLI versions keep
+ * working unchanged.
+ */
+function packSourceMap(content, projectRoot) {
+    const slimmed = slimSourceMap(content, projectRoot);
+    return zlib_1.default.gzipSync(Buffer.from(slimmed ?? content, 'utf8'));
+}
+/** Decode an archived source map: gzip when the magic bytes say so. */
+function unpackSourceMap(data) {
+    if (data.length >= 2 && data[0] === 0x1f && data[1] === 0x8b) {
+        return zlib_1.default.gunzipSync(data).toString('utf8');
+    }
+    return data.toString('utf8');
+}

package/lib/utils/zip-entries.d.ts

@@ -0,0 +1,10 @@
+/**
+ * [INPUT]: 依赖 fs-extra、临时目录、路径、流式管道与 ZIP 条目元数据
+ * [OUTPUT]: 对外提供 ZIP 条目读取、写入、前缀读取和枚举能力
+ * [POS]: CLI 归档基础设施，统一本地/嵌套 ZIP 的资源访问和临时目录生命周期
+ */
+import { type Entry, type ZipFile as YauzlZipFile } from 'yauzl';
+export declare function readEntry(entry: Entry, zipFile: YauzlZipFile): Promise<Buffer>;
+export declare function writeEntry(entry: Entry, zipFile: YauzlZipFile, outputPath: string): Promise<void>;
+export declare function readEntryPrefix(entry: Entry, zipFile: YauzlZipFile, maxBytes: number): Promise<Buffer>;
+export declare function enumZipEntries(zipFn: string, callback: (entry: Entry, zipFile: YauzlZipFile, nestedPath?: string) => Promise<any> | undefined, nestedPath?: string): Promise<unknown>;

package/lib/utils/zip-entries.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 fs-extra、临时目录、路径、流式管道与 ZIP 条目元数据
+ * [OUTPUT]: 对外提供 ZIP 条目读取、写入、前缀读取和枚举能力
+ * [POS]: CLI 归档基础设施，统一本地/嵌套 ZIP 的资源访问和临时目录生命周期
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEntry = readEntry;
+exports.writeEntry = writeEntry;
+exports.readEntryPrefix = readEntryPrefix;
+exports.enumZipEntries = enumZipEntries;
+const fs = __importStar(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = require("stream/promises");
+const yauzl_1 = require("yauzl");
+function readEntry(entry, zipFile) {
+    const buffers = [];
+    return new Promise((resolve, reject) => {
+        zipFile.openReadStream(entry, (err, stream) => {
+            if (err) {
+                return reject(err);
+            }
+            if (!stream) {
+                return reject(new Error(`Unable to read zip entry: ${entry.fileName}`));
+            }
+            stream.on('data', (chunk) => {
+                buffers.push(chunk);
+            });
+            stream.on('end', () => {
+                // a single chunk (a cached Range read) is handed back as-is, not copied
+                resolve(buffers.length === 1 ? buffers[0] : Buffer.concat(buffers));
+            });
+            stream.on('error', (err) => {
+                reject(err);
+            });
+        });
+    });
+}
+function writeEntry(entry, zipFile, outputPath) {
+    fs.ensureDirSync(path_1.default.dirname(outputPath));
+    return new Promise((resolve, reject) => {
+        zipFile.openReadStream(entry, (err, stream) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            if (!stream) {
+                reject(new Error(`Unable to read zip entry: ${entry.fileName}`));
+                return;
+            }
+            (0, promises_1.pipeline)(stream, fs.createWriteStream(outputPath)).then(resolve, reject);
+        });
+    });
+}
+function readEntryPrefix(entry, zipFile, maxBytes) {
+    if (maxBytes <= 0) {
+        return Promise.resolve(Buffer.alloc(0));
+    }
+    const buffers = [];
+    let length = 0;
+    return new Promise((resolve, reject) => {
+        zipFile.openReadStream(entry, (err, stream) => {
+            if (err) {
+                return reject(err);
+            }
+            if (!stream) {
+                return reject(new Error(`Unable to read zip entry: ${entry.fileName}`));
+            }
+            let settled = false;
+            let expectedDestroyError;
+            const cleanup = () => {
+                stream.off('data', onData);
+                stream.off('end', onEnd);
+                stream.off('error', onError);
+            };
+            const finish = (destroyStream = false) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                stream.off('data', onData);
+                stream.off('end', onEnd);
+                if (!destroyStream) {
+                    stream.off('error', onError);
+                }
+                resolve(Buffer.concat(buffers, length));
+                if (destroyStream) {
+                    expectedDestroyError = new Error('zip entry prefix read complete');
+                    stream.destroy(expectedDestroyError);
+                }
+            };
+            const onData = (chunk) => {
+                const remaining = maxBytes - length;
+                if (remaining <= 0) {
+                    finish(true);
+                    return;
+                }
+                const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
+                buffers.push(slice);
+                length += slice.length;
+                if (length >= maxBytes) {
+                    finish(true);
+                }
+            };
+            const onEnd = () => finish();
+            const onError = (error) => {
+                if (settled && error === expectedDestroyError) {
+                    cleanup();
+                    return;
+                }
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                reject(error);
+            };
+            stream.on('data', onData);
+            stream.once('end', onEnd);
+            stream.once('error', onError);
+        });
+    });
+}
+async function enumZipEntries(zipFn, callback, nestedPath = '') {
+    return new Promise((resolve, reject) => {
+        (0, yauzl_1.open)(zipFn, { lazyEntries: true }, async (err, zipfile) => {
+            if (err) {
+                return reject(err);
+            }
+            zipfile.on('end', resolve);
+            zipfile.on('error', reject);
+            zipfile.on('entry', async (entry) => {
+                const fullPath = nestedPath + entry.fileName;
+                try {
+                    if (!entry.fileName.endsWith('/') &&
+                        entry.fileName.toLowerCase().endsWith('.hap')) {
+                        const tempDir = await fs.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'nested_zip_'));
+                        const tempZipPath = path_1.default.join(tempDir, 'temp.zip');
+                        try {
+                            await new Promise((res, rej) => {
+                                zipfile.openReadStream(entry, async (err, readStream) => {
+                                    if (err)
+                                        return rej(err);
+                                    const writeStream = fs.createWriteStream(tempZipPath);
+                                    readStream.on('error', rej);
+                                    readStream.pipe(writeStream);
+                                    writeStream.on('finish', () => res(void 0));
+                                    writeStream.on('error', rej);
+                                });
+                            });
+                            await enumZipEntries(tempZipPath, callback, `${fullPath}/`);
+                        }
+                        finally {
+                            await fs.remove(tempDir);
+                        }
+                    }
+                    const result = callback(entry, zipfile, fullPath);
+                    if (result && typeof result.then === 'function') {
+                        await result;
+                    }
+                }
+                catch (error) {
+                    // the rejection carries the error; logging it here too would make
+                    // callers report it twice
+                    zipfile.close();
+                    reject(error);
+                    return;
+                }
+                zipfile.readEntry();
+            });
+            zipfile.readEntry();
+        });
+    });
+}