@qvac/sdk 0.18.2 → 0.19.0

package/dist/client/api/vla.js

@@ -1,166 +0,0 @@
-import { vlaHparamsResponseSchema, vlaRunResponseSchema, vlaSetEmbodimentResponseSchema } from '../../schemas/index.js';
-import { decodeBase64, encodeBase64 } from '../../utils/encoding.js';
-import { invokePlugin } from './invoke-plugin.js';
-const VLA_RUN_HANDLER = 'vlaRun';
-const VLA_HPARAMS_HANDLER = 'vlaHparams';
-const VLA_SET_EMBODIMENT_HANDLER = 'vlaSetEmbodiment';
-function bytesOf(arr) {
-    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-function f32FromBase64(b64) {
-    const bytes = decodeBase64(b64);
-    // base64 round-trip produces a fresh Uint8Array whose buffer starts at 0
-    // and isn't shared, so the underlying ArrayBuffer is safe to reinterpret.
-    return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
-}
-/**
- * Run VLA inference on a loaded model (SmolVLA, π₀.₅, or GR00T) and return the
- * produced action chunk plus per-stage timings.
- *
- * @param params - Inference inputs.
- * @param params.modelId - Identifier of the loaded VLA model (returned by
- *   `loadModel({ modelType: "vla", ... })`).
- * @param params.images - The preprocessed camera frames, one per camera. For
- *   pixel-input models (SmolVLA, π₀.₅) each is a `Float32Array` of length
- *   `3 * imgWidth * imgHeight` in CHW layout, range `[-1, 1]`, produced by the
- *   addon's `preprocessImage()` (re-exported as `vlaPreprocessImage`). For
- *   patch-input models (GR00T, `hparams.imageInputMode === 'patches'`) each is
- *   the pre-patchified buffer of length `hparams.imagePatchElems` instead. Pass
- *   exactly `hparams.numCameras` frames (2 for SmolVLA and GR00T, 3 for π₀.₅).
- * @param params.imgWidth - Width of each preprocessed image; must equal
- *   `hparams.visionImageSize`.
- * @param params.imgHeight - Height of each preprocessed image; must equal
- *   `hparams.visionImageSize`.
- * @param params.state - Robot end-effector / gripper state. For
- *   continuous-state models (SmolVLA, GR00T) pad to `hparams.maxStateDim` with
- *   `vlaPadState`. For discrete-state models (π₀.₅,
- *   `hparams.stateInputMode === 'discrete'`) the state is tokenised into the
- *   prompt and this buffer is ignored — pass an empty `Float32Array(0)`.
- * @param params.tokens - Tokenized instruction (`Int32Array` of length
- *   `hparams.tokenizerMaxLength`). Tokenize on the consumer side with the
- *   model's tokenizer (SmolVLM2 for SmolVLA, PaliGemma/Gemma for π₀.₅,
- *   Qwen3-VL for GR00T).
- * @param params.mask - Token attention mask (`Uint8Array` matching `tokens`).
- * @param params.noise - Seeded noise prior
- *   (`Float32Array` of length `hparams.chunkSize * hparams.maxActionDim`).
- *   Optional for SmolVLA / π₀.₅ (addon samples its own prior when omitted).
- *   Required for GR00T (`hparams.imageInputMode === 'patches'`).
- * @returns A `VlaClientRunResult` with the produced `actions` Float32Array
- *   (length `chunkSize * actionDim`), the corresponding `chunkSize` /
- *   `actionDim` returned by the addon, and optional per-stage `stats`.
- *
- * @example
- * ```typescript
- * import { loadModel, vla, vlaPreprocessImage, vlaPadState, vlaHparams } from "@qvac/sdk";
- *
- * const modelId = await loadModel({ modelSrc: "/path/to/smolvla.gguf", modelType: "vla" });
- * const { hparams } = await vlaHparams({ modelId });
- * const size = hparams.visionImageSize;
- * const front = vlaPreprocessImage(frontPixels, frontW, frontH, { size });
- * const wrist = vlaPreprocessImage(wristPixels, wristW, wristH, { size });
- * const state = vlaPadState(robotState, hparams.maxStateDim);
- * const tokens = new Int32Array(hparams.tokenizerMaxLength);
- * const mask = new Uint8Array(hparams.tokenizerMaxLength);
- * // ...tokenize the instruction into tokens/mask...
- * const { actions } = await vla({
- *   modelId, images: [front, wrist], imgWidth: size, imgHeight: size,
- *   state, tokens, mask,
- * });
- * ```
- */
-export async function vla(params) {
-    const wireRequest = {
-        type: 'vlaRun',
-        modelId: params.modelId,
-        images: params.images.map((img) => encodeBase64(bytesOf(img))),
-        imgWidth: params.imgWidth,
-        imgHeight: params.imgHeight,
-        state: encodeBase64(bytesOf(params.state)),
-        tokens: encodeBase64(bytesOf(params.tokens)),
-        mask: encodeBase64(bytesOf(params.mask)),
-        ...(params.noise !== undefined && {
-            noise: encodeBase64(bytesOf(params.noise))
-        })
-    };
-    const result = await invokePlugin({
-        modelId: params.modelId,
-        handler: VLA_RUN_HANDLER,
-        params: wireRequest
-    });
-    const parsed = vlaRunResponseSchema.parse(result);
-    return {
-        actions: f32FromBase64(parsed.actions),
-        actionDim: parsed.actionDim,
-        chunkSize: parsed.chunkSize,
-        ...(parsed.stats && { stats: parsed.stats })
-    };
-}
-/**
- * Fetch the loaded VLA model's hyperparameters and the active ggml backend
- * name. Useful to size token / state / noise buffers before calling `vla()`.
- *
- * @param params - Identifier of the loaded VLA model.
- * @returns The model's hparams and the human-readable backend name
- *   (`"CPU"` / `"Vulkan"` / `"Metal"` / `"OpenCL"` / `null` if the addon
- *   has not surfaced one).
- */
-export async function vlaHparams(params) {
-    const wireRequest = {
-        type: 'vlaHparams',
-        modelId: params.modelId
-    };
-    const result = await invokePlugin({
-        modelId: params.modelId,
-        handler: VLA_HPARAMS_HANDLER,
-        params: wireRequest
-    });
-    return vlaHparamsResponseSchema.parse(result);
-}
-/**
- * Switch a loaded multi-embodiment GR00T model to another embodiment shipped
- * in the same GGUF — no reload, only that embodiment's weight rows are re-read.
- *
- * The returned hparams follow the newly active embodiment: re-read
- * `numCameras` (and re-size buffers if needed) before the next `vla()` call.
- * `selectedEmbodimentTag` / `selectedEmbodimentCatId` report what was
- * resolved. Selecting by `catId` reports that id's canonical tag, which may
- * differ from the alias used to select — the id is the stable identity.
- *
- * Rejects (leaving the current embodiment active) for a non-GR00T or
- * single-embodiment model, an unknown tag or `cat_id`, one not stored in the
- * GGUF, an embodiment with no known camera count and no `numCameras`
- * override, or while an inference response is still pending — await the
- * in-flight `vla()` call first.
- *
- * @param params.modelId - Identifier of the loaded VLA model.
- * @param params.embodiment - The embodiment to activate: a tag string, a
- *   numeric `cat_id` (0..31), or `{ tag | catId, numCameras }` where
- *   `numCameras` overrides the camera count stored in the GGUF.
- * @returns The refreshed model hparams after the switch.
- *
- * @example
- * ```typescript
- * import { loadModel, vlaSetEmbodiment, vlaHparams } from "@qvac/sdk";
- *
- * const modelId = await loadModel({
- *   modelSrc: "/path/to/groot-multi.gguf",
- *   modelType: "vla",
- *   modelConfig: { embodiment: "libero_sim" }, // initial selection at load
- * });
- * const { hparams } = await vlaSetEmbodiment({ modelId, embodiment: "real_droid" });
- * console.log(hparams.selectedEmbodimentTag, hparams.numCameras);
- * ```
- */
-export async function vlaSetEmbodiment(params) {
-    const wireRequest = {
-        type: 'vlaSetEmbodiment',
-        modelId: params.modelId,
-        embodiment: params.embodiment
-    };
-    const result = await invokePlugin({
-        modelId: params.modelId,
-        handler: VLA_SET_EMBODIMENT_HANDLER,
-        params: wireRequest
-    });
-    return vlaSetEmbodimentResponseSchema.parse(result);
-}

package/dist/client/config-loader/config-utils.d.ts

@@ -1,5 +0,0 @@
-import { type QvacConfig } from '../../schemas/index.js';
-export type { QvacConfig };
-export declare function validateConfig(config: unknown): QvacConfig;
-export declare function parseJsonConfig(content: string, filePath: string): unknown;
-//# sourceMappingURL=config-utils.d.ts.map

package/dist/client/config-loader/config-utils.js

@@ -1,18 +0,0 @@
-import { qvacConfigSchema } from '../../schemas/index.js';
-import { ConfigValidationFailedError } from '../../utils/errors-client.js';
-import { formatZodError } from '../../utils/zod-error.js';
-export function validateConfig(config) {
-    const result = qvacConfigSchema.safeParse(config);
-    if (!result.success) {
-        throw new ConfigValidationFailedError(formatZodError(result.error));
-    }
-    return result.data;
-}
-export function parseJsonConfig(content, filePath) {
-    try {
-        return JSON.parse(content);
-    }
-    catch {
-        throw new ConfigValidationFailedError(`Invalid JSON in config file: ${filePath}`);
-    }
-}

package/dist/client/config-loader/resolve-config.bare.d.ts

@@ -1,9 +0,0 @@
-import { type QvacConfig } from './config-utils.js';
-/**
- * Resolution order for Bare:
- * 1. QVAC_CONFIG_PATH environment variable
- * 2. Config file in project root (qvac.config.js, qvac.config.json)
- * 3. SDK defaults
- */
-export declare function resolveConfig(): Promise<QvacConfig | undefined>;
-//# sourceMappingURL=resolve-config.bare.d.ts.map

package/dist/client/config-loader/resolve-config.bare.js

@@ -1,74 +0,0 @@
-/**
- * Config loader for Bare runtime
- * Uses bare-fs and bare-path modules
- */
-import fs from 'bare-fs';
-import path from 'bare-path';
-import os from 'bare-os';
-import env from 'bare-env';
-import { validateConfig } from './config-utils.js';
-import { ConfigFileInvalidError, ConfigFileParseFailedError } from '../../utils/errors-client.js';
-import { getClientLogger } from '../../logging/index.js';
-const SUPPORTED_CONFIG_FILE_EXTS = ['.js', '.json'];
-const logger = getClientLogger();
-function findProjectRoot() {
-    return os.cwd();
-}
-function fileExists(filePath) {
-    return fs.existsSync(filePath);
-}
-function assertBareConfigExtension(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    if (!SUPPORTED_CONFIG_FILE_EXTS.includes(ext)) {
-        throw new ConfigFileInvalidError(filePath, 'Given config file format unsupported on this platform. Use qvac.config.js or qvac.config.json in the project root, or set QVAC_CONFIG_PATH to a .js or .json file.');
-    }
-}
-function loadConfigFromPath(filePath) {
-    assertBareConfigExtension(filePath);
-    try {
-        const configModule = require(filePath);
-        return validateConfig(configModule.default || configModule);
-    }
-    catch (error) {
-        throw new ConfigFileParseFailedError(filePath, error instanceof Error ? error.message : String(error), error);
-    }
-}
-function findConfigFile(searchDir) {
-    const configFiles = SUPPORTED_CONFIG_FILE_EXTS.map((ext) => `qvac.config${ext}`);
-    for (const name of configFiles) {
-        const filePath = path.resolve(searchDir, name);
-        if (fileExists(filePath)) {
-            return filePath;
-        }
-    }
-    return undefined;
-}
-/**
- * Resolution order for Bare:
- * 1. QVAC_CONFIG_PATH environment variable
- * 2. Config file in project root (qvac.config.js, qvac.config.json)
- * 3. SDK defaults
- */
-// eslint-disable-next-line @typescript-eslint/require-await -- matches Node/Expo resolver signature
-export async function resolveConfig() {
-    const configPath = env['QVAC_CONFIG_PATH'];
-    if (configPath) {
-        const normalizedPath = path.resolve(configPath);
-        if (fileExists(normalizedPath)) {
-            const config = loadConfigFromPath(normalizedPath);
-            logger.info(`✅ Loaded config from: ${normalizedPath}`);
-            return config;
-        }
-    }
-    const projectRoot = findProjectRoot();
-    if (projectRoot) {
-        const configFilePath = findConfigFile(projectRoot);
-        if (configFilePath) {
-            const config = loadConfigFromPath(configFilePath);
-            logger.info(`✅ Loaded config from: ${configFilePath}`);
-            return config;
-        }
-    }
-    logger.info('ℹ️ No config file found, using SDK defaults');
-    return undefined;
-}

package/dist/client/config-loader/resolve-config.expo.js

@@ -1,62 +0,0 @@
-/**
- * Config loader for Expo/React Native runtime
- * Only uses expo-file-system - no Node.js or Bare imports
- */
-import { File, Paths } from 'expo-file-system';
-import { validateConfig, parseJsonConfig } from './config-utils.js';
-import { getClientLogger } from '../../logging/index.js';
-const logger = getClientLogger();
-function fileExists(filePath) {
-    try {
-        const file = new File(filePath);
-        return file.exists;
-    }
-    catch {
-        return false;
-    }
-}
-async function readFile(filePath) {
-    const file = new File(filePath);
-    return await file.text();
-}
-async function loadJsonConfig(filePath) {
-    const content = await readFile(filePath);
-    const parsed = parseJsonConfig(content, filePath);
-    return validateConfig(parsed);
-}
-/**
- * Resolution order for Expo:
- * 1. QVAC_CONFIG_PATH environment variable (if set)
- * 2. Default Expo path: ${Paths.document.uri}qvac.config.json
- * 3. SDK defaults
- *
- * Note: Only JSON config files are supported in React Native
- */
-export async function resolveConfig() {
-    // Check environment variable first
-    const configPath = typeof process !== 'undefined'
-        ? process.env?.['QVAC_CONFIG_PATH']
-        : undefined;
-    if (configPath) {
-        if (fileExists(configPath)) {
-            logger.info(`✅ Loaded config from: ${configPath}`);
-            return await loadJsonConfig(configPath);
-        }
-    }
-    // Try default Expo document directory path
-    try {
-        const documentDir = Paths.document.uri;
-        if (documentDir) {
-            const defaultExpoConfigPath = `${documentDir}qvac.config.json`;
-            if (fileExists(defaultExpoConfigPath)) {
-                logger.info(`✅ Loaded config from: ${defaultExpoConfigPath}`);
-                return await loadJsonConfig(defaultExpoConfigPath);
-            }
-        }
-    }
-    catch {
-        // Paths not available
-    }
-    logger.info('ℹ️ No config file found, using SDK defaults');
-    return undefined;
-}

package/dist/client/config-loader/resolve-config.node.js

@@ -1,199 +0,0 @@
-/**
- * Config loader for Node.js runtime
- * Uses Node.js fs/promises and path modules
- */
-import { promises as fs } from 'fs';
-import path from 'path';
-import { pathToFileURL } from 'url';
-import { validateConfig, parseJsonConfig } from './config-utils.js';
-import { ConfigFileInvalidError, ConfigFileParseFailedError } from '../../utils/errors-client.js';
-import { getClientLogger } from '../../logging/index.js';
-const logger = getClientLogger();
-/** Config filenames searched under a project root (bundle/verify/commands). */
-export const CONFIG_CANDIDATES = [
-    'qvac.config.ts',
-    'qvac.config.mjs',
-    'qvac.config.js',
-    'qvac.config.json'
-];
-async function findProjectRoot() {
-    try {
-        let currentDir = path.resolve(process.cwd());
-        const root = path.parse(currentDir).root;
-        while (currentDir !== root) {
-            try {
-                const packageJsonPath = path.join(currentDir, 'package.json');
-                await fs.access(packageJsonPath);
-                return currentDir;
-            }
-            catch {
-                const parentDir = path.dirname(currentDir);
-                if (parentDir === currentDir) {
-                    break;
-                }
-                currentDir = parentDir;
-            }
-        }
-    }
-    catch (error) {
-        logger.debug('Project root search failed, using cwd:', { error });
-    }
-    return process.cwd();
-}
-async function fileExists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function readFile(filePath) {
-    return await fs.readFile(filePath, { encoding: 'utf-8' });
-}
-async function loadJsonConfig(filePath) {
-    const content = await readFile(filePath);
-    const parsed = parseJsonConfig(content, filePath);
-    return validateConfig(parsed);
-}
-async function loadJsConfig(filePath) {
-    try {
-        let importPath = filePath;
-        // Windows requires file:// URLs for dynamic imports
-        if (process.platform === 'win32' && !process.env['JEST_WORKER_ID']) {
-            importPath = pathToFileURL(filePath).toString();
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const configModule = await import(importPath);
-        return validateConfig(configModule.default || configModule);
-    }
-    catch (error) {
-        throw new ConfigFileParseFailedError(filePath, error instanceof Error ? error.message : String(error), error);
-    }
-}
-async function loadTsConfig(filePath) {
-    let tsxApiPath;
-    try {
-        const { createRequire } = await import('node:module');
-        const require = createRequire(import.meta.url);
-        tsxApiPath = require.resolve('tsx/esm/api');
-    }
-    catch (error) {
-        throw new ConfigFileInvalidError(filePath, 'Loading a TypeScript qvac.config.ts requires the optional peer dependency `tsx`. Install it as a devDependency, or use qvac.config.mjs / qvac.config.js / qvac.config.json instead.', error);
-    }
-    try {
-        const tsxModule = (await import(tsxApiPath));
-        const mod = await tsxModule.tsImport(filePath, import.meta.url);
-        return validateConfig(mod.default ?? mod);
-    }
-    catch (error) {
-        throw new ConfigFileParseFailedError(filePath, error instanceof Error ? error.message : String(error), error);
-    }
-}
-/** Load and validate a config file at an explicit path (used by RPC init and commands). */
-export async function loadConfigFromPath(configPath) {
-    const ext = path.extname(configPath).toLowerCase();
-    if (ext === '.json') {
-        return loadJsonConfig(configPath);
-    }
-    if (ext === '.js' || ext === '.mjs') {
-        return loadJsConfig(configPath);
-    }
-    if (ext === '.ts') {
-        return loadTsConfig(configPath);
-    }
-    throw new ConfigFileInvalidError(configPath, `Unsupported config format: ${ext}. Use .json, .js, .mjs, or .ts`);
-}
-async function findConfigFileInDir(searchDir) {
-    for (const name of CONFIG_CANDIDATES) {
-        const filePath = path.resolve(searchDir, name);
-        if (await fileExists(filePath)) {
-            return filePath;
-        }
-    }
-    return undefined;
-}
-/**
- * Resolve a config file path under `projectRoot` (or an explicit relative/absolute path).
- * Used by `bundleSdk` / `verifyBundle` when the caller supplies `projectRoot`.
- */
-export async function resolveConfigFileInProject(projectRoot, explicitPath) {
-    if (explicitPath) {
-        const absPath = path.isAbsolute(explicitPath)
-            ? explicitPath
-            : path.join(projectRoot, explicitPath);
-        if (await fileExists(absPath)) {
-            return absPath;
-        }
-        throw new ConfigFileInvalidError(absPath, 'Config file not found at explicit path');
-    }
-    const found = await findConfigFileInDir(projectRoot);
-    return found ?? null;
-}
-/**
- * Load `qvac.config.*` for a known project directory (commands tooling API).
- */
-export async function resolveConfigForProject(projectRoot, explicitPath) {
-    const configPath = await resolveConfigFileInProject(projectRoot, explicitPath);
-    if (!configPath) {
-        return { configPath: null, config: {} };
-    }
-    const config = await loadConfigFromPath(configPath);
-    return { configPath, config };
-}
-function getResourcesPath() {
-    const { resourcesPath } = process;
-    return typeof resourcesPath === 'string' ? resourcesPath : undefined;
-}
-async function findPackagedConfig() {
-    const resourcesPath = getResourcesPath();
-    if (!resourcesPath)
-        return undefined;
-    const candidates = [
-        path.join(resourcesPath, 'app', 'qvac.config.json'),
-        path.join(resourcesPath, 'app.asar.unpacked', 'qvac.config.json'),
-        path.join(resourcesPath, 'qvac.config.json')
-    ];
-    for (const candidate of candidates) {
-        if (await fileExists(candidate)) {
-            return candidate;
-        }
-    }
-    return undefined;
-}
-/**
- * Resolution order for Node.js:
- * 1. QVAC_CONFIG_PATH environment variable
- * 2. Packaged Electron app (via process.resourcesPath)
- * 3. Config file in project root (qvac.config.ts, qvac.config.js, qvac.config.json)
- * 4. SDK defaults
- */
-export async function resolveConfig() {
-    const configPath = process.env['QVAC_CONFIG_PATH'];
-    if (configPath) {
-        const normalizedPath = path.resolve(configPath);
-        if (await fileExists(normalizedPath)) {
-            const config = await loadConfigFromPath(normalizedPath);
-            logger.info(`✅ Loaded config from: ${normalizedPath}`);
-            return config;
-        }
-    }
-    const packagedConfig = await findPackagedConfig();
-    if (packagedConfig) {
-        const config = await loadJsonConfig(packagedConfig);
-        logger.info(`✅ Loaded config from packaged app: ${packagedConfig}`);
-        return config;
-    }
-    const projectRoot = await findProjectRoot();
-    if (projectRoot) {
-        const configFilePath = await findConfigFileInDir(projectRoot);
-        if (configFilePath) {
-            const config = await loadConfigFromPath(configFilePath);
-            logger.info(`✅ Loaded config from: ${configFilePath}`);
-            return config;
-        }
-    }
-    logger.info('ℹ️ No config file found, using SDK defaults');
-    return undefined;
-}

package/dist/client/init-hooks.d.ts

@@ -1,21 +0,0 @@
-import type { QvacConfig, RuntimeContext } from '../schemas/index.js';
-type ResolveConfigFn = () => Promise<QvacConfig | undefined>;
-interface RPCClient {
-    request(command: number): any;
-}
-/**
- * Initializes SDK configuration and runtime context.
- * Config is loaded once and becomes immutable on the worker side.
- *
- * @param rpc - The RPC client instance
- * @param resolveConfig - Runtime-specific config resolver function
- * @param runtimeContext - Optional runtime context (platform, device info)
- */
-export declare function initializeConfig(rpc: RPCClient, resolveConfig: ResolveConfigFn, runtimeContext?: RuntimeContext): Promise<void>;
-/**
- * Legacy function for backward compatibility
- * @deprecated Use initializeConfig instead
- */
-export declare function replayConfigIfCached(): void;
-export {};
-//# sourceMappingURL=init-hooks.d.ts.map

package/dist/client/init-hooks.js

@@ -1,66 +0,0 @@
-import { getClientLogger, setGlobalLogLevel, setGlobalConsoleOutput } from '../logging/index.js';
-import { SetConfigFailedError } from '../utils/errors-client.js';
-const logger = getClientLogger();
-function applyClientLoggerSettings(config) {
-    if (config.loggerLevel !== undefined) {
-        setGlobalLogLevel(config.loggerLevel);
-    }
-    if (config.loggerConsoleOutput !== undefined) {
-        setGlobalConsoleOutput(config.loggerConsoleOutput);
-    }
-}
-async function sendInitMessage(rpc, config, runtimeContext) {
-    const initMessage = {
-        type: '__init_config',
-        config,
-        runtimeContext
-    };
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const req = rpc.request(1);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-    req.send(JSON.stringify(initMessage), 'utf8');
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-    const response = await req.reply('utf8');
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
-    const parsed = JSON.parse(response.toString());
-    if (!parsed.success) {
-        throw new SetConfigFailedError(parsed.error ?? 'Unknown error');
-    }
-}
-/**
- * Initializes SDK configuration and runtime context.
- * Config is loaded once and becomes immutable on the worker side.
- *
- * @param rpc - The RPC client instance
- * @param resolveConfig - Runtime-specific config resolver function
- * @param runtimeContext - Optional runtime context (platform, device info)
- */
-export async function initializeConfig(rpc, resolveConfig, runtimeContext) {
-    const config = await resolveConfig();
-    // Nothing to initialize
-    if (!config && !runtimeContext) {
-        return;
-    }
-    // Apply client-side logger settings
-    if (config) {
-        applyClientLoggerSettings(config);
-        logger.info('📦 Initializing SDK config');
-    }
-    if (runtimeContext) {
-        logger.info('📱 Runtime context:', runtimeContext);
-    }
-    try {
-        await sendInitMessage(rpc, config, runtimeContext);
-        logger.info('✅ Initialization complete');
-    }
-    catch (error) {
-        logger.error('❌ Initialization failed:', error);
-    }
-}
-/**
- * Legacy function for backward compatibility
- * @deprecated Use initializeConfig instead
- */
-export function replayConfigIfCached() {
-    logger.warn('⚠️ replayConfigIfCached is deprecated and has no effect. Config is now loaded from file during initialization.');
-}

package/dist/client/plugins-factory.d.ts

@@ -1,8 +0,0 @@
-import * as hostApi from '../client/api/index.js';
-import type { QvacPlugin } from '../schemas/plugin.js';
-/**
- * Register plugins and return the client host API. Designed for
- * @qvac/bare-sdk consumers assembling explicit plugin subsets.
- */
-export declare function plugins(pluginList: readonly QvacPlugin[]): typeof hostApi;
-//# sourceMappingURL=plugins-factory.d.ts.map

package/dist/client/plugins-factory.js

@@ -1,10 +0,0 @@
-import { registerPlugins } from '../server/plugins/index.js';
-import * as hostApi from '../client/api/index.js';
-/**
- * Register plugins and return the client host API. Designed for
- * @qvac/bare-sdk consumers assembling explicit plugin subsets.
- */
-export function plugins(pluginList) {
-    registerPlugins(pluginList);
-    return hostApi;
-}

package/dist/client/rpc/bare-client.d.ts

@@ -1,17 +0,0 @@
-import type { Request, Response } from '../../schemas/index.js';
-export declare function send<T extends Request>(request: T): Promise<Response>;
-export declare function getWorkerLifeSignal(): AbortSignal | null;
-export declare function notifyChannelClosed(): void;
-export declare function getRPC(): Promise<{
-    request(): {
-        send(payload: string): void;
-        reply(): Promise<Buffer<ArrayBuffer>>;
-        createResponseStream(): AsyncGenerator<Buffer<ArrayBuffer>, void, unknown>;
-    };
-}>;
-export declare function close(): Promise<void>;
-export declare function createDuplexSession(payload: string, _commandId: number): Promise<{
-    requestStream: import("bare-stream").Transform<import("bare-stream").TransformEvents>;
-    responseStream: import("bare-stream").Transform<import("bare-stream").TransformEvents>;
-}>;
-//# sourceMappingURL=bare-client.d.ts.map