@qvac/sdk 0.18.2 → 0.19.0

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

@@ -1,251 +0,0 @@
-import { normalizeModelType, PROFILING_KEY } from '../../schemas/index.js';
-import os from 'bare-os';
-import { registry } from '../../server/rpc/handler-registry.js';
-import { handlerSupportsProgress, selectHandler } from '../../server/rpc/handler-selection.js';
-import { createErrorResponse } from '../../schemas/index.js';
-import { RPCNoHandlerError, RPCRequestNotSentError } from '../../utils/errors-client.js';
-import { initializeConfig } from '../../client/init-hooks.js';
-import { setSDKConfig } from '../../server/bare/registry/config-registry.js';
-import { setRuntimeContext } from '../../server/bare/registry/runtime-context-registry.js';
-import { resolveModelConfig } from '../../server/bare/registry/model-config-registry.js';
-import { resolveConfig } from '../../client/config-loader/resolve-config.bare.js';
-import { initializeWorkerCore, cleanupForTerminate } from '../../server/worker-core.js';
-import { assertLifecycleAllowed } from '../../server/bare/runtime-lifecycle.js';
-import { ensurePluginsRegistered } from '../../client/rpc/ensure-worker-ready.js';
-async function ensureWorkerReady() {
-    initializeWorkerCore();
-    await ensurePluginsRegistered();
-}
-function getHandlerEntry(type) {
-    const entry = registry[type];
-    if (!entry) {
-        throw new RPCNoHandlerError(type);
-    }
-    return entry;
-}
-function applyDeviceDefaultsToLoadModel(request) {
-    if (request.type !== 'loadModel' || !('modelSrc' in request)) {
-        return request;
-    }
-    let canonicalType;
-    try {
-        canonicalType = normalizeModelType(request.modelType);
-    }
-    catch {
-        return request;
-    }
-    const rawConfig = request.modelConfig ?? {};
-    const configWithDefaults = resolveModelConfig(canonicalType, rawConfig);
-    return { ...request, modelConfig: configWithDefaults };
-}
-function getProfilingMetaFromRequest(request) {
-    if (PROFILING_KEY in request) {
-        return request[PROFILING_KEY];
-    }
-    return undefined;
-}
-function createDelegatedOptions(request, progressCallback) {
-    const profilingMeta = getProfilingMetaFromRequest(request);
-    if (!profilingMeta && !progressCallback) {
-        return undefined;
-    }
-    const options = {};
-    if (progressCallback) {
-        options.progressCallback = progressCallback;
-    }
-    if (profilingMeta) {
-        options.profilingMeta = profilingMeta;
-    }
-    return options;
-}
-function executeDirectHandler(request, handler, isDelegated) {
-    const directHandler = handler;
-    if (isDelegated) {
-        return directHandler(request, createDelegatedOptions(request));
-    }
-    return directHandler(request);
-}
-function isAsyncGenerator(result) {
-    return typeof result === 'object' && result !== null && Symbol.asyncIterator in result;
-}
-async function* streamWithProgress(request, handler, isDelegated) {
-    const queue = [];
-    const errors = [];
-    let done = false;
-    function progressCallback(update) {
-        queue.push(update);
-    }
-    const directHandler = handler;
-    Promise.resolve(directHandler(request, isDelegated ? createDelegatedOptions(request, progressCallback) : progressCallback))
-        .then((final) => {
-        queue.push(final);
-        done = true;
-    })
-        .catch((error) => {
-        errors.push(error);
-        done = true;
-    });
-    while (!done || queue.length > 0) {
-        if (queue.length > 0) {
-            yield queue.shift();
-        }
-        else {
-            await new Promise((resolve) => setTimeout(resolve, 10));
-        }
-    }
-    const handlerError = errors[0];
-    if (handlerError) {
-        throw handlerError;
-    }
-}
-export async function send(request) {
-    assertLifecycleAllowed(request);
-    const processedRequest = applyDeviceDefaultsToLoadModel(request);
-    const entry = getHandlerEntry(processedRequest.type);
-    const { handler, isDelegated } = selectHandler(entry, processedRequest);
-    return (await executeDirectHandler(processedRequest, handler, isDelegated));
-}
-async function* stream(request) {
-    assertLifecycleAllowed(request);
-    const processedRequest = applyDeviceDefaultsToLoadModel(request);
-    const entry = getHandlerEntry(processedRequest.type);
-    const { handler, isDelegated } = selectHandler(entry, processedRequest);
-    if (handlerSupportsProgress(entry, processedRequest)) {
-        yield* streamWithProgress(processedRequest, handler, isDelegated);
-    }
-    else {
-        const result = executeDirectHandler(processedRequest, handler, isDelegated);
-        // Check if the handler returns a Promise or AsyncGenerator
-        if (isAsyncGenerator(result)) {
-            // It's an AsyncGenerator
-            yield* result;
-        }
-        else {
-            // It's a Promise, await and yield the single result
-            yield await result;
-        }
-    }
-}
-function createMockRPCRequest() {
-    let requestData = null;
-    return {
-        send(payload) {
-            // Parse the JSON payload to get the actual request data
-            requestData = JSON.parse(payload);
-        },
-        async reply() {
-            if (!requestData) {
-                throw new RPCRequestNotSentError();
-            }
-            // Handle special internal config initialization message
-            if (typeof requestData === 'object' &&
-                'type' in requestData &&
-                requestData.type === '__init_config') {
-                try {
-                    const initData = requestData;
-                    if (initData.config) {
-                        setSDKConfig(initData.config);
-                    }
-                    if (initData.runtimeContext) {
-                        setRuntimeContext(initData.runtimeContext);
-                    }
-                    return Buffer.from(JSON.stringify({ success: true }));
-                }
-                catch (error) {
-                    return Buffer.from(JSON.stringify({
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error)
-                    }));
-                }
-            }
-            // Handle special pre-terminate cleanup signal. In direct mode the
-            // bare runtime is the host JS context, so we run cleanup but never
-            // exit the process here.
-            if (typeof requestData === 'object' &&
-                'type' in requestData &&
-                requestData.type === '__shutdown__') {
-                try {
-                    await cleanupForTerminate();
-                    return Buffer.from(JSON.stringify({ success: true }));
-                }
-                catch (error) {
-                    return Buffer.from(JSON.stringify({
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error)
-                    }));
-                }
-            }
-            const response = await send(requestData);
-            return Buffer.from(JSON.stringify(response));
-        },
-        async *createResponseStream() {
-            if (!requestData) {
-                throw new RPCRequestNotSentError();
-            }
-            for await (const response of stream(requestData)) {
-                yield Buffer.from(JSON.stringify(response) + '\n');
-            }
-        }
-    };
-}
-let configInitialized = false;
-// No child worker on Bare-direct — `#rpc` interface stub.
-export function getWorkerLifeSignal() {
-    return null;
-}
-// No life signal on Bare-direct, so the RPC layer never calls this — `#rpc` interface stub.
-export function notifyChannelClosed() { }
-export async function getRPC() {
-    await ensureWorkerReady();
-    const mockRPC = {
-        request() {
-            return createMockRPCRequest();
-        }
-    };
-    // Initialize config once on first call
-    if (!configInitialized) {
-        const runtimeContext = {
-            runtime: 'bare',
-            platform: os.platform()
-        };
-        await initializeConfig(mockRPC, resolveConfig, runtimeContext);
-        configInitialized = true;
-    }
-    return mockRPC;
-}
-export async function close() {
-    await cleanupForTerminate();
-}
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function createDuplexSession(payload, _commandId) {
-    await getRPC();
-    const { PassThrough } = await import('bare-stream');
-    const request = JSON.parse(payload);
-    assertLifecycleAllowed(request);
-    const entry = registry[request.type];
-    if (!entry || entry.type !== 'duplex') {
-        throw new RPCNoHandlerError(request.type);
-    }
-    const inputStream = new PassThrough();
-    const outputStream = new PassThrough();
-    const duplexHandler = entry.handler;
-    void (async () => {
-        try {
-            for await (const response of duplexHandler(request, inputStream)) {
-                outputStream.write(JSON.stringify(response) + '\n', 'utf-8');
-            }
-        }
-        catch (error) {
-            inputStream.destroy();
-            const errorResponse = createErrorResponse(error);
-            outputStream.write(JSON.stringify(errorResponse) + '\n', 'utf-8');
-        }
-        finally {
-            outputStream.end();
-        }
-    })();
-    return {
-        requestStream: inputStream,
-        responseStream: outputStream
-    };
-}

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

@@ -1,196 +0,0 @@
-import RPC from 'bare-rpc';
-import { RPCConnectionFailedError } from '../../utils/errors-client.js';
-import { initializeConfig } from '../../client/init-hooks.js';
-import { resolveConfig } from '../../client/config-loader/resolve-config.expo.js';
-import { getClientLogger } from '../../logging/index.js';
-import { getDeviceInfo } from '../../client/rpc/expo-device-info.js';
-const logger = getClientLogger();
-let rpcInstance = null;
-let rpcPromise = null;
-let workletInstance = null;
-let workletInitialized = false;
-let cachedRuntimeContext;
-// Set while close() is in flight. Concurrent callers share the same
-// promise instead of double-sending __shutdown__ or re-entering the
-// terminate block on already-null state.
-let closingPromise = null;
-logger.debug('EXPO RPC Client bundle');
-async function getRuntimeContext() {
-    if (cachedRuntimeContext) {
-        return cachedRuntimeContext;
-    }
-    const { platform, deviceModel, deviceBrand } = await getDeviceInfo();
-    cachedRuntimeContext = {
-        runtime: 'react-native',
-        platform,
-        deviceModel,
-        deviceBrand
-    };
-    return cachedRuntimeContext;
-}
-// No child-process exit on Expo (Worklet lifecycle) — `#rpc` interface stub.
-export function getWorkerLifeSignal() {
-    return null;
-}
-// No life signal on Expo, so the RPC layer never calls this — `#rpc` interface stub.
-export function notifyChannelClosed() { }
-export async function getRPC() {
-    if (rpcInstance) {
-        return rpcInstance;
-    }
-    if (rpcPromise) {
-        return rpcPromise;
-    }
-    rpcPromise = (async () => {
-        if (workletInstance) {
-            logger.debug('🔄 Reusing existing worklet');
-            rpcInstance = new RPC(workletInstance.IPC, () => { });
-            // Only initialize once per worklet - server state persists
-            if (!workletInitialized) {
-                const runtimeContext = await getRuntimeContext();
-                await initializeConfig(rpcInstance, resolveConfig, runtimeContext);
-                workletInitialized = true;
-            }
-            return rpcInstance;
-        }
-        const { Paths } = await import('expo-file-system');
-        const bareKitModule = await import('react-native-bare-kit');
-        const worklet = new bareKitModule.Worklet();
-        workletInstance = worklet;
-        logger.debug('Starting new worklet');
-        // Load the mobile bundle - generated by expo plugin during prebuild
-        // The expo plugin handles bundle selection:
-        // 1. Uses qvac/worker.bundle.js if exists (user pre-generated)
-        // 2. Generates tree-shaken bundle if qvac.config.* exists
-        // 3. Generates default bundle (all plugins) otherwise
-        let mobileBundle;
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            mobileBundle = require('@qvac/sdk/worker.mobile.bundle');
-        }
-        catch (error) {
-            const message = 'Failed to load mobile worker bundle. Make sure the QVAC Expo plugin is configured. ' +
-                `Add '@qvac/sdk/expo-plugin' to your app.json plugins array. ` +
-                `Error: ${String(error)}`;
-            logger.error(message);
-            throw new RPCConnectionFailedError(message, error instanceof Error ? error : undefined);
-        }
-        worklet.start('worker.bundle', mobileBundle, [
-            // Normalize arg number across platforms
-            'react-native-bare-kit',
-            'worker.js',
-            JSON.stringify({
-                HOME_DIR: Paths.document.uri.replace('file://', '')
-            })
-        ]);
-        logger.info('Worklet started');
-        rpcInstance = new RPC(worklet.IPC, () => {
-            // Use this for async callbacks
-        });
-        const runtimeContext = await getRuntimeContext();
-        await initializeConfig(rpcInstance, resolveConfig, runtimeContext);
-        workletInitialized = true;
-        return rpcInstance;
-    })();
-    try {
-        return await rpcPromise;
-    }
-    catch (error) {
-        logger.error(`Failed to initialize RPC: ${String(error)}`);
-        throw error;
-    }
-    finally {
-        rpcPromise = null;
-    }
-}
-const SHUTDOWN_RPC_TIMEOUT_MS = 10_000;
-/**
- * Pre-terminate cleanup roundtrip. Sends an internal `__shutdown__` message
- * to the worker so it can clear addon plugin registries (calls each addon's
- * `releaseLogger` → frees env-bound js_ref_t state) and unload all model
- * instances BEFORE we kill the worklet.
- *
- * Without this, the worklet's V8 isolate dies while addon static state still
- * holds js_ref_t handles into it; the next worklet's first `setLogger` call
- * trips a V8 GlobalHandle assertion (brk 0 / SIGTRAP) and the iOS app dies.
- *
- * Best-effort: never throws. Falls through to terminate even on timeout.
- */
-async function sendShutdownMessage(rpc) {
-    let timer;
-    try {
-        await Promise.race([
-            (async () => {
-                const req = rpc.request(1);
-                req.send(JSON.stringify({ type: '__shutdown__' }), 'utf8');
-                const response = await req.reply('utf8');
-                const parsed = JSON.parse(String(response));
-                if (!parsed.success) {
-                    throw new Error(parsed.error ?? 'Worker reported cleanup failure');
-                }
-            })(),
-            new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error(`Worker did not ack __shutdown__ within ${SHUTDOWN_RPC_TIMEOUT_MS}ms`)), SHUTDOWN_RPC_TIMEOUT_MS);
-            })
-        ]);
-    }
-    catch (error) {
-        // Best-effort: log but don't block termination if cleanup fails.
-        logger.warn(`⚠️ Pre-terminate worker cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-export async function close() {
-    // Concurrent callers (or a getRPC retry that overlaps with a manual
-    // close) share the in-flight close promise instead of each sending
-    // their own __shutdown__ and racing on the terminate block.
-    if (closingPromise)
-        return closingPromise;
-    closingPromise = (async () => {
-        logger.info('🧹 Closing RPC client (Expo)');
-        // The inference addons self-pin (RTLD_NODELETE, qvac-lib-inference-addon-cpp
-        // >= 1.2.2), so dlclose() during terminate() no longer unmaps addon code
-        // with dangling pthread_key_t destructors. terminate() is therefore safe on
-        // every platform (previously it was skipped on non-iOS to avoid a SIGSEGV in
-        // pthread_key_clean_all), so we always run the full pre-terminate cleanup +
-        // terminate path.
-        if (rpcInstance) {
-            logger.info('🧹 Requesting worker pre-terminate cleanup');
-            await sendShutdownMessage(rpcInstance);
-        }
-        rpcInstance = null;
-        rpcPromise = null;
-        if (workletInstance) {
-            logger.info('🐻🔫 Terminating bare worklet');
-            try {
-                workletInstance.terminate();
-            }
-            catch (error) {
-                logger.debug('Failed to terminate worklet', { error });
-            }
-            workletInstance = null;
-            workletInitialized = false;
-        }
-    })();
-    try {
-        await closingPromise;
-    }
-    finally {
-        // Reset so a subsequent close() (e.g. after a fresh getRPC spawned
-        // a new worklet) can run again. Body guards on rpcInstance / workletInstance
-        // make a redundant call a no-op if state is already cleared.
-        closingPromise = null;
-    }
-}
-export async function createDuplexSession(payload, commandId) {
-    const rpc = await getRPC();
-    const req = rpc.request(commandId);
-    const requestStream = req.createRequestStream();
-    const responseStream = req.createResponseStream({ encoding: 'utf-8' });
-    // Pre-encode payload — RN/Hermes lacks a global `Buffer`, so `write(string, "utf-8")` would throw.
-    requestStream.write(new TextEncoder().encode(payload));
-    return { requestStream, responseStream };
-}