@qvac/sdk 0.18.2 → 0.19.0

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

@@ -0,0 +1,159 @@
+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({
+            promptTokens: readOptionalNumberField(response.typedFields, 'promptTokens'),
+            cachedTokens: readOptionalNumberField(response.typedFields, 'cachedTokens'),
+            requiredTokens: readOptionalNumberField(response.typedFields, 'requiredTokens'),
+            ctxSize: 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) {
+    // Own-key gate: the map is an object literal, so a hostile name like
+    // "constructor" would otherwise resolve through Object.prototype.
+    const reconstructor = response.name && Object.prototype.hasOwnProperty.call(RECONSTRUCTORS, 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/src/client/rpc/worker-startup-error.d.ts

@@ -0,0 +1,12 @@
+import { WorkerStartupError } from '../../utils/errors-client.js';
+export interface WorkerExit {
+    code: number | null;
+    signal: string | null;
+}
+/**
+ * Always returns a cause. A worker that is still running and has written
+ * nothing carries no diagnostic text, but `workerExited: false` is what tells a
+ * caller that waiting longer could still help.
+ */
+export declare function createRPCInitTimeoutCause(stderrTail: string, workerExit: WorkerExit | null): WorkerStartupError;
+//# sourceMappingURL=worker-startup-error.d.ts.map

package/dist/src/client/rpc/worker-startup-error.js

@@ -0,0 +1,13 @@
+import { WorkerStartupError } from '../../utils/errors-client.js';
+/**
+ * Always returns a cause. A worker that is still running and has written
+ * nothing carries no diagnostic text, but `workerExited: false` is what tells a
+ * caller that waiting longer could still help.
+ */
+export function createRPCInitTimeoutCause(stderrTail, workerExit) {
+    const stderr = stderrTail.trimEnd();
+    if (workerExit) {
+        return new WorkerStartupError(`Worker process exited with code ${workerExit.code}, signal ${workerExit.signal} before IPC connection was established`, { code: workerExit.code, signal: workerExit.signal }, stderr);
+    }
+    return new WorkerStartupError('Worker did not establish IPC before the RPC initialization timeout', null, stderr);
+}

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

@@ -0,0 +1,54 @@
+import { parseBuiltinSpecifier } from './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 { initializeWorker, ensureRPCSetup } from "${resolveImport(`${sdkName}/worker-lifecycle`)}";
+import { registerPlugin } from "${resolveImport(`${sdkName}/plugins`)}";
+import { getServerLogger } from "${resolveImport(`${sdkName}/logging`)}";
+
+${importsStr}
+
+const { hasRPCConfig } = initializeWorker();
+
+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/src/commands/bundle/index.js

@@ -0,0 +1,148 @@
+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 './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 './plugins.js';
+import { generateWorkerEntries } from './entry-gen.js';
+import { runBarePack } from './bare-pack.js';
+import { generateAddonsManifest } from './manifest.js';
+import { createSdkImportResolver } from './resolve-sdk-import.js';
+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/src/commands/bundle/plugins.d.ts

@@ -0,0 +1,9 @@
+import type { Logger } from '../../logging/types.js';
+import type { QvacConfig } from '@qvac/inference/surface';
+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/src/commands/bundle/plugins.js

@@ -0,0 +1,51 @@
+import { BUILTIN_PLUGINS, BUILTIN_SUFFIXES } from './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/src/commands/bundle/resolve-sdk-import.js

@@ -0,0 +1,58 @@
+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 || entry === undefined)
+        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 readPackageExports(packagePath) {
+    try {
+        const raw = fs.readFileSync(path.join(packagePath, '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 anchors = [{ prefix: `${sdkName}/`, root: resolvedSdkPath }];
+    const resolved = anchors.map(({ prefix, root }) => ({
+        prefix,
+        root,
+        exports: readPackageExports(root)
+    }));
+    return (specifier) => {
+        for (const { prefix, root, exports } of resolved) {
+            if (!specifier.startsWith(prefix))
+                continue;
+            const subpath = `./${specifier.slice(prefix.length)}`;
+            const target = selectExportTarget(exports[subpath]);
+            return target ? pathToFileURL(path.join(root, target)).href : specifier;
+        }
+        return specifier;
+    };
+}

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

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

package/dist/src/commands/index.js

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

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

@@ -0,0 +1,52 @@
+import { type NativeAddon } from './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