@qvac/sdk 0.20.1 → 0.21.1

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

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

@@ -0,0 +1,278 @@
+import { spawn } from 'node:child_process';
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import semver from 'semver';
+const PACKAGE_MANAGERS = ['npm', 'pnpm', 'bun', 'yarn'];
+const LOCKFILES = [
+    ['package-lock.json', 'npm'],
+    ['npm-shrinkwrap.json', 'npm'],
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['bun.lock', 'bun'],
+    ['bun.lockb', 'bun'],
+    ['yarn.lock', 'yarn']
+];
+/**
+ * Files a package manager writes into the node_modules it installs. They name
+ * the tool that built the tree even where the project keeps no lockfile. Bun's
+ * default layout writes none.
+ */
+const INSTALL_MARKERS = [
+    ['.package-lock.json', 'npm'],
+    ['.modules.yaml', 'pnpm'],
+    ['.yarn-state.yml', 'yarn'],
+    ['.yarn-integrity', '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 async function detectPackageManager(projectRoot) {
+    const start = path.resolve(projectRoot);
+    const own = await readInstallEvidence(start);
+    if (hasEvidence(own))
+        return decidePackageManager(start, own);
+    let dir = start;
+    for (;;) {
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return {
+                manager: null,
+                reason: `no lockfile or packageManager field found in ${start} or its parent directories`
+            };
+        }
+        dir = parent;
+        const evidence = await readInstallEvidence(dir);
+        if (!hasEvidence(evidence))
+            continue;
+        if (!(await isWorkspaceMember(dir, start))) {
+            return {
+                manager: null,
+                reason: `${start} has no lockfile of its own, and ${dir}, which has one, ` +
+                    'is not a workspace root that lists it'
+            };
+        }
+        return decidePackageManager(dir, evidence);
+    }
+}
+export function isPackageManagerName(value) {
+    return PACKAGE_MANAGERS.includes(value);
+}
+function hasEvidence(evidence) {
+    return evidence.declared !== null || evidence.found.length > 0;
+}
+/** A declared `packageManager` decides; otherwise every lockfile and install file must agree. */
+function decidePackageManager(dir, evidence) {
+    const { declared, found } = evidence;
+    if (declared !== null) {
+        const name = declared.split('@')[0] ?? '';
+        if (!isPackageManagerName(name)) {
+            return {
+                manager: null,
+                reason: `package.json in ${dir} declares packageManager "${declared}", ` +
+                    'which is not npm, pnpm, bun, or Yarn'
+            };
+        }
+        return {
+            manager: name,
+            source: `packageManager "${declared}" in ${path.join(dir, 'package.json')}`
+        };
+    }
+    const managers = [...new Set(found.map((entry) => entry.manager))];
+    const [first] = found;
+    if (managers.length === 1 && first !== undefined) {
+        return { manager: first.manager, source: first.source };
+    }
+    return {
+        manager: null,
+        reason: `${dir} has install files from ${managers.join(', ')} ` +
+            `(${found.map((entry) => path.relative(dir, entry.source)).join(', ')}); ` +
+            'set the packageManager field in package.json to pick one'
+    };
+}
+async function readInstallEvidence(dir) {
+    const found = [];
+    for (const [file, manager] of LOCKFILES) {
+        const source = path.join(dir, file);
+        if (await isFile(source))
+            found.push({ manager, source });
+    }
+    for (const [file, manager] of INSTALL_MARKERS) {
+        const source = path.join(dir, 'node_modules', file);
+        if (await isFile(source))
+            found.push({ manager, source });
+    }
+    const manifest = await readPackageJson(dir);
+    const field = manifest?.['packageManager'];
+    return { declared: typeof field === 'string' && field.length > 0 ? field : null, found };
+}
+async function isFile(filePath) {
+    try {
+        return (await fsp.stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function readPackageJson(dir) {
+    try {
+        const parsed = JSON.parse(await fsp.readFile(path.join(dir, 'package.json'), 'utf8'));
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Whether the workspace globs declared at `rootDir` (package.json `workspaces`
+ * for npm, Yarn, and bun; `pnpm-workspace.yaml` for pnpm) include `memberDir`.
+ */
+export async function isWorkspaceMember(rootDir, memberDir) {
+    const relative = path.relative(rootDir, memberDir).split(path.sep).join('/');
+    let included = false;
+    for (const pattern of await readWorkspacePatterns(rootDir)) {
+        const negated = pattern.startsWith('!');
+        const glob = (negated ? pattern.slice(1) : pattern).replace(/^\.\//, '').replace(/\/+$/, '');
+        if (globToRegExp(glob).test(relative))
+            included = !negated;
+    }
+    return included;
+}
+async function readWorkspacePatterns(dir) {
+    const patterns = [];
+    const workspaces = (await readPackageJson(dir))?.['workspaces'];
+    const list = typeof workspaces === 'object' && workspaces !== null && !Array.isArray(workspaces)
+        ? workspaces.packages
+        : workspaces;
+    if (Array.isArray(list)) {
+        patterns.push(...list.filter((entry) => typeof entry === 'string'));
+    }
+    try {
+        const yaml = await fsp.readFile(path.join(dir, 'pnpm-workspace.yaml'), 'utf8');
+        patterns.push(...parsePnpmWorkspacePackages(yaml));
+    }
+    catch {
+        // Not a pnpm workspace.
+    }
+    return patterns;
+}
+/**
+ * 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 function parsePnpmWorkspacePackages(yaml) {
+    const patterns = [];
+    let inPackages = false;
+    for (const rawLine of yaml.split(/\r?\n/)) {
+        const line = rawLine.replace(/\s+#.*$/, '');
+        const flow = /^packages\s*:\s*\[(.*)\]\s*$/.exec(line);
+        if (flow !== null) {
+            patterns.push(...(flow[1] ?? '').split(',').map(unquote).filter(Boolean));
+            break;
+        }
+        if (/^packages\s*:\s*$/.test(line)) {
+            inPackages = true;
+            continue;
+        }
+        if (!inPackages)
+            continue;
+        if (/^\S/.test(line))
+            break;
+        const item = /^\s*-\s*(.+?)\s*$/.exec(line);
+        if (item !== null)
+            patterns.push(unquote(item[1] ?? ''));
+    }
+    return patterns;
+}
+function unquote(value) {
+    return value.trim().replace(/^(['"])(.*)\1$/, '$2');
+}
+/** `*` matches within one path segment, `**` across segments. */
+function globToRegExp(glob) {
+    let source = '';
+    for (let i = 0; i < glob.length; i++) {
+        const char = glob[i] ?? '';
+        if (char === '*' && glob[i + 1] === '*') {
+            const slash = glob[i + 2] === '/';
+            source += slash ? '(?:.*/)?' : '.*';
+            i += slash ? 2 : 1;
+        }
+        else if (char === '*') {
+            source += '[^/]*';
+        }
+        else if (char === '?') {
+            source += '[^/]';
+        }
+        else {
+            source += char.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        }
+    }
+    return new RegExp(`^${source}$`);
+}
+/**
+ * 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 async function checkPackageManagerSupport(manager, cwd) {
+    const result = await runPackageManager(manager, ['--version'], { cwd, quiet: true });
+    if (result.error !== undefined || result.code !== 0) {
+        return `\`${manager} --version\` failed; is ${manager} installed and on PATH?`;
+    }
+    const version = semver.coerce(result.stdout.trim())?.version;
+    if (version === undefined)
+        return null;
+    if (manager === 'npm' && semver.lt(version, '7.0.0')) {
+        return `npm ${version} is too old; npm 7 or later is required`;
+    }
+    if (manager === 'yarn' && semver.lt(version, '2.0.0')) {
+        return `Yarn ${version} (Yarn Classic) is not supported; use Yarn Berry (2 or later)`;
+    }
+    return null;
+}
+/** Arguments that add `specs` as exact-version dependencies of the package in cwd. */
+export function installArgs(manager, specs) {
+    switch (manager) {
+        case 'npm':
+            return ['install', '--save-exact', ...specs];
+        case 'pnpm':
+            return ['add', '--save-exact', ...specs];
+        case 'bun':
+        case 'yarn':
+            return ['add', '--exact', ...specs];
+    }
+}
+/**
+ * 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 function runPackageManager(manager, args, options) {
+    return new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        const spawnOptions = {
+            cwd: options.cwd,
+            stdio: options.quiet ? ['ignore', 'pipe', 'pipe'] : 'inherit'
+        };
+        const proc = process.platform === 'win32'
+            ? spawn([manager, ...args].join(' '), { ...spawnOptions, shell: true })
+            : spawn(manager, args, spawnOptions);
+        proc.stdout?.setEncoding('utf8');
+        proc.stdout?.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        proc.stderr?.setEncoding('utf8');
+        proc.stderr?.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        proc.on('error', (error) => resolve({ code: null, stdout, stderr, error }));
+        proc.on('close', (code) => resolve({ code, stdout, stderr }));
+    });
+}

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

@@ -1,5 +1,14 @@
 export { bundleSdk } from './bundle/index.js';
 export type { BundleSdkOptions, BundleSdkResult } from './bundle/index.js';
+export { ensureHostPrebuilds } from './host-prebuilds/index.js';
+export type { EnsureHostPrebuildsOptions, EnsureHostPrebuildsResult, HostPrebuildPackage, PackageManagerName } from './host-prebuilds/index.js';
 export { verifyBundle, hasErrors, hasWarnings, formatVerifyBundleResult } from './verify/index.js';
-export type { VerifyBundleOptions, VerifyBundleResult, VerifyBundleIssue } from './verify/index.js';
+export type { VerifyBundleOptions, VerifyBundleResult, VerifyBundleIssue, RuntimeGroup } from './verify/index.js';
+export { HostPrebuildsInstallFailedError, HostPrebuildsInstallRefusedError } from '../utils/errors-client.js';
+export { formatRuntimeSource } from './verify/abi.js';
+export type { BareRuntime, BareRuntimeResolution } from './verify/abi.js';
+export { isReactNativeBareKitInstalled } from './verify/bare-kit-runtime.js';
+export { isMobileHost } from './verify/prebuilds.js';
+export { formatEnginesAdvice } from './verify/engines-advice.js';
+export type { EnginesAdvice, EnginesOverride, EnginesUpgrade } from './verify/engines-advice.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/commands/index.js

@@ -1,2 +1,8 @@
 export { bundleSdk } from './bundle/index.js';
+export { ensureHostPrebuilds } from './host-prebuilds/index.js';
 export { verifyBundle, hasErrors, hasWarnings, formatVerifyBundleResult } from './verify/index.js';
+export { HostPrebuildsInstallFailedError, HostPrebuildsInstallRefusedError } from '../utils/errors-client.js';
+export { formatRuntimeSource } from './verify/abi.js';
+export { isReactNativeBareKitInstalled } from './verify/bare-kit-runtime.js';
+export { isMobileHost } from './verify/prebuilds.js';
+export { formatEnginesAdvice } from './verify/engines-advice.js';

package/dist/src/commands/verify/abi.d.ts

@@ -1,7 +1,10 @@
 import { type NativeAddon } from './addon-source.js';
 export interface BareRuntime {
     version: string;
-    source: 'flag' | 'config' | 'bare-runtime' | 'bare';
+    source: 'flag' | 'config' | 'bare-runtime' | 'bare' | 'react-native-bare-kit';
+    /** Installed version of the package named by `source`, when it differs from `version`. */
+    packageVersion?: string;
+    detail?: string;
 }
 export interface UnresolvedBareRuntime {
     reason: string;
@@ -27,6 +30,15 @@ export interface AbiMismatchIssue {
     enginesBare: string;
     runtimeVersion: string;
 }
+/** A bundled package that is not an addon but still declares engines.bare. */
+export interface EnginesMismatchIssue {
+    code: 'engines-mismatch';
+    level: 'error';
+    package: string;
+    message: string;
+    enginesBare: string;
+    runtimeVersion: string;
+}
 export interface UnknownRuntimeIssue {
     code: 'unknown-runtime-version';
     level: 'warning';
@@ -40,13 +52,21 @@ export interface MalformedEnginesBareIssue {
     enginesBare: string;
     message: string;
 }
-export type AbiIssue = AbiMismatchIssue | UnknownRuntimeIssue | MalformedEnginesBareIssue;
+export type AbiIssue = AbiMismatchIssue | EnginesMismatchIssue | UnknownRuntimeIssue | MalformedEnginesBareIssue;
 export interface CheckAbiOptions {
     addons: NativeAddon[];
     runtime: BareRuntimeResolution;
+    /** Non-addon packages that declare engines.bare. */
+    packages?: EnginesPackage[] | undefined;
+}
+export interface EnginesPackage {
+    name: string;
+    version?: string;
+    enginesBare: string;
 }
 export declare function resolveBareRuntime(options: ResolveBareRuntimeOptions): Promise<BareRuntimeResolution>;
 export declare function normalizeVersion(value: string): string | null;
 export declare function formatConfigLabel(projectRoot: string, configPath?: string): string;
+export declare function formatRuntimeSource(runtime: BareRuntime): string;
 export declare function checkAbi(options: CheckAbiOptions): AbiIssue[];
 //# sourceMappingURL=abi.d.ts.map