@qvac/sdk 0.18.2 → 0.19.0

package/dist/client/rpc/rpc-error.js

@@ -1,150 +0,0 @@
-import { ContextOverflowError, RequestIdConflictError, RequestNotFoundError, RequestRejectedByPolicyError, TranslationFailedError } from '../../utils/errors-server.js';
-export class RPCError extends Error {
-    timestamp;
-    remoteStack;
-    code;
-    cause;
-    isQvacError;
-    constructor(errorResponse) {
-        super(errorResponse.message);
-        // If this was originally a QvacError, preserve its structure
-        if (errorResponse.name && errorResponse.code) {
-            this.name = errorResponse.name;
-            this.code = errorResponse.code;
-            this.cause = errorResponse.cause;
-            this.isQvacError = true;
-        }
-        else {
-            this.name = 'RPCError';
-            this.isQvacError = false;
-        }
-        if (errorResponse.timestamp) {
-            this.timestamp = errorResponse.timestamp;
-        }
-        if (errorResponse.stack) {
-            this.remoteStack = errorResponse.stack;
-            this.stack = `${this.stack}\n--- Worker Stack ---\n${errorResponse.stack}`;
-        }
-    }
-    toJSON() {
-        return {
-            name: this.name,
-            code: this.code,
-            message: this.message,
-            stack: this.stack,
-            cause: this.cause,
-            timestamp: this.timestamp,
-            isQvacError: this.isQvacError
-        };
-    }
-}
-/**
- * Attach the remote stack onto a reconstructed typed error so the
- * client-side trace points at the consumer call site and the worker-
- * side trace is preserved for debugging. Mirrors the behaviour
- * `RPCError`'s constructor applies in the fall-through path.
- */
-function attachRemoteContext(err, response) {
-    if (response.stack) {
-        ;
-        err.remoteStack = response.stack;
-        err.stack = `${err.stack}\n--- Worker Stack ---\n${response.stack}`;
-    }
-    if (response.timestamp) {
-        ;
-        err.timestamp = response.timestamp;
-    }
-    return err;
-}
-/** Read a string field from the `typedFields` envelope, defaulting to `fallback` if missing or non-string. */
-function readStringField(fields, key, fallback) {
-    const value = fields?.[key];
-    return typeof value === 'string' ? value : fallback;
-}
-/** Read a number field from the `typedFields` envelope, returning `undefined` if missing or non-number. */
-function readOptionalNumberField(fields, key) {
-    const value = fields?.[key];
-    return typeof value === 'number' ? value : undefined;
-}
-/** Read a string field, returning `undefined` (not a fallback string) if missing. */
-function readOptionalStringField(fields, key) {
-    const value = fields?.[key];
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-/**
- * Map of server-thrown `QvacErrorBase` subclasses that need to survive
- * the RPC boundary as their original class — `err instanceof
- * RequestRejectedByPolicyError` on the consumer side must match the
- * class re-exported from `@qvac/sdk`.
- *
- * **Key shape.** The key is the `name` value `QvacErrorBase` sets at
- * construction time, which `createErrorResponse` forwards onto
- * `response.name`. That value is the SCREAMING_SNAKE_CASE error-code
- * name from `sdk-errors-server.ts` (`"REQUEST_REJECTED_BY_POLICY"`),
- * **not** the JS class name (`"RequestRejectedByPolicyError"`). The
- * mismatch was a 0.11.0 bring-up bug fixed alongside the reconstructor
- * unit tests in `rpc-error-reconstruct.test.ts`.
- *
- * **Maintenance contract.** Every new cross-RPC server-thrown typed
- * error class added in `errors-server.ts` adds a row here in the same
- * PR, keyed by its `SDK_SERVER_ERROR_CODES.<NAME>` constant. The
- * class must (a) implement `toErrorResponseFields(): Record<…>` so
- * the wire envelope carries its named constructor arguments and (b)
- * be re-exported from `@qvac/sdk` so consumers can `import` it.
- * Forgetting either side means `instanceof` regresses for that class.
- *
- * Client-constructed typed errors (e.g. `InferenceCancelledError`
- * built in `client/api/completion-stream.ts` from the aggregated
- * partial state) are NOT registered here — they never round-trip the
- * envelope, and adding a reconstructor for one would create a
- * parallel construction path that fires whenever the server happens
- * to throw the same class name.
- */
-const RECONSTRUCTORS = {
-    REQUEST_ID_CONFLICT: (response) => {
-        return new RequestIdConflictError(readStringField(response.typedFields, 'requestId', ''), response.cause);
-    },
-    REQUEST_NOT_FOUND: (response) => {
-        return new RequestNotFoundError(readStringField(response.typedFields, 'requestId', ''), response.cause);
-    },
-    REQUEST_REJECTED_BY_POLICY: (response) => {
-        return new RequestRejectedByPolicyError(readStringField(response.typedFields, 'requestId', ''), readStringField(response.typedFields, 'kind', ''), readStringField(response.typedFields, 'modelId', ''), readStringField(response.typedFields, 'reason', response.message), response.cause);
-    },
-    CONTEXT_OVERFLOW: (response) => {
-        return new ContextOverflowError(readOptionalNumberField(response.typedFields, 'promptTokens'), readOptionalNumberField(response.typedFields, 'ctxSize'), readOptionalStringField(response.typedFields, 'modelId'), response.cause);
-    },
-    // Source-language autodetect now fails server-side (translate detection moved
-    // into the worker), so this crosses the RPC and reconstructs as the typed
-    // class -- matching the Python client's reconstructor.
-    TRANSLATION_FAILED: (response) => {
-        return new TranslationFailedError(response.message, response.cause);
-    }
-};
-/**
- * Rebuild the original server-thrown typed error from its serialised
- * envelope so consumer code can do
- * `if (err instanceof RequestRejectedByPolicyError) { ... }` across
- * the RPC boundary. Unknown error names fall through to the legacy
- * `RPCError` wrapper, which preserves `name`/`code`/`message` for
- * code-based predicates.
- */
-export function reconstructError(response) {
-    const reconstructor = response.name ? RECONSTRUCTORS[response.name] : undefined;
-    if (!reconstructor) {
-        return new RPCError(response);
-    }
-    try {
-        return attachRemoteContext(reconstructor(response), response);
-    }
-    catch {
-        // Defensive fall-through: if a reconstructor throws (e.g. a
-        // future class adds a required constructor field and an older
-        // server doesn't ship `typedFields`), surface the original error
-        // via `RPCError` so consumers never see "couldn't reconstruct
-        // error" obscuring the real one. The reconstructors here are
-        // intentionally written to coerce missing fields to defensible
-        // defaults (`String(x ?? "")`), so reaching this branch is the
-        // edge case, not the norm.
-        return new RPCError(response);
-    }
-}

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

@@ -1,54 +0,0 @@
-import { parseBuiltinSpecifier } from '../../commands/bundle/plugins.js';
-export function generateWorkerEntry(pluginSpecifiers, sdkName, resolveImport = (specifier) => specifier) {
-    const imports = [];
-    const registrations = [];
-    let varIndex = 0;
-    for (const specifier of pluginSpecifiers) {
-        const builtin = parseBuiltinSpecifier(specifier, sdkName);
-        if (builtin) {
-            imports.push(`import { ${builtin.exportName} } from "${resolveImport(`${sdkName}/${builtin.suffix}/plugin`)}";`);
-            registrations.push(`registerPlugin(${builtin.exportName});`);
-        }
-        else {
-            const varName = `customPlugin${varIndex++}`;
-            imports.push(`import ${varName} from "${resolveImport(specifier)}";`);
-            registrations.push(`registerPlugin(${varName});`);
-        }
-    }
-    const importsStr = imports.join('\n');
-    const registrationsStr = registrations.join('\n');
-    const pluginsList = pluginSpecifiers.map((p) => `*   - ${p}`).join('\n');
-    return `/**
- * QVAC SDK Worker Entry (auto-generated)
- * Generated by: @qvac/sdk/commands bundleSdk
- * Plugins: ${pluginSpecifiers.length}
- *
-${pluginsList}
- */
-
-import { initializeWorkerCore, ensureRPCSetup } from "${resolveImport(`${sdkName}/worker-core`)}";
-import { registerPlugin } from "${resolveImport(`${sdkName}/plugins`)}";
-import { getServerLogger } from "${resolveImport(`${sdkName}/logging`)}";
-
-${importsStr}
-
-const { hasRPCConfig } = initializeWorkerCore();
-
-const logger = getServerLogger();
-logger.info("🐻 QVAC Worker (custom bundle)");
-logger.info("📦 Plugins: ${pluginSpecifiers.length}");
-
-${registrationsStr}
-
-// Auto-setup RPC if config present
-if (hasRPCConfig) {
-  ensureRPCSetup();
-}
-`;
-}
-export function generateWorkerEntries(pluginSpecifiers, sdkName, resolveBundleImport) {
-    return {
-        runtimeEntry: generateWorkerEntry(pluginSpecifiers, sdkName),
-        bundleEntry: generateWorkerEntry(pluginSpecifiers, sdkName, resolveBundleImport)
-    };
-}

package/dist/commands/bundle/index.js

@@ -1,148 +0,0 @@
-import fs, { promises as fsp } from 'node:fs';
-import path from 'node:path';
-import { createRequire } from 'node:module';
-import { DEFAULT_HOSTS, DEFAULT_SDK_NAME } from '../../commands/bundle/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 { resolvePluginSpecifiers, parseBuiltinSpecifier } from '../../commands/bundle/plugins.js';
-import { generateWorkerEntries } from '../../commands/bundle/entry-gen.js';
-import { runBarePack } from '../../commands/bundle/bare-pack.js';
-import { generateAddonsManifest } from '../../commands/bundle/manifest.js';
-import { createSdkImportResolver } from '../../commands/bundle/resolve-sdk-import.js';
-const require = createRequire(import.meta.url);
-function resolveSdkPath(projectRoot, explicitSdkPath) {
-    if (explicitSdkPath) {
-        return path.isAbsolute(explicitSdkPath)
-            ? explicitSdkPath
-            : path.join(projectRoot, explicitSdkPath);
-    }
-    try {
-        const pkgJsonPath = require.resolve('@qvac/sdk/package.json', {
-            paths: [projectRoot]
-        });
-        return path.dirname(pkgJsonPath);
-    }
-    catch {
-        return path.join(projectRoot, 'node_modules', '@qvac', 'sdk');
-    }
-}
-async function resolveSdkName(sdkPath) {
-    const sdkPackageJsonPath = path.join(sdkPath, 'package.json');
-    try {
-        if (fs.existsSync(sdkPackageJsonPath)) {
-            const content = await fsp.readFile(sdkPackageJsonPath, 'utf8');
-            const pkg = JSON.parse(content);
-            if (pkg.name)
-                return pkg.name;
-        }
-    }
-    catch {
-        // Fall through to default
-    }
-    return DEFAULT_SDK_NAME;
-}
-function resolveImportsMapPath(sdkPath, sdkName) {
-    const importsMapPath = path.join(sdkPath, 'bare-imports.json');
-    if (fs.existsSync(importsMapPath)) {
-        return importsMapPath;
-    }
-    throw new BareImportsMapNotFoundError(sdkName, importsMapPath);
-}
-function createCommandLogger(options) {
-    if (options.quiet) {
-        return getClientLogger({ level: 'error', enableConsole: false });
-    }
-    if (options.verbose) {
-        return getClientLogger({ level: 'debug' });
-    }
-    return getClientLogger();
-}
-export async function bundleSdk(options = {}) {
-    const startTime = Date.now();
-    const projectRoot = options.projectRoot ?? process.cwd();
-    const outputDir = path.join(projectRoot, 'qvac');
-    const entryPath = path.join(outputDir, 'worker.entry.mjs');
-    const bundleEntryPath = path.join(outputDir, 'worker.bundle.entry.mjs');
-    const bundlePath = path.join(outputDir, 'worker.bundle.js');
-    const logger = createCommandLogger(options);
-    logger.info('🔧 QVAC SDK Worker Bundler\n');
-    const { configPath, config } = await resolveConfigForProject(projectRoot, options.configPath);
-    if (configPath) {
-        logger.info(`📄 Config: ${path.relative(projectRoot, configPath)}`);
-    }
-    else {
-        logger.info('📄 Config: (none)');
-        logger.warn('No config file found — continuing with defaults.');
-        logger.info('   To customize bundling, create one of:\n' +
-            CONFIG_CANDIDATES.map((c) => `     - ${c}`).join('\n') +
-            '\n');
-    }
-    const sdkPath = resolveSdkPath(projectRoot, options.sdkPath);
-    const sdkName = await resolveSdkName(sdkPath);
-    logger.info(`📦 SDK: ${sdkName}`);
-    logger.debug(`   Path: ${sdkPath}`);
-    const importsMapPath = resolveImportsMapPath(sdkPath, sdkName);
-    const pluginSpecifiers = resolvePluginSpecifiers(config, sdkName, logger);
-    logger.info(`\n📦 Plugins to include (${pluginSpecifiers.length}):`);
-    for (const spec of pluginSpecifiers) {
-        const label = parseBuiltinSpecifier(spec, sdkName) ? '✓ built-in' : '⊕ custom';
-        logger.info(`   ${label}: ${spec}`);
-    }
-    const hosts = options.hosts && options.hosts.length > 0 ? options.hosts : DEFAULT_HOSTS;
-    const deferModules = options.defer ?? [];
-    await fsp.mkdir(outputDir, { recursive: true });
-    logger.info('\n📝 Generating worker entry...');
-    const resolveSdkImport = createSdkImportResolver(sdkPath, sdkName);
-    const { runtimeEntry, bundleEntry } = generateWorkerEntries(pluginSpecifiers, sdkName, resolveSdkImport);
-    await fsp.writeFile(entryPath, runtimeEntry, 'utf8');
-    logger.info(`   Created: ${path.relative(projectRoot, entryPath)}`);
-    logger.info(`   Using: ${path.relative(projectRoot, importsMapPath)}`);
-    logger.info('\n🔨 Bundling with bare-pack...');
-    logger.debug(`   Hosts: ${hosts.join(', ')}`);
-    if (deferModules.length > 0) {
-        logger.debug(`   Deferred: ${deferModules.join(', ')}`);
-    }
-    try {
-        await fsp.writeFile(bundleEntryPath, bundleEntry, 'utf8');
-        await runBarePack({
-            entryPath: bundleEntryPath,
-            outputPath: bundlePath,
-            hosts,
-            importsMapPath,
-            deferModules,
-            quiet: options.quiet === true,
-            logger
-        });
-    }
-    finally {
-        await fsp.rm(bundleEntryPath, { force: true });
-    }
-    const stats = await fsp.stat(bundlePath);
-    const sizeKB = (stats.size / 1024).toFixed(1);
-    logger.info(`\n✅ Bundle created: ${path.relative(projectRoot, bundlePath)}`);
-    logger.info(`   Size: ${sizeKB} KB`);
-    const manifestResult = await generateAddonsManifest({
-        bundlePath,
-        outputDir,
-        projectRoot,
-        logger
-    });
-    const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
-    logger.info(`\n🎉 Done in ${elapsed}s!\n`);
-    logger.info('Generated files:');
-    logger.info('  - qvac/worker.entry.mjs    (standalone worker with RPC + lifecycle)');
-    logger.info('  - qvac/worker.bundle.js    (mobile bundle for Expo/React Native BareKit)');
-    logger.info('  - qvac/addons.manifest.json\n');
-    logger.info('Mobile: Expo plugin auto-configures worker.bundle.js');
-    logger.info('Standalone: Import qvac/worker.entry.mjs for full worker with RPC\n');
-    return {
-        bundlePath,
-        plugins: pluginSpecifiers,
-        addons: manifestResult.addons,
-        entryPaths: {
-            worker: entryPath
-        },
-        manifestPath: manifestResult.manifestPath
-    };
-}

package/dist/commands/bundle/plugins.d.ts

@@ -1,9 +0,0 @@
-import type { Logger } from '../../logging/types.js';
-import type { QvacConfig } from '../../schemas/sdk-config.js';
-export declare function buildBuiltinSpecifier(sdkName: string, suffix: string): string;
-export declare function parseBuiltinSpecifier(specifier: string, sdkName: string): {
-    suffix: string;
-    exportName: string;
-} | null;
-export declare function resolvePluginSpecifiers(config: QvacConfig, sdkName: string, logger: Logger): string[];
-//# sourceMappingURL=plugins.d.ts.map

package/dist/commands/bundle/plugins.js

@@ -1,51 +0,0 @@
-import { BUILTIN_PLUGINS, BUILTIN_SUFFIXES } from '../../commands/bundle/constants.js';
-import { InvalidPluginSpecifierError } from '../../utils/errors-client.js';
-export function buildBuiltinSpecifier(sdkName, suffix) {
-    return `${sdkName}/${suffix}/plugin`;
-}
-export function parseBuiltinSpecifier(specifier, sdkName) {
-    const prefix = `${sdkName}/`;
-    const pluginSuffix = '/plugin';
-    if (specifier.startsWith(prefix) && specifier.endsWith(pluginSuffix)) {
-        const middle = specifier.slice(prefix.length, -pluginSuffix.length);
-        const info = BUILTIN_PLUGINS[middle];
-        if (!middle.includes('/') && info) {
-            return { suffix: middle, exportName: info.exportName };
-        }
-    }
-    return null;
-}
-export function resolvePluginSpecifiers(config, sdkName, logger) {
-    let plugins = config.plugins ?? [];
-    if (plugins.length === 0) {
-        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");
-        plugins = allBuiltins;
-    }
-    const uniquePlugins = [...new Set(plugins)];
-    const resolved = [];
-    const customPlugins = [];
-    const errors = [];
-    for (const specifier of uniquePlugins) {
-        const builtin = parseBuiltinSpecifier(specifier, sdkName);
-        if (builtin) {
-            resolved.push(specifier);
-        }
-        else {
-            if (!specifier.endsWith('/plugin')) {
-                errors.push(specifier);
-            }
-            else {
-                customPlugins.push(specifier);
-            }
-        }
-    }
-    if (errors.length > 0) {
-        throw new InvalidPluginSpecifierError(errors);
-    }
-    if (customPlugins.length > 0) {
-        logger.info(`📦 Custom plugins: ${customPlugins.join(', ')}`);
-    }
-    return [...resolved, ...customPlugins];
-}

package/dist/commands/bundle/resolve-sdk-import.js

@@ -1,53 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-const SDK_EXPORT_CONDITIONS = ['bare', 'import', 'module', 'default', 'node', 'require'];
-export function selectExportTarget(entry) {
-    if (entry == null)
-        return null;
-    if (typeof entry === 'string')
-        return entry;
-    for (const condition of SDK_EXPORT_CONDITIONS) {
-        const resolved = selectExportTarget(entry[condition]);
-        if (resolved)
-            return resolved;
-    }
-    return null;
-}
-function readSdkExports(sdkPath) {
-    try {
-        const raw = fs.readFileSync(path.join(sdkPath, 'package.json'), 'utf8');
-        const pkg = JSON.parse(raw);
-        return pkg.exports ?? {};
-    }
-    catch {
-        return {};
-    }
-}
-// bare-pack rewrites the worker's Node builtins to their bare-* equivalents
-// (os -> bare-os, fs -> bare-fs, ...) and resolves them relative to wherever
-// the generated entry imports the SDK from. A bare specifier resolves against
-// the consumer project, so a hoisted/symlinked SDK (pnpm, workspaces) whose
-// bare-* deps live in a parent node_modules becomes unreachable. Importing each
-// SDK subpath via its resolved file under the SDK's realpath anchors that
-// resolution next to the bare-* deps instead.
-export function createSdkImportResolver(sdkPath, sdkName) {
-    let resolvedSdkPath = sdkPath;
-    try {
-        resolvedSdkPath = fs.realpathSync(sdkPath);
-    }
-    catch {
-        // Keep sdkPath as-is if it cannot be canonicalized.
-    }
-    const exportsMap = readSdkExports(resolvedSdkPath);
-    const prefix = `${sdkName}/`;
-    return (specifier) => {
-        if (!specifier.startsWith(prefix))
-            return specifier;
-        const subpath = `./${specifier.slice(prefix.length)}`;
-        const target = selectExportTarget(exportsMap[subpath]);
-        if (!target)
-            return specifier;
-        return pathToFileURL(path.join(resolvedSdkPath, target)).href;
-    };
-}

package/dist/commands/index.d.ts

@@ -1,5 +0,0 @@
-export { bundleSdk } from '../commands/bundle/index.js';
-export type { BundleSdkOptions, BundleSdkResult } from '../commands/bundle/index.js';
-export { verifyBundle, hasErrors, hasWarnings, formatVerifyBundleResult } from '../commands/verify/index.js';
-export type { VerifyBundleOptions, VerifyBundleResult, VerifyBundleIssue } from '../commands/verify/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.js

@@ -1,2 +0,0 @@
-export { bundleSdk } from '../commands/bundle/index.js';
-export { verifyBundle, hasErrors, hasWarnings, formatVerifyBundleResult } from '../commands/verify/index.js';

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

@@ -1,52 +0,0 @@
-import { type NativeAddon } from '../../commands/verify/addon-source.js';
-export interface BareRuntime {
-    version: string;
-    source: 'flag' | 'config' | 'bare-runtime' | 'bare';
-}
-export interface UnresolvedBareRuntime {
-    reason: string;
-    triedPaths: string[];
-}
-export interface ResolveBareRuntimeOptions {
-    projectRoot: string;
-    explicitVersion?: string;
-    explicitSource?: 'flag' | 'config';
-}
-export type BareRuntimeResolution = {
-    resolved: true;
-    runtime: BareRuntime;
-} | {
-    resolved: false;
-    error: UnresolvedBareRuntime;
-};
-export interface AbiMismatchIssue {
-    code: 'abi-mismatch';
-    level: 'error';
-    addon: string;
-    message: string;
-    enginesBare: string;
-    runtimeVersion: string;
-}
-export interface UnknownRuntimeIssue {
-    code: 'unknown-runtime-version';
-    level: 'warning';
-    message: string;
-    triedPaths: string[];
-}
-export interface MalformedEnginesBareIssue {
-    code: 'malformed-engines-bare';
-    level: 'warning';
-    addon: string;
-    enginesBare: string;
-    message: string;
-}
-export type AbiIssue = AbiMismatchIssue | UnknownRuntimeIssue | MalformedEnginesBareIssue;
-export interface CheckAbiOptions {
-    addons: NativeAddon[];
-    runtime: BareRuntimeResolution;
-}
-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 checkAbi(options: CheckAbiOptions): AbiIssue[];
-//# sourceMappingURL=abi.d.ts.map

package/dist/commands/verify/abi.js

@@ -1,125 +0,0 @@
-import { promises as fsp } from 'node:fs';
-import path from 'node:path';
-import semver from 'semver';
-import { formatAddonId } from '../../commands/verify/addon-source.js';
-const RUNTIME_PACKAGES = [
-    { source: 'bare-runtime', packageName: 'bare-runtime' },
-    { source: 'bare', packageName: 'bare' }
-];
-export async function resolveBareRuntime(options) {
-    if (options.explicitVersion) {
-        // Caller (verifyBundle) pre-validates explicitVersion via normalizeVersion.
-        return {
-            resolved: true,
-            runtime: {
-                version: normalizeVersion(options.explicitVersion),
-                source: options.explicitSource ?? 'flag'
-            }
-        };
-    }
-    const tried = [];
-    for (const candidate of RUNTIME_PACKAGES) {
-        const pkgJsonPath = path.join(options.projectRoot, 'node_modules', candidate.packageName, 'package.json');
-        tried.push(pkgJsonPath);
-        const version = await tryReadRuntimeVersion(pkgJsonPath);
-        if (version) {
-            return {
-                resolved: true,
-                runtime: { version, source: candidate.source }
-            };
-        }
-    }
-    return {
-        resolved: false,
-        error: {
-            reason: 'Unable to detect installed Bare runtime version',
-            triedPaths: tried
-        }
-    };
-}
-async function tryReadRuntimeVersion(pkgJsonPath) {
-    let raw;
-    try {
-        raw = await fsp.readFile(pkgJsonPath, 'utf8');
-    }
-    catch {
-        return null;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-        return null;
-    }
-    const version = parsed['version'];
-    return typeof version === 'string' ? normalizeVersion(version) : null;
-}
-export function normalizeVersion(value) {
-    const coerced = semver.coerce(value, { includePrerelease: true });
-    return coerced ? coerced.version : null;
-}
-export function formatConfigLabel(projectRoot, configPath) {
-    if (!configPath)
-        return 'qvac.config';
-    const rel = path.relative(projectRoot, configPath);
-    if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
-        return configPath;
-    return rel;
-}
-export function checkAbi(options) {
-    const { addons, runtime } = options;
-    const addonsWithEngines = addons.filter((addon) => addon.enginesBare !== undefined);
-    if (addonsWithEngines.length === 0)
-        return [];
-    const issues = [];
-    const checkable = [];
-    for (const addon of addonsWithEngines) {
-        const range = addon.enginesBare;
-        if (!range)
-            continue;
-        if (!semver.validRange(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.'
-            });
-            continue;
-        }
-        checkable.push({ addon, range });
-    }
-    if (checkable.length === 0)
-        return issues;
-    if (!runtime.resolved) {
-        issues.push({
-            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.',
-            triedPaths: runtime.error.triedPaths
-        });
-        return issues;
-    }
-    for (const { addon, range } of checkable) {
-        if (semver.satisfies(runtime.runtime.version, 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}).`
-        });
-    }
-    return issues;
-}

package/dist/commands/verify/bundle-source.d.ts

@@ -1,12 +0,0 @@
-import { type CollectDiagnostics, type NativeAddon } from '../../commands/verify/addon-source.js';
-export declare class InvalidBundleSourceError extends Error {
-    bundlePath: string;
-    constructor(bundlePath: string, cause: unknown);
-}
-export interface CollectAddonsFromBundleOptions {
-    bundlePath: string;
-    projectRoot: string;
-    diagnostics?: CollectDiagnostics;
-}
-export declare function collectAddonsFromBundle(options: CollectAddonsFromBundleOptions): Promise<NativeAddon[]>;
-//# sourceMappingURL=bundle-source.d.ts.map