@qvac/sdk 0.18.2 → 0.19.1

package/dist/src/commands/verify/node-modules-source.js

@@ -0,0 +1,76 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { deduplicateAddons, readAddonPackageJson } from './addon-source.js';
+export class InvalidNodeModulesSourceError extends Error {
+    nodeModulesPath;
+    constructor(nodeModulesPath, cause) {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        super(`node_modules at ${nodeModulesPath} could not be read.\n\n` +
+            `  Reason: ${reason}\n\n` +
+            '  Run `npm install` before invoking verifyBundle against a node_modules tree.');
+        this.name = 'InvalidNodeModulesSourceError';
+        this.nodeModulesPath = nodeModulesPath;
+    }
+}
+export async function collectAddonsFromNodeModules(options) {
+    const { nodeModulesRoot, diagnostics } = options;
+    const addons = [];
+    await walkNodeModules(nodeModulesRoot, addons, diagnostics, true);
+    return deduplicateAddons(addons);
+}
+async function walkNodeModules(nodeModulesDir, addons, diagnostics, isRoot) {
+    let entries;
+    try {
+        entries = await fsp.readdir(nodeModulesDir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isRoot)
+            throw new InvalidNodeModulesSourceError(nodeModulesDir, error);
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.'))
+            continue;
+        if (!isPackageEntry(entry))
+            continue;
+        if (entry.name.startsWith('@')) {
+            await walkScopeDirectory(path.join(nodeModulesDir, entry.name), addons, diagnostics);
+            continue;
+        }
+        await visitPackageDirectory(path.join(nodeModulesDir, entry.name), entry.name, addons, diagnostics);
+    }
+}
+async function walkScopeDirectory(scopeDir, addons, diagnostics) {
+    const scope = path.basename(scopeDir);
+    let entries;
+    try {
+        entries = await fsp.readdir(scopeDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.'))
+            continue;
+        if (!isPackageEntry(entry))
+            continue;
+        await visitPackageDirectory(path.join(scopeDir, entry.name), `${scope}/${entry.name}`, addons, diagnostics);
+    }
+}
+function isPackageEntry(entry) {
+    return entry.isDirectory() || entry.isSymbolicLink();
+}
+async function visitPackageDirectory(packageDir, packageName, addons, diagnostics) {
+    const result = await readAddonPackageJson({
+        packageJsonPath: path.join(packageDir, 'package.json'),
+        expectedName: packageName
+    });
+    if (result.isAddon && result.addon) {
+        addons.push(result.addon);
+    }
+    else if (result.invalid !== undefined && diagnostics !== undefined) {
+        diagnostics.invalidPackageJsons.push(result.invalid);
+    }
+    const nestedNodeModules = path.join(packageDir, 'node_modules');
+    await walkNodeModules(nestedNodeModules, addons, diagnostics, false);
+}

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

@@ -0,0 +1,16 @@
+import { type NativeAddon } from './addon-source.js';
+export interface MissingPrebuildIssue {
+    code: 'missing-prebuild';
+    level: 'error';
+    addon: string;
+    host: string;
+    message: string;
+    packageRoot: string;
+}
+export interface CheckPrebuildsOptions {
+    addon: NativeAddon;
+    hosts: string[];
+}
+export declare function checkPrebuilds(options: CheckPrebuildsOptions): Promise<MissingPrebuildIssue[]>;
+export declare function listBarePrebuildFiles(hostDir: string): Promise<string[]>;
+//# sourceMappingURL=prebuilds.d.ts.map

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

@@ -0,0 +1,36 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { formatAddonId } from './addon-source.js';
+export async function checkPrebuilds(options) {
+    const { addon, hosts } = options;
+    const issues = [];
+    for (const host of hosts) {
+        const hostDir = path.join(addon.packageRoot, 'prebuilds', host);
+        const present = (await listBarePrebuildFiles(hostDir)).length > 0;
+        if (!present) {
+            issues.push({
+                code: 'missing-prebuild',
+                level: 'error',
+                addon: formatAddonId(addon),
+                host,
+                packageRoot: addon.packageRoot,
+                message: `${formatAddonId(addon)} is missing a prebuild for ${host} ` +
+                    `(expected ${path.join(hostDir, '*.bare')}).`
+            });
+        }
+    }
+    return issues;
+}
+export async function listBarePrebuildFiles(hostDir) {
+    let entries;
+    try {
+        entries = await fsp.readdir(hostDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => (entry.isFile() || entry.isSymbolicLink()) && entry.name.endsWith('.bare'))
+        .map((entry) => path.resolve(hostDir, entry.name))
+        .sort();
+}

package/dist/src/commands/verify/resource-collectors.js

@@ -0,0 +1,261 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { createGzip } from 'node:zlib';
+import tarStream, {} from 'tar-stream';
+import { collectAddonsFromBundle } from './bundle-source.js';
+import { listBarePrebuildFiles } from './prebuilds.js';
+export const RESOURCE_COLLECTOR_PACKAGES = ['bare-cpu-info', 'bare-gpu-info'];
+export const RESOURCE_COLLECTOR_SIZE_BUDGETS = {
+    compressedBytes: 2 * 1024 * 1024,
+    uncompressedBytes: 5 * 1024 * 1024
+};
+const DEFAULT_MEASUREMENT_DEPENDENCIES = {
+    writeArchiveEntry
+};
+export async function acceptResourceCollectorPackaging(options) {
+    const addons = await collectAddonsFromBundle({
+        bundlePath: options.bundlePath,
+        projectRoot: options.projectRoot
+    });
+    const collectors = new Map(addons
+        .filter((addon) => isResourceCollectorPackage(addon.name))
+        .map((addon) => [addon.name, addon]));
+    const manifestResult = await readAddonsManifest(options.manifestPath);
+    const manifestAddons = new Set(manifestResult.manifest?.addons);
+    const issues = [];
+    const entriesByHost = new Map(options.hosts.map((host) => [host, []]));
+    const budgets = options.budgets ?? RESOURCE_COLLECTOR_SIZE_BUDGETS;
+    if (manifestResult.issue !== undefined)
+        issues.push(manifestResult.issue);
+    for (const packageName of RESOURCE_COLLECTOR_PACKAGES) {
+        const collector = collectors.get(packageName);
+        if (collector === undefined) {
+            issues.push({
+                code: 'missing-collector',
+                level: 'error',
+                package: packageName,
+                location: 'bundle',
+                message: `${packageName} is missing from the linked worker bundle graph.`
+            });
+        }
+        if (manifestResult.manifest !== undefined && !manifestAddons.has(packageName)) {
+            issues.push({
+                code: 'missing-collector',
+                level: 'error',
+                package: packageName,
+                location: 'manifest',
+                message: `${packageName} is missing from ${options.manifestPath}.`
+            });
+        }
+        if (collector === undefined)
+            continue;
+        for (const host of options.hosts) {
+            const hostDir = path.join(collector.packageRoot, 'prebuilds', host);
+            const files = await listBarePrebuildFiles(hostDir);
+            if (files.length === 0) {
+                issues.push({
+                    code: 'missing-prebuild',
+                    level: 'error',
+                    package: packageName,
+                    host,
+                    message: `${packageName} is missing a prebuild for ${host} ` +
+                        `(expected ${path.join(hostDir, '*.bare')}).`
+                });
+                continue;
+            }
+            for (const file of files) {
+                try {
+                    const contents = await fsp.readFile(file);
+                    entriesByHost.get(host)?.push({
+                        package: packageName,
+                        relativePath: normalizeArchivePath(path.relative(collector.packageRoot, file)),
+                        bytes: contents.byteLength,
+                        contents
+                    });
+                }
+                catch (error) {
+                    issues.push(measurementFailedIssue(packageName, host, error));
+                }
+            }
+        }
+    }
+    const targets = [];
+    for (const host of options.hosts) {
+        const entries = entriesByHost.get(host) ?? [];
+        entries.sort(compareMeasurementEntries);
+        try {
+            const target = await measureTarget(host, entries);
+            targets.push(target);
+            applyBudgets(target, budgets, issues);
+        }
+        catch (error) {
+            issues.push(measurementFailedIssue(entries[0]?.package ?? RESOURCE_COLLECTOR_PACKAGES[0], host, error));
+        }
+    }
+    return {
+        ok: issues.length === 0,
+        collectors: [...RESOURCE_COLLECTOR_PACKAGES],
+        hosts: [...options.hosts],
+        budgets,
+        targets,
+        issues
+    };
+}
+export function formatResourceCollectorAcceptanceReport(report) {
+    const lines = [
+        `Resource collector packaging: ${report.ok ? 'PASS' : 'FAIL'}`,
+        ...report.targets.map((target) => `${target.host}: ${target.compressedBytes} compressed / ` +
+            `${target.uncompressedBytes} uncompressed`),
+        `Budgets: ${formatMebibytes(report.budgets.compressedBytes)} compressed / ` +
+            `${formatMebibytes(report.budgets.uncompressedBytes)} uncompressed`
+    ];
+    for (const issue of report.issues) {
+        const details = [issue.code];
+        if ('host' in issue)
+            details.push(`host: ${issue.host}`);
+        if ('package' in issue)
+            details.push(`package: ${issue.package}`);
+        if ('actualBytes' in issue)
+            details.push(`actual: ${issue.actualBytes} bytes`);
+        if ('budgetBytes' in issue)
+            details.push(`limit: ${issue.budgetBytes} bytes`);
+        details.push(issue.message);
+        lines.push(`- ${details.join(' | ')}`);
+    }
+    return lines.join('\n');
+}
+function formatMebibytes(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MiB`;
+}
+function normalizeArchivePath(filePath) {
+    return filePath.replaceAll(path.sep, path.posix.sep);
+}
+function compareMeasurementEntries(left, right) {
+    const leftPath = `${left.package}/${left.relativePath}`;
+    const rightPath = `${right.package}/${right.relativePath}`;
+    if (leftPath < rightPath)
+        return -1;
+    if (leftPath > rightPath)
+        return 1;
+    return 0;
+}
+export async function measureTarget(host, entries, dependencies = DEFAULT_MEASUREMENT_DEPENDENCIES) {
+    const pack = tarStream.pack();
+    const gzip = createGzip({ level: 9 });
+    const compressedBytesPromise = countStreamBytes(gzip);
+    pack.pipe(gzip);
+    try {
+        for (const entry of entries) {
+            await dependencies.writeArchiveEntry(pack, entry);
+        }
+        pack.finalize();
+    }
+    catch (error) {
+        pack.destroy();
+        gzip.destroy();
+        await compressedBytesPromise.catch(() => { });
+        throw error;
+    }
+    return {
+        host,
+        files: entries.map(({ package: packageName, relativePath, bytes }) => ({
+            package: packageName,
+            relativePath,
+            bytes
+        })),
+        compressedBytes: await compressedBytesPromise,
+        uncompressedBytes: entries.reduce((total, entry) => total + entry.bytes, 0)
+    };
+}
+async function writeArchiveEntry(pack, entry) {
+    await new Promise((resolve, reject) => {
+        pack.entry({
+            name: `${entry.package}/${entry.relativePath}`,
+            mode: 0o644,
+            size: entry.bytes,
+            mtime: new Date(0)
+        }, entry.contents, (error) => {
+            if (error === null || error === undefined)
+                resolve();
+            else
+                reject(error);
+        });
+    });
+}
+async function countStreamBytes(stream) {
+    let bytes = 0;
+    for await (const chunk of stream)
+        bytes += Buffer.byteLength(chunk);
+    return bytes;
+}
+function applyBudgets(target, budgets, issues) {
+    if (target.compressedBytes > budgets.compressedBytes) {
+        issues.push({
+            code: 'compressed-budget-exceeded',
+            level: 'error',
+            host: target.host,
+            actualBytes: target.compressedBytes,
+            budgetBytes: budgets.compressedBytes,
+            message: `${target.host} resource collectors use ${target.compressedBytes} compressed bytes ` +
+                `(limit: ${budgets.compressedBytes}).`
+        });
+    }
+    if (target.uncompressedBytes > budgets.uncompressedBytes) {
+        issues.push({
+            code: 'uncompressed-budget-exceeded',
+            level: 'error',
+            host: target.host,
+            actualBytes: target.uncompressedBytes,
+            budgetBytes: budgets.uncompressedBytes,
+            message: `${target.host} resource collectors use ${target.uncompressedBytes} uncompressed bytes ` +
+                `(limit: ${budgets.uncompressedBytes}).`
+        });
+    }
+}
+function measurementFailedIssue(packageName, host, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    return {
+        code: 'measurement-failed',
+        level: 'error',
+        package: packageName,
+        host,
+        message: `Could not measure ${packageName} for ${host}: ${reason}.`
+    };
+}
+function isResourceCollectorPackage(packageName) {
+    return RESOURCE_COLLECTOR_PACKAGES.some((collector) => collector === packageName);
+}
+async function readAddonsManifest(manifestPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await fsp.readFile(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        return {
+            issue: invalidManifestIssue(manifestPath, error)
+        };
+    }
+    if (!isAddonsManifest(parsed)) {
+        return {
+            issue: invalidManifestIssue(manifestPath, 'manifest does not match the expected shape')
+        };
+    }
+    return { manifest: parsed };
+}
+function isAddonsManifest(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const manifest = value;
+    return (manifest['version'] === 1 &&
+        typeof manifest['bundleId'] === 'string' &&
+        Array.isArray(manifest['addons']) &&
+        manifest['addons'].every((addon) => typeof addon === 'string'));
+}
+function invalidManifestIssue(manifestPath, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    return {
+        code: 'invalid-manifest',
+        level: 'error',
+        message: `Could not read a valid addon manifest at ${manifestPath}: ${reason}.`
+    };
+}

package/dist/src/deprecate.d.ts

@@ -0,0 +1,2 @@
+export declare function deprecate(key: string, message: string): void;
+//# sourceMappingURL=deprecate.d.ts.map

package/dist/src/deprecate.js

@@ -0,0 +1,9 @@
+import { getServerLogger } from './logging/index.js';
+const warned = new Set();
+export function deprecate(key, message) {
+    if (warned.has(key))
+        return;
+    warned.add(key);
+    // enableConsole so the notice shows even in a worker with no log-stream subscriber.
+    getServerLogger({ enableConsole: true }).warn(`DEPRECATED: ${message}`);
+}

package/dist/src/expo/plugins/withAndroidNdkVersion.js

@@ -0,0 +1,31 @@
+import configPlugins from '@expo/config-plugins';
+import * as fs from 'fs';
+import * as path from 'path';
+const { withDangerousMod } = configPlugins;
+const DEFAULT_NDK_VERSION = '29.0.14206865';
+/**
+ * Expo plugin to set NDK version in android/build.gradle.
+ * Ensures NDK 29 is used to match the addon build version.
+ */
+function withAndroidNdkVersion(config) {
+    const ndkVersion = DEFAULT_NDK_VERSION;
+    return withDangerousMod(config, [
+        'android',
+        function (config) {
+            const buildGradlePath = path.join(config.modRequest.platformProjectRoot, 'build.gradle');
+            if (fs.existsSync(buildGradlePath)) {
+                let buildGradle = fs.readFileSync(buildGradlePath, 'utf8');
+                if (buildGradle.includes('ndkVersion')) {
+                    buildGradle = buildGradle.replace(/ndkVersion\s*=\s*["'][^"']+["']/g, `ndkVersion = "${ndkVersion}"`);
+                }
+                else {
+                    buildGradle = buildGradle.replace(/(buildscript\s*\{)/, `$1\n  ext {\n    ndkVersion = "${ndkVersion}"\n  }`);
+                }
+                fs.writeFileSync(buildGradlePath, buildGradle);
+                console.log(`[withAndroidNdkVersion] 🔧 QVAC: Set Android NDK version to ${ndkVersion}`);
+            }
+            return config;
+        }
+    ]);
+}
+export default withAndroidNdkVersion;

package/dist/src/expo/plugins/withDeviceInfo.js

@@ -0,0 +1,49 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveSDKPackageDir } from './resolve-sdk-package-dir.js';
+import { getProjectRootFromBaseConfig } from './get-project-root.js';
+let didRun = false;
+/**
+ * Expo plugin that stubs expo-device-info when expo-device is not a declared
+ * dependency of the consuming app. Expo autolinking resolves modules from
+ * package.json — if expo-device isn't listed there, the native module won't
+ * be linked and Metro may fail to resolve the JS import.
+ */
+function withDeviceInfo(config) {
+    if (didRun) {
+        return config;
+    }
+    didRun = true;
+    const projectRoot = getProjectRootFromBaseConfig(config);
+    if (!projectRoot) {
+        return config;
+    }
+    const { dir: qvacSdkPath } = resolveSDKPackageDir(projectRoot);
+    const appPackageJsonPath = path.join(projectRoot, 'package.json');
+    let hasExpoDevice = false;
+    if (fs.existsSync(appPackageJsonPath)) {
+        const appPackageJson = JSON.parse(fs.readFileSync(appPackageJsonPath, 'utf-8'));
+        hasExpoDevice =
+            'expo-device' in (appPackageJson.dependencies ?? {}) ||
+                'expo-device' in (appPackageJson.devDependencies ?? {});
+    }
+    if (!hasExpoDevice) {
+        const deviceInfoPath = path.join(qvacSdkPath, 'dist', 'client', 'rpc', 'expo-device-info.js');
+        if (fs.existsSync(deviceInfoPath)) {
+            fs.writeFileSync(deviceInfoPath, [
+                `"use strict";`,
+                `Object.defineProperty(exports, "__esModule", { value: true });`,
+                `async function getDeviceInfo() {`,
+                `  return { platform: undefined, deviceModel: undefined, deviceBrand: undefined };`,
+                `}`,
+                `exports.getDeviceInfo = getDeviceInfo;`
+            ].join('\n'));
+            console.log('[withDeviceInfo] 🔧 QVAC: expo-device not in app dependencies, stubbed device info');
+        }
+    }
+    else {
+        console.log('[withDeviceInfo] 🔧 QVAC: expo-device in app dependencies, using expo-device info');
+    }
+    return config;
+}
+export default withDeviceInfo;

package/dist/src/expo/plugins/withMobileBundle.d.ts

@@ -0,0 +1,31 @@
+import type { ExpoConfig } from 'expo/config';
+/**
+ * Desktop-only modules deferred so bare-pack stops walking into them. They back
+ * the advisory fit check, which mobile refuses at runtime, but the imports are
+ * static and pull in `bare-process` -> `bare-posix`, which ships no
+ * `android-arm64` prebuild and fails bundle verification.
+ */
+declare const MOBILE_UNSUPPORTED_MODULES: string[];
+declare const MOBILE_HOSTS: string[];
+type BareKitLinkerPaths = {
+    android: string | null;
+    ios: string | null;
+};
+/**
+ * Expo plugin: bundle, verify, then copy the mobile worker bundle.
+ *
+ * Flow: bundleSdk -> verifyBundle -> copy to `<sdkPackageDir>/dist/worker.mobile.bundle.js`.
+ * Uses `qvac.config.*` if present.
+ */
+declare function withMobileBundle(config: ExpoConfig): ExpoConfig;
+/** Runs the patched iOS linker after bundleSdk has written the current addons manifest. */
+declare function runIOSAddonLinker(linkerPath: string): Promise<void>;
+/**
+ * Patches react-native-bare-kit linkers to use the addons manifest and returns
+ * the paths for each platform that was successfully patched.
+ */
+declare function patchBareKitLinkers(projectRoot: string, qvacSdkPath: string): BareKitLinkerPaths;
+export { MOBILE_HOSTS, MOBILE_UNSUPPORTED_MODULES, patchBareKitLinkers, runIOSAddonLinker };
+export type { BareKitLinkerPaths };
+export default withMobileBundle;
+//# sourceMappingURL=withMobileBundle.d.ts.map

package/dist/src/expo/plugins/withMobileBundle.js

@@ -0,0 +1,163 @@
+import configPlugins from '@expo/config-plugins';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execPath } from 'process';
+import { bundleSdk, verifyBundle, hasErrors, formatVerifyBundleResult } from '../../commands/index.js';
+import { CONFIG_CANDIDATES } from '../../client/config-loader/resolve-config.node.js';
+import { resolveSDKPackageDir } from './resolve-sdk-package-dir.js';
+import { getProjectRootFromMod } from './get-project-root.js';
+import { findInAncestorNodeModules } from './find-in-ancestor-node-modules.js';
+import { BundleVerificationFailedError } from '../../utils/errors-client.js';
+const { withDangerousMod } = configPlugins;
+/** Modules to defer from mobile bundles (not available at bundle time) */
+const DEFERRED_MODULES = ['expo-file-system', 'react-native-bare-kit'];
+/**
+ * Desktop-only modules deferred so bare-pack stops walking into them. They back
+ * the advisory fit check, which mobile refuses at runtime, but the imports are
+ * static and pull in `bare-process` -> `bare-posix`, which ships no
+ * `android-arm64` prebuild and fails bundle verification.
+ */
+const MOBILE_UNSUPPORTED_MODULES = ['bare-runtime/spawn', '@qvac/model-fit/process'];
+const MOBILE_HOSTS = ['android-arm64', 'ios-arm64', 'ios-arm64-simulator', 'ios-x64-simulator'];
+/**
+ * Expo plugin: bundle, verify, then copy the mobile worker bundle.
+ *
+ * Flow: bundleSdk -> verifyBundle -> copy to `<sdkPackageDir>/dist/worker.mobile.bundle.js`.
+ * Uses `qvac.config.*` if present.
+ */
+function withMobileBundle(config) {
+    async function buildMobileBundle(config) {
+        const projectRoot = getProjectRootFromMod(config);
+        const sdkPackage = resolveSDKPackageDir(projectRoot);
+        const outputPath = path.join(sdkPackage.dir, 'dist', 'worker.mobile.bundle.js');
+        const configPath = findConfigFile(projectRoot);
+        if (configPath) {
+            console.log(`🕚 QVAC: Found ${path.basename(configPath)}, generating tree-shaken bundle...`);
+        }
+        else {
+            console.log('🕚 QVAC: No config found, generating default bundle (all plugins)...');
+        }
+        const deferredModules = [
+            ...DEFERRED_MODULES,
+            ...MOBILE_UNSUPPORTED_MODULES,
+            `${sdkPackage.name}/worker.mobile.bundle`
+        ];
+        const linkerPaths = await runBundler(projectRoot, sdkPackage.dir, configPath, deferredModules);
+        const generatedBundle = path.join(projectRoot, 'qvac', 'worker.bundle.js');
+        await runVerifier(projectRoot, generatedBundle, configPath);
+        fs.copyFileSync(generatedBundle, outputPath);
+        if (config.modRequest.platform === 'ios' && linkerPaths.ios !== null) {
+            await runIOSAddonLinker(linkerPaths.ios);
+        }
+        console.log('🫡 QVAC: Mobile bundle generated and verified');
+        return config;
+    }
+    config = withDangerousMod(config, ['android', buildMobileBundle]);
+    config = withDangerousMod(config, ['ios', buildMobileBundle]);
+    return config;
+}
+/** Finds qvac.config.* file in project root */
+function findConfigFile(projectRoot) {
+    for (const candidate of CONFIG_CANDIDATES) {
+        const configPath = path.join(projectRoot, candidate);
+        if (fs.existsSync(configPath)) {
+            return configPath;
+        }
+    }
+    return null;
+}
+async function runVerifier(projectRoot, generatedBundle, configPath) {
+    if (!configPath) {
+        console.log('⚠️ QVAC: no qvac.config.* found — Bare runtime will be auto-detected ' +
+            'from node_modules (bare-runtime, then bare). Add qvac.config.json ' +
+            'with `bareRuntimeVersion` to pin ABI checks deterministically.');
+    }
+    const result = await verifyBundle({
+        projectRoot,
+        addonsSource: generatedBundle,
+        hosts: MOBILE_HOSTS,
+        ...(configPath ? { configPath } : {})
+    });
+    if (hasErrors(result)) {
+        throw new BundleVerificationFailedError(generatedBundle, new Error(formatVerifyBundleResult(result)));
+    }
+}
+async function runBundler(projectRoot, qvacSdkPath, configPath, deferredModules) {
+    const linkerPaths = patchBareKitLinkers(projectRoot, qvacSdkPath);
+    await bundleSdk({
+        projectRoot,
+        sdkPath: qvacSdkPath,
+        ...(configPath ? { configPath } : {}),
+        hosts: MOBILE_HOSTS,
+        defer: deferredModules,
+        quiet: true
+    });
+    return linkerPaths;
+}
+/** Runs the patched iOS linker after bundleSdk has written the current addons manifest. */
+async function runIOSAddonLinker(linkerPath) {
+    await new Promise((resolve, reject) => {
+        const proc = spawn(execPath, [linkerPath], {
+            stdio: ['ignore', 'inherit', 'pipe']
+        });
+        let stderr = '';
+        proc.stderr.setEncoding('utf8');
+        proc.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const details = stderr.trim();
+            reject(new Error(`QVAC: iOS native addon linker exited with code ${code ?? 1}${details ? `: ${details}` : ''}`));
+        });
+        proc.on('error', reject);
+    });
+    console.log('✅ QVAC: Refreshed iOS native addons from the generated manifest');
+}
+/**
+ * Patches react-native-bare-kit linkers to use the addons manifest and returns
+ * the paths for each platform that was successfully patched.
+ */
+function patchBareKitLinkers(projectRoot, qvacSdkPath) {
+    const bareKitPath = findInAncestorNodeModules(projectRoot, 'react-native-bare-kit');
+    if (bareKitPath === null) {
+        console.warn('⚠️ QVAC: react-native-bare-kit not found in any ancestor node_modules, ' +
+            'skipping linker patch. The bundle will link all native addons ' +
+            'rather than only those required by your bundle.');
+        return { android: null, ios: null };
+    }
+    const patchesDir = path.join(qvacSdkPath, 'src', 'expo', 'plugins', 'patches');
+    if (!fs.existsSync(patchesDir)) {
+        console.log(`⚠️ QVAC: patches directory not found (${patchesDir}), skipping linker patch`);
+        return { android: null, ios: null };
+    }
+    const androidPatch = path.join(patchesDir, 'android-link.mjs');
+    const androidTarget = path.join(bareKitPath, 'android', 'link.mjs');
+    let androidLinkerPath = null;
+    if (fs.existsSync(androidPatch)) {
+        fs.copyFileSync(androidPatch, androidTarget);
+        console.log('✅ QVAC: Patched android/link.mjs for manifest-aware linking');
+        androidLinkerPath = androidTarget;
+    }
+    else {
+        console.log(`⚠️ QVAC: Android linker patch not found (${androidPatch})`);
+    }
+    const iosPatch = path.join(patchesDir, 'ios-link.mjs');
+    const iosTarget = path.join(bareKitPath, 'ios', 'link.mjs');
+    let iosLinkerPath = null;
+    if (fs.existsSync(iosPatch)) {
+        fs.copyFileSync(iosPatch, iosTarget);
+        console.log('✅ QVAC: Patched ios/link.mjs for manifest-aware linking');
+        iosLinkerPath = iosTarget;
+    }
+    else {
+        console.log(`⚠️ QVAC: iOS linker patch not found (${iosPatch})`);
+    }
+    return { android: androidLinkerPath, ios: iosLinkerPath };
+}
+export { MOBILE_HOSTS, MOBILE_UNSUPPORTED_MODULES, patchBareKitLinkers, runIOSAddonLinker };
+export default withMobileBundle;