@qvac/sdk 0.20.1 → 0.21.0

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

package/dist/src/commands/verify/abi.js

@@ -70,30 +70,37 @@ export function formatConfigLabel(projectRoot, configPath) {
         return configPath;
     return rel;
 }
+export function formatRuntimeSource(runtime) {
+    return runtime.detail === undefined ? runtime.source : `${runtime.source}: ${runtime.detail}`;
+}
 export function checkAbi(options) {
-    const { addons, runtime } = options;
-    const addonsWithEngines = addons.filter((addon) => addon.enginesBare !== undefined);
-    if (addonsWithEngines.length === 0)
+    const { addons, runtime, packages = [] } = options;
+    const constrained = [
+        ...addons.map((addon) => ({
+            id: formatAddonId(addon),
+            range: addon.enginesBare,
+            isAddon: true
+        })),
+        ...packages.map((pkg) => ({ id: formatAddonId(pkg), range: pkg.enginesBare, isAddon: false }))
+    ].filter((entry) => !!entry.range);
+    if (constrained.length === 0)
         return [];
     const issues = [];
     const checkable = [];
-    for (const addon of addonsWithEngines) {
-        const range = addon.enginesBare;
-        if (!range)
-            continue;
-        if (!semver.validRange(range)) {
+    for (const entry of constrained) {
+        if (!semver.validRange(entry.range)) {
             issues.push({
                 code: 'malformed-engines-bare',
                 level: 'warning',
-                addon: formatAddonId(addon),
-                enginesBare: range,
-                message: `${formatAddonId(addon)} declares engines.bare "${range}", which is ` +
-                    'not a valid semver range. ABI check skipped for this addon. ' +
-                    'Report this to the addon maintainer.'
+                addon: entry.id,
+                enginesBare: entry.range,
+                message: `${entry.id} declares engines.bare "${entry.range}", which is ` +
+                    `not a valid semver range. ABI check skipped for this ${entry.isAddon ? 'addon' : 'package'}. ` +
+                    'Report this to the package maintainer.'
             });
             continue;
         }
-        checkable.push({ addon, range });
+        checkable.push(entry);
     }
     if (checkable.length === 0)
         return issues;
@@ -102,24 +109,39 @@ export function checkAbi(options) {
             code: 'unknown-runtime-version',
             level: 'warning',
             message: `${runtime.error.reason}. ABI checks skipped for ${checkable.length} ` +
-                `addon${checkable.length === 1 ? '' : 's'}. ` +
-                'Pass bareRuntimeVersion to enable strict ABI verification.',
+                `package${checkable.length === 1 ? '' : 's'}. ` +
+                'For mobile hosts, install react-native-bare-kit; for a desktop build, ' +
+                'install bare-runtime or pass bareRuntimeVersion.',
             triedPaths: runtime.error.triedPaths
         });
         return issues;
     }
-    for (const { addon, range } of checkable) {
-        if (semver.satisfies(runtime.runtime.version, range))
+    const { version } = runtime.runtime;
+    for (const entry of checkable) {
+        if (semver.satisfies(version, entry.range))
             continue;
-        issues.push({
-            code: 'abi-mismatch',
-            level: 'error',
-            addon: formatAddonId(addon),
-            enginesBare: range,
-            runtimeVersion: runtime.runtime.version,
-            message: `${formatAddonId(addon)} requires bare ${range}, ` +
-                `runtime is ${runtime.runtime.version} (from ${runtime.runtime.source}).`
-        });
+        const message = `${entry.id} requires bare ${entry.range}, ` +
+            `runtime is ${version} (from ${formatRuntimeSource(runtime.runtime)}).`;
+        if (entry.isAddon) {
+            issues.push({
+                code: 'abi-mismatch',
+                level: 'error',
+                addon: entry.id,
+                enginesBare: entry.range,
+                runtimeVersion: version,
+                message
+            });
+        }
+        else {
+            issues.push({
+                code: 'engines-mismatch',
+                level: 'error',
+                package: entry.id,
+                enginesBare: entry.range,
+                runtimeVersion: version,
+                message
+            });
+        }
     }
     return issues;
 }

package/dist/src/commands/verify/addon-source.d.ts

@@ -19,6 +19,19 @@ export interface AddonPackageJson {
     engines?: {
         bare?: string;
     };
+    dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+}
+/** Any package in the collected graph, addon or not. */
+export interface PackageRecord {
+    name: string;
+    version?: string;
+    packageJsonPath: string;
+    isAddon: boolean;
+    enginesBare?: string;
+    /** Declared ranges of every dependency kind, keyed by dependency name. */
+    dependencies: Record<string, string>;
 }
 export interface ReadAddonPackageJsonOptions {
     packageJsonPath: string;
@@ -34,13 +47,22 @@ export interface ReadAddonPackageJsonResult {
     isAddon: boolean;
     invalid?: InvalidPackageJsonRecord;
     addon?: NativeAddon;
+    record?: PackageRecord;
 }
 export declare function readAddonPackageJson(options: ReadAddonPackageJsonOptions): Promise<ReadAddonPackageJsonResult>;
 export interface CollectDiagnostics {
     invalidPackageJsons: InvalidPackageJsonRecord[];
     emptyResolutions: boolean;
+    /** Every readable package the collector visited, in visit order. */
+    packages: PackageRecord[];
 }
 export declare function createCollectDiagnostics(): CollectDiagnostics;
+/**
+ * Caps concurrent filesystem calls so a large node_modules tree is read in
+ * parallel without exhausting file descriptors.
+ */
+export declare function createLimiter(max: number): <T>(task: () => Promise<T>) => Promise<T>;
+export declare const FS_CONCURRENCY = 32;
 export declare function formatAddonId(addon: {
     name: string;
     version?: string;

package/dist/src/commands/verify/addon-source.js

@@ -29,8 +29,11 @@ export async function readAddonPackageJson(options) {
         };
     }
     const pkg = parsed;
+    const record = buildRecord(pkg, packageJsonPath, expectedName);
     if (pkg.addon !== true) {
-        return { found: true, isAddon: false };
+        return record === null
+            ? { found: true, isAddon: false }
+            : { found: true, isAddon: false, record };
     }
     const name = pkg.name ?? expectedName;
     if (!name) {
@@ -49,7 +52,39 @@ export async function readAddonPackageJson(options) {
         addon.version = pkg.version;
     if (typeof pkg.engines?.bare === 'string')
         addon.enginesBare = pkg.engines.bare;
-    return { found: true, isAddon: true, addon };
+    return record === null
+        ? { found: true, isAddon: true, addon }
+        : { found: true, isAddon: true, addon, record };
+}
+function stringRecord(value) {
+    const out = {};
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return out;
+    for (const [key, range] of Object.entries(value)) {
+        if (typeof range === 'string')
+            out[key] = range;
+    }
+    return out;
+}
+function buildRecord(pkg, packageJsonPath, expectedName) {
+    const name = typeof pkg.name === 'string' ? pkg.name : expectedName;
+    if (!name)
+        return null;
+    const record = {
+        name,
+        packageJsonPath,
+        isAddon: pkg.addon === true,
+        dependencies: {
+            ...stringRecord(pkg.peerDependencies),
+            ...stringRecord(pkg.optionalDependencies),
+            ...stringRecord(pkg.dependencies)
+        }
+    };
+    if (typeof pkg.version === 'string')
+        record.version = pkg.version;
+    if (typeof pkg.engines?.bare === 'string')
+        record.enginesBare = pkg.engines.bare;
+    return record;
 }
 function buildInvalid(packageJsonPath, expectedName, reason) {
     const record = { packageJsonPath, reason };
@@ -58,8 +93,39 @@ function buildInvalid(packageJsonPath, expectedName, reason) {
     return record;
 }
 export function createCollectDiagnostics() {
-    return { invalidPackageJsons: [], emptyResolutions: false };
+    return { invalidPackageJsons: [], emptyResolutions: false, packages: [] };
+}
+/**
+ * Caps concurrent filesystem calls so a large node_modules tree is read in
+ * parallel without exhausting file descriptors.
+ */
+export function createLimiter(max) {
+    let active = 0;
+    const queue = [];
+    // A finishing task hands its slot straight to the next waiter, so a caller
+    // arriving in between cannot take it as well.
+    function release() {
+        const next = queue.shift();
+        if (next)
+            next();
+        else
+            active--;
+    }
+    async function run(task) {
+        if (active >= max)
+            await new Promise((resolve) => queue.push(resolve));
+        else
+            active++;
+        try {
+            return await task();
+        }
+        finally {
+            release();
+        }
+    }
+    return run;
 }
+export const FS_CONCURRENCY = 32;
 export function formatAddonId(addon) {
     return `${addon.name}@${addon.version ?? 'unknown'}`;
 }

package/dist/src/commands/verify/bare-kit-runtime.d.ts

@@ -0,0 +1,38 @@
+import type { BareRuntimeResolution } from './abi.js';
+export declare const REACT_NATIVE_BARE_KIT = "react-native-bare-kit";
+export declare const NETWORK_TIMEOUT_MS = 5000;
+export type FetchText = (url: string) => Promise<string>;
+export type ProgressFn = (message: string) => void;
+export interface ResolveMobileBareRuntimeOptions {
+    projectRoot: string;
+    network?: boolean | undefined;
+    onProgress?: ProgressFn | undefined;
+    fetchText?: FetchText | undefined;
+}
+export declare function isReactNativeBareKitInstalled(projectRoot: string): boolean;
+export declare function fetchText(url: string): Promise<string>;
+export declare function parseBareKitReleaseVersion(cmakeLists: string): string | null;
+export declare function parseBareVersion(cmakeLists: string): string | null;
+export declare function parseInfoPlistVersion(plist: string): string | null;
+export declare function fetchBareKitVersionFromGitHub(reactNativeBareKitVersion: string, fetch?: FetchText): Promise<string | null>;
+export declare function fetchBareVersionFromGitHub(bareKitVersion: string, fetch?: FetchText): Promise<string | null>;
+export declare function bareVersionForBareKit(bareKitVersion: string): string | null;
+/**
+ * The oldest react-native-bare-kit release newer than `currentVersion` whose
+ * embedded Bare satisfies every range, or null if the table has none.
+ */
+export declare function findReactNativeBareKitUpgrade(currentVersion: string, ranges: string[]): {
+    version: string;
+    bareKit: string;
+    bare: string;
+} | null;
+/**
+ * Bare version the app runs on mobile: the one compiled into the bare-kit
+ * binaries that react-native-bare-kit ships, not any `bare-runtime` package
+ * in node_modules.
+ *
+ * Checks the built-in table, then the installed iOS framework's Info.plist,
+ * and only then GitHub.
+ */
+export declare function resolveMobileBareRuntime(options: ResolveMobileBareRuntimeOptions): Promise<BareRuntimeResolution>;
+//# sourceMappingURL=bare-kit-runtime.d.ts.map