@qvac/sdk 0.20.1 → 0.21.0

package/dist/src/commands/bundle/entry-gen.js

@@ -1,8 +1,12 @@
 import { parseBuiltinSpecifier } from './plugins.js';
-export function generateWorkerEntry(pluginSpecifiers, sdkName, resolveImport = (specifier) => specifier) {
+export function generateWorkerEntry(pluginSpecifiers, sdkName, resolveImport = (specifier) => specifier, rpcServerProvider) {
     const imports = [];
     const registrations = [];
     let varIndex = 0;
+    if (rpcServerProvider) {
+        imports.push(`import { registerRpcServerProvider } from ${JSON.stringify(resolveImport(`${sdkName}/rpc-server-provider`))};`, `import rpcServerProvider from ${JSON.stringify(resolveImport(rpcServerProvider))};`);
+        registrations.push('registerRpcServerProvider(rpcServerProvider);');
+    }
     for (const specifier of pluginSpecifiers) {
         const builtin = parseBuiltinSpecifier(specifier, sdkName);
         if (builtin) {
@@ -46,9 +50,9 @@ if (hasRPCConfig) {
 }
 `;
 }
-export function generateWorkerEntries(pluginSpecifiers, sdkName, resolveBundleImport) {
+export function generateWorkerEntries(pluginSpecifiers, sdkName, resolveBundleImport, rpcServerProvider) {
     return {
-        runtimeEntry: generateWorkerEntry(pluginSpecifiers, sdkName),
-        bundleEntry: generateWorkerEntry(pluginSpecifiers, sdkName, resolveBundleImport)
+        runtimeEntry: generateWorkerEntry(pluginSpecifiers, sdkName, undefined, rpcServerProvider),
+        bundleEntry: generateWorkerEntry(pluginSpecifiers, sdkName, resolveBundleImport, rpcServerProvider)
     };
 }

package/dist/src/commands/bundle/index.d.ts

@@ -1,3 +1,4 @@
+import { type HostPrebuildPackage } from '../host-prebuilds/index.js';
 export interface BundleSdkOptions {
     projectRoot?: string | undefined;
     configPath?: string | undefined;
@@ -6,6 +7,23 @@ export interface BundleSdkOptions {
     defer?: string[] | undefined;
     quiet?: boolean | undefined;
     verbose?: boolean | undefined;
+    /**
+     * Install the addon platform packages the bundle needs for its mobile hosts
+     * with the project's package manager (see `ensureHostPrebuilds`), then
+     * bundle again. Off by default: without it, bundling never changes
+     * package.json or node_modules. When the install is refused, the bundle and
+     * its manifest are still written before `HostPrebuildsInstallRefusedError`
+     * is thrown.
+     */
+    installMissingPrebuilds?: boolean | undefined;
+    /**
+     * Check the bundled packages' engines.bare against the Bare runtime of each
+     * host and warn on a mismatch. Defaults to true; callers that run
+     * `verifyBundle` on the result can turn it off.
+     */
+    checkEngines?: boolean | undefined;
+    /** Allow network lookups during the engines check. Defaults to true. */
+    network?: boolean | undefined;
 }
 export interface BundleSdkResult {
     bundlePath: string;
@@ -15,6 +33,8 @@ export interface BundleSdkResult {
         worker: string;
     };
     manifestPath: string;
+    /** Platform packages `installMissingPrebuilds` installed; empty when it is off. */
+    installedPrebuilds: HostPrebuildPackage[];
 }
 export declare function bundleSdk(options?: BundleSdkOptions): Promise<BundleSdkResult>;
 //# sourceMappingURL=index.d.ts.map

package/dist/src/commands/bundle/index.js

@@ -3,13 +3,18 @@ import path from 'node:path';
 import { createRequire } from 'node:module';
 import { DEFAULT_HOSTS, DEFAULT_SDK_NAME } from './constants.js';
 import { CONFIG_CANDIDATES, resolveConfigForProject } from '../../client/config-loader/resolve-config.node.js';
-import { getClientLogger } from '../../logging/index.js';
-import { BareImportsMapNotFoundError } from '../../utils/errors-client.js';
+import { createCommandLogger } from '../command-logger.js';
+import { BareImportsMapNotFoundError, HostPrebuildsInstallRefusedError } from '../../utils/errors-client.js';
 import { resolvePluginSpecifiers, parseBuiltinSpecifier } from './plugins.js';
 import { generateWorkerEntries } from './entry-gen.js';
 import { runBarePack } from './bare-pack.js';
 import { generateAddonsManifest } from './manifest.js';
 import { createSdkImportResolver } from './resolve-sdk-import.js';
+import { installMissingHostPrebuilds } from '../host-prebuilds/index.js';
+import { collectAddonsFromBundle } from '../verify/bundle-source.js';
+import { verifyBundle } from '../verify/index.js';
+import { formatRuntimeSource } from '../verify/abi.js';
+import { formatEnginesAdvice } from '../verify/engines-advice.js';
 const require = createRequire(import.meta.url);
 function resolveSdkPath(projectRoot, explicitSdkPath) {
     if (explicitSdkPath) {
@@ -49,14 +54,43 @@ function resolveImportsMapPath(sdkPath, sdkName) {
     }
     throw new BareImportsMapNotFoundError(sdkName, importsMapPath);
 }
-function createCommandLogger(options) {
-    if (options.quiet) {
-        return getClientLogger({ level: 'error', enableConsole: false });
+const ENGINES_ISSUE_CODES = new Set(['abi-mismatch', 'engines-mismatch']);
+async function checkBundleEngines(options) {
+    const { projectRoot, bundlePath, hosts, configPath, network, logger } = options;
+    logger.info('\n🔎 Checking engines.bare against the Bare runtime of each host...');
+    const result = await verifyBundle({
+        projectRoot,
+        addonsSource: bundlePath,
+        hosts,
+        ...(configPath !== undefined ? { configPath } : {}),
+        ...(network !== undefined ? { network } : {}),
+        onProgress: (message) => logger.info(`   ${message}`)
+    });
+    const checkedHosts = [];
+    for (const group of result.runtimes ?? []) {
+        const label = group.hosts.join(', ');
+        if (group.resolution.resolved) {
+            checkedHosts.push(...group.hosts);
+            logger.info(`   ${label}: Bare ${group.resolution.runtime.version} (from ${formatRuntimeSource(group.resolution.runtime)})`);
+        }
+        else {
+            logger.warn(`engines.bare not checked for ${label}: ${group.resolution.error.reason}`);
+        }
     }
-    if (options.verbose) {
-        return getClientLogger({ level: 'debug' });
+    const mismatches = result.issues.filter((issue) => ENGINES_ISSUE_CODES.has(issue.code) && issue.level === 'error');
+    if (mismatches.length === 0) {
+        if (checkedHosts.length > 0) {
+            logger.info(`   No engines.bare mismatches for ${checkedHosts.join(', ')}`);
+        }
+        return;
     }
-    return getClientLogger();
+    const lines = ['The bundle contains packages that require a newer Bare runtime:'];
+    for (const issue of mismatches)
+        lines.push(`  - ${issue.message}`);
+    lines.push('');
+    for (const advice of result.advice ?? [])
+        lines.push(...formatEnginesAdvice(advice));
+    logger.warn(lines.join('\n').trimEnd());
 }
 export async function bundleSdk(options = {}) {
     const startTime = Date.now();
@@ -94,7 +128,7 @@ export async function bundleSdk(options = {}) {
     await fsp.mkdir(outputDir, { recursive: true });
     logger.info('\n📝 Generating worker entry...');
     const resolveSdkImport = createSdkImportResolver(sdkPath, sdkName);
-    const { runtimeEntry, bundleEntry } = generateWorkerEntries(pluginSpecifiers, sdkName, resolveSdkImport);
+    const { runtimeEntry, bundleEntry } = generateWorkerEntries(pluginSpecifiers, sdkName, resolveSdkImport, config.rpcServerProvider);
     await fsp.writeFile(entryPath, runtimeEntry, 'utf8');
     logger.info(`   Created: ${path.relative(projectRoot, entryPath)}`);
     logger.info(`   Using: ${path.relative(projectRoot, importsMapPath)}`);
@@ -103,9 +137,11 @@ export async function bundleSdk(options = {}) {
     if (deferModules.length > 0) {
         logger.debug(`   Deferred: ${deferModules.join(', ')}`);
     }
+    let installedPrebuilds = [];
+    let installRefused;
     try {
         await fsp.writeFile(bundleEntryPath, bundleEntry, 'utf8');
-        await runBarePack({
+        const barePackOptions = {
             entryPath: bundleEntryPath,
             outputPath: bundlePath,
             hosts,
@@ -113,7 +149,34 @@ export async function bundleSdk(options = {}) {
             deferModules,
             quiet: options.quiet === true,
             logger
-        });
+        };
+        await runBarePack(barePackOptions);
+        if (options.installMissingPrebuilds === true) {
+            try {
+                const { installed } = await installMissingHostPrebuilds({
+                    projectRoot,
+                    hosts,
+                    addons: await collectAddonsFromBundle({ bundlePath, projectRoot, hosts }),
+                    quiet: options.quiet === true,
+                    logger
+                });
+                installedPrebuilds = installed;
+                // Where a platform package was missing, bare-pack resolved the addon's
+                // `#host-addon` import to its fallback module; bundle again to pick up
+                // the installed package.
+                if (installed.length > 0) {
+                    logger.info('\n🔨 Bundling again with the installed platform packages...');
+                    await runBarePack(barePackOptions);
+                }
+            }
+            catch (error) {
+                if (!(error instanceof HostPrebuildsInstallRefusedError))
+                    throw error;
+                // A refusal happens before anything is installed, so the bundle
+                // already written is final and only its manifest is left to write.
+                installRefused = error;
+            }
+        }
     }
     finally {
         await fsp.rm(bundleEntryPath, { force: true });
@@ -128,6 +191,18 @@ export async function bundleSdk(options = {}) {
         projectRoot,
         logger
     });
+    if (options.checkEngines !== false) {
+        await checkBundleEngines({
+            projectRoot,
+            bundlePath,
+            hosts,
+            configPath: configPath ?? undefined,
+            network: options.network,
+            logger
+        });
+    }
+    if (installRefused !== undefined)
+        throw installRefused;
     const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
     logger.info(`\n🎉 Done in ${elapsed}s!\n`);
     logger.info('Generated files:');
@@ -143,6 +218,7 @@ export async function bundleSdk(options = {}) {
         entryPaths: {
             worker: entryPath
         },
-        manifestPath: manifestResult.manifestPath
+        manifestPath: manifestResult.manifestPath,
+        installedPrebuilds
     };
 }

package/dist/src/commands/bundle/plugins.js

@@ -17,7 +17,7 @@ export function parseBuiltinSpecifier(specifier, sdkName) {
 }
 export function resolvePluginSpecifiers(config, sdkName, logger) {
     let plugins = config.plugins ?? [];
-    if (plugins.length === 0) {
+    if (plugins.length === 0 && !(config.rpcServerProvider && config.plugins !== undefined)) {
         const allBuiltins = BUILTIN_SUFFIXES.map((suffix) => buildBuiltinSpecifier(sdkName, suffix));
         logger.warn('No plugins specified — bundling ALL built-in plugins.');
         logger.info("   For smaller bundles, add a 'plugins' array to qvac.config.*\n");

package/dist/src/commands/command-logger.d.ts

@@ -0,0 +1,6 @@
+export interface CommandLoggerOptions {
+    quiet?: boolean | undefined;
+    verbose?: boolean | undefined;
+}
+export declare function createCommandLogger(options: CommandLoggerOptions): import("../logging/index.js").Logger;
+//# sourceMappingURL=command-logger.d.ts.map

package/dist/src/commands/command-logger.js

@@ -0,0 +1,12 @@
+import { getClientLogger } from '../logging/index.js';
+export function createCommandLogger(options) {
+    if (options.quiet) {
+        return getClientLogger({ level: 'error', enableConsole: false });
+    }
+    // The client logger keeps console output off unless asked; a command's
+    // progress and warnings are meant for the person running it.
+    if (options.verbose) {
+        return getClientLogger({ level: 'debug', enableConsole: true });
+    }
+    return getClientLogger({ enableConsole: true });
+}

package/dist/src/commands/host-prebuilds/index.d.ts

@@ -0,0 +1,71 @@
+import type { Logger } from '../../logging/types.js';
+import { type NativeAddon } from '../verify/addon-source.js';
+import { type PackageManagerName } from './package-manager.js';
+export type { PackageManagerName } from './package-manager.js';
+export interface EnsureHostPrebuildsOptions {
+    /** The package whose package.json receives the pins; its package manager installs them. */
+    projectRoot: string;
+    /** Bare hosts to cover. Only mobile hosts (`android-*`, `ios-*`) can need an install. */
+    hosts: string[];
+    /**
+     * Addon package names to cover. Defaults to every addon installed for the
+     * project: in its own node_modules or in that of a workspace root listing it.
+     */
+    addons?: string[] | undefined;
+    /** Install with this package manager instead of detecting the project's own. */
+    packageManager?: PackageManagerName | undefined;
+    quiet?: boolean | undefined;
+    verbose?: boolean | undefined;
+}
+export interface HostPrebuildPackage {
+    /** The platform package, e.g. `@qvac/tts-ggml-android-arm64`. */
+    name: string;
+    /** Always the addon's own version: platform packages are version-locked to it. */
+    version: string;
+    /** The addon the package ships prebuilds for. */
+    addon: string;
+    /** The requested hosts the package covers. */
+    hosts: string[];
+}
+export interface EnsureHostPrebuildsResult {
+    /** The packages this call installed; empty when every prebuild already resolved. */
+    installed: HostPrebuildPackage[];
+    /** The package manager that installed them, or null when nothing was missing. */
+    packageManager: PackageManagerName | null;
+}
+/**
+ * Installs the per-platform prebuild packages that addons need for mobile
+ * hosts and that the project does not have yet.
+ *
+ * A split addon names one platform package per host in the `#host-addon` map
+ * of its package.json (`<addon>-ios` covers every iOS host). Desktop platform
+ * packages install as the addon's os/cpu-filtered optionalDependencies, but a
+ * build host never reports a mobile os, so mobile ones have to be declared.
+ * This declares the missing ones in package.json, pinned to each addon's
+ * exact version, using the project's own package manager.
+ *
+ * A host whose prebuild already resolves is skipped: a local
+ * `prebuilds/<host>` in the addon (source builds) or its platform package at
+ * the addon's version. Throws `HostPrebuildsInstallRefusedError` when no
+ * supported package manager (npm 7+, pnpm, bun, Yarn Berry) is found, and
+ * `HostPrebuildsInstallFailedError` when the install does not produce the
+ * packages.
+ */
+export declare function ensureHostPrebuilds(options: EnsureHostPrebuildsOptions): Promise<EnsureHostPrebuildsResult>;
+export interface InstallMissingHostPrebuildsOptions {
+    projectRoot: string;
+    hosts: string[];
+    addons: NativeAddon[];
+    packageManager?: PackageManagerName | undefined;
+    quiet: boolean;
+    logger: Logger;
+}
+/** `ensureHostPrebuilds` for addons the caller has already located. */
+export declare function installMissingHostPrebuilds(options: InstallMissingHostPrebuildsOptions): Promise<EnsureHostPrebuildsResult>;
+/**
+ * The platform packages `addons` still need for the mobile hosts in `hosts`,
+ * one entry per package. Throws when two installed versions of one addon need
+ * the same platform package, since only one version of it can be installed.
+ */
+export declare function findMissingHostPrebuilds(addons: NativeAddon[], hosts: string[]): Promise<HostPrebuildPackage[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/commands/host-prebuilds/index.js

@@ -0,0 +1,227 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import semver from 'semver';
+import { createCommandLogger } from '../command-logger.js';
+import { readAddonPackageJson } from '../verify/addon-source.js';
+import { checkPrebuilds, isMobileHost } from '../verify/prebuilds.js';
+import { checkPackageManagerSupport, detectPackageManager, installArgs, isPackageManagerName, isWorkspaceMember, runPackageManager } from './package-manager.js';
+import { HostPrebuildsInstallFailedError, HostPrebuildsInstallRefusedError } from '../../utils/errors-client.js';
+/** npm's package-name grammar. On Windows the names pass through a shell. */
+const PACKAGE_NAME = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+/**
+ * Installs the per-platform prebuild packages that addons need for mobile
+ * hosts and that the project does not have yet.
+ *
+ * A split addon names one platform package per host in the `#host-addon` map
+ * of its package.json (`<addon>-ios` covers every iOS host). Desktop platform
+ * packages install as the addon's os/cpu-filtered optionalDependencies, but a
+ * build host never reports a mobile os, so mobile ones have to be declared.
+ * This declares the missing ones in package.json, pinned to each addon's
+ * exact version, using the project's own package manager.
+ *
+ * A host whose prebuild already resolves is skipped: a local
+ * `prebuilds/<host>` in the addon (source builds) or its platform package at
+ * the addon's version. Throws `HostPrebuildsInstallRefusedError` when no
+ * supported package manager (npm 7+, pnpm, bun, Yarn Berry) is found, and
+ * `HostPrebuildsInstallFailedError` when the install does not produce the
+ * packages.
+ */
+export async function ensureHostPrebuilds(options) {
+    const logger = createCommandLogger(options);
+    const addons = await resolveAddons(options.projectRoot, options.addons, logger);
+    return installMissingHostPrebuilds({
+        projectRoot: options.projectRoot,
+        hosts: options.hosts,
+        addons,
+        packageManager: options.packageManager,
+        quiet: options.quiet === true,
+        logger
+    });
+}
+/** `ensureHostPrebuilds` for addons the caller has already located. */
+export async function installMissingHostPrebuilds(options) {
+    const { projectRoot, hosts, addons, quiet, logger } = options;
+    const missing = await findMissingHostPrebuilds(addons, hosts);
+    if (missing.length === 0)
+        return { installed: [], packageManager: null };
+    const dependencies = toDependencies(missing);
+    const manager = await choosePackageManager(projectRoot, options.packageManager, dependencies);
+    const args = installArgs(manager, missing.map((pkg) => `${pkg.name}@${pkg.version}`));
+    const command = `${manager} ${args.join(' ')}`;
+    logger.info(`\n📦 Installing addon platform packages with ${manager}:`);
+    for (const pkg of missing) {
+        logger.info(`   ${pkg.name}@${pkg.version} (${pkg.hosts.join(', ')})`);
+    }
+    const result = await runPackageManager(manager, args, { cwd: projectRoot, quiet });
+    if (result.error !== undefined || result.code !== 0) {
+        const outcome = result.error?.message ?? `exited with code ${result.code ?? 'unknown'}`;
+        const stderr = result.stderr.trim();
+        throw new HostPrebuildsInstallFailedError(`\`${command}\` ${outcome}${stderr.length > 0 ? `\n\n${stderr}` : ''}`, dependencies, result.error);
+    }
+    const stillMissing = await findMissingHostPrebuilds(addons, hosts);
+    if (stillMissing.length > 0) {
+        const names = stillMissing.map((pkg) => pkg.name).join(', ');
+        const pnpHint = manager === 'yarn'
+            ? "; Yarn Plug'n'Play installs no node_modules, so set `nodeLinker: node-modules`"
+            : '';
+        throw new HostPrebuildsInstallFailedError(`\`${command}\` succeeded, but ${names} is still not installed under node_modules${pnpHint}`, toDependencies(stillMissing));
+    }
+    logger.info(`   Installed ${missing.length} platform package${missing.length === 1 ? '' : 's'}`);
+    return { installed: missing, packageManager: manager };
+}
+/**
+ * The platform packages `addons` still need for the mobile hosts in `hosts`,
+ * one entry per package. Throws when two installed versions of one addon need
+ * the same platform package, since only one version of it can be installed.
+ */
+export async function findMissingHostPrebuilds(addons, hosts) {
+    const mobileHosts = hosts.filter(isMobileHost);
+    const packages = new Map();
+    if (mobileHosts.length === 0)
+        return [];
+    for (const addon of addons) {
+        for (const issue of await checkPrebuilds({ addon, hosts: mobileHosts })) {
+            const pin = issue.platformPackage;
+            if (pin === undefined)
+                continue;
+            const known = packages.get(pin.name);
+            if (known === undefined) {
+                packages.set(pin.name, { ...pin, addon: addon.name, hosts: [issue.host] });
+                continue;
+            }
+            if (known.version !== pin.version) {
+                throw new HostPrebuildsInstallRefusedError(`${addon.name} is installed at both ${known.version} and ${pin.version}, but ` +
+                    `${pin.name} can be installed at only one version. ` +
+                    `Deduplicate ${addon.name} to a single version and try again`, {});
+            }
+            if (!known.hosts.includes(issue.host))
+                known.hosts.push(issue.host);
+        }
+    }
+    const missing = [...packages.values()].sort((a, b) => a.name.localeCompare(b.name));
+    for (const pkg of missing) {
+        if (!PACKAGE_NAME.test(pkg.name) || semver.valid(pkg.version) === null) {
+            throw new HostPrebuildsInstallRefusedError(`${pkg.addon} names "${pkg.name}@${pkg.version}", which is not a valid package name and version`, {});
+        }
+    }
+    return missing;
+}
+async function choosePackageManager(projectRoot, requested, dependencies) {
+    let manager;
+    let source = '';
+    if (requested !== undefined) {
+        if (!isPackageManagerName(requested)) {
+            throw new HostPrebuildsInstallRefusedError(`packageManager "${String(requested)}" is not npm, pnpm, bun, or yarn`, dependencies);
+        }
+        manager = requested;
+    }
+    else {
+        const detected = await detectPackageManager(projectRoot);
+        if (detected.manager === null) {
+            throw new HostPrebuildsInstallRefusedError(`could not tell which package manager the project uses (${detected.reason})`, dependencies);
+        }
+        manager = detected.manager;
+        source = ` (detected from ${detected.source})`;
+    }
+    const unsupported = await checkPackageManagerSupport(manager, projectRoot);
+    if (unsupported !== null) {
+        throw new HostPrebuildsInstallRefusedError(`${unsupported}${source}`, dependencies);
+    }
+    return manager;
+}
+/**
+ * The installed addons named in `names`, or every installed addon when
+ * `names` is omitted. For each name the copy in the nearest modules directory
+ * wins, as it does for Node's resolver.
+ */
+async function resolveAddons(projectRoot, names, logger) {
+    const moduleDirs = await reachableModuleDirs(projectRoot);
+    const wanted = names === undefined ? null : new Set(names);
+    const found = new Map();
+    for (const modulesDir of moduleDirs) {
+        const candidates = wanted === null ? await listPackageNames(modulesDir) : [...wanted];
+        for (const name of candidates) {
+            if (found.has(name))
+                continue;
+            const result = await readAddonPackageJson({
+                packageJsonPath: path.join(modulesDir, ...name.split('/'), 'package.json'),
+                expectedName: name
+            });
+            if (result.addon !== undefined)
+                found.set(name, result.addon);
+        }
+    }
+    for (const name of wanted ?? []) {
+        if (!found.has(name))
+            logger.warn(`${name} is not an installed native addon; skipping it`);
+    }
+    return [...found.values()];
+}
+/**
+ * Every modules directory a package installed for `projectRoot` can sit in,
+ * nearest first: the project's `node_modules` and that of each workspace root
+ * above it that lists the project (npm, Yarn, and bun hoist workspace
+ * dependencies to the root), plus the views pnpm (`.pnpm/node_modules`) and
+ * bun's isolated layout (`.bun/node_modules`) keep of the packages that are not
+ * direct dependencies. Any other enclosing project installed its node_modules
+ * for itself, so its addons do not belong to this one.
+ */
+async function reachableModuleDirs(projectRoot) {
+    const start = path.resolve(projectRoot);
+    const dirs = [];
+    let dir = start;
+    for (;;) {
+        if (dir === start || (await isWorkspaceMember(dir, start))) {
+            const nodeModules = path.join(dir, 'node_modules');
+            for (const candidate of [
+                nodeModules,
+                path.join(nodeModules, '.pnpm', 'node_modules'),
+                path.join(nodeModules, '.bun', 'node_modules')
+            ]) {
+                if (await isDirectory(candidate))
+                    dirs.push(candidate);
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return dirs;
+        dir = parent;
+    }
+}
+async function listPackageNames(modulesDir) {
+    const names = [];
+    for (const entry of await readDirNames(modulesDir)) {
+        if (entry.startsWith('.'))
+            continue;
+        if (!entry.startsWith('@')) {
+            names.push(entry);
+            continue;
+        }
+        for (const scoped of await readDirNames(path.join(modulesDir, entry))) {
+            if (!scoped.startsWith('.'))
+                names.push(`${entry}/${scoped}`);
+        }
+    }
+    return names;
+}
+async function readDirNames(dir) {
+    try {
+        return (await fsp.readdir(dir, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+async function isDirectory(dir) {
+    try {
+        return (await fsp.stat(dir)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function toDependencies(packages) {
+    return Object.fromEntries(packages.map((pkg) => [pkg.name, pkg.version]));
+}

package/dist/src/commands/host-prebuilds/package-manager.d.ts

@@ -0,0 +1,54 @@
+export type PackageManagerName = 'npm' | 'pnpm' | 'bun' | 'yarn';
+/**
+ * The package manager that owns `projectRoot`, from the project's own
+ * `packageManager` field, lockfile, or node_modules install files. A project
+ * with none of those is a workspace member only if the nearest directory above
+ * it that has them is a workspace root listing it; any other enclosing project
+ * belongs to someone else, and its package manager is not this one's.
+ */
+export declare function detectPackageManager(projectRoot: string): Promise<{
+    manager: null;
+    reason: string;
+    source?: never;
+} | {
+    manager: PackageManagerName;
+    source: string;
+    reason?: never;
+}>;
+export declare function isPackageManagerName(value: string): value is PackageManagerName;
+/**
+ * Whether the workspace globs declared at `rootDir` (package.json `workspaces`
+ * for npm, Yarn, and bun; `pnpm-workspace.yaml` for pnpm) include `memberDir`.
+ */
+export declare function isWorkspaceMember(rootDir: string, memberDir: string): Promise<boolean>;
+/**
+ * The `packages` list of a pnpm-workspace.yaml, in block (`- 'apps/*'`) or
+ * flow (`packages: ['apps/*']`) form. The SDK has no YAML parser, and the
+ * file's other keys are irrelevant here.
+ */
+export declare function parsePnpmWorkspacePackages(yaml: string): string[];
+/**
+ * Why `manager` cannot install in `cwd`, or null when it can. The supported
+ * set matches the installers the split addons document: npm 7+, pnpm, bun,
+ * and Yarn Berry.
+ */
+export declare function checkPackageManagerSupport(manager: PackageManagerName, cwd: string): Promise<string | null>;
+/** Arguments that add `specs` as exact-version dependencies of the package in cwd. */
+export declare function installArgs(manager: PackageManagerName, specs: string[]): string[];
+export interface RunPackageManagerResult {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+}
+/**
+ * Quiet runs capture stdout and stderr; other runs stream them to this
+ * process. Windows resolves the package managers' `.cmd` shims through the
+ * shell, which does not escape arguments, so callers must pass only
+ * validated ones.
+ */
+export declare function runPackageManager(manager: PackageManagerName, args: string[], options: {
+    cwd: string;
+    quiet: boolean;
+}): Promise<RunPackageManagerResult>;
+//# sourceMappingURL=package-manager.d.ts.map