@qvac/sdk 0.14.0 → 0.15.0

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

@@ -1,17 +1,17 @@
-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 "../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 "../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 "./ensure-worker-ready.js";
+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 '../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 '../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 './ensure-worker-ready.js';
 async function ensureWorkerReady() {
     initializeWorkerCore();
     await ensurePluginsRegistered();
@@ -24,7 +24,7 @@ function getHandlerEntry(type) {
     return entry;
 }
 function applyDeviceDefaultsToLoadModel(request) {
-    if (request.type !== "loadModel" || !("modelSrc" in request)) {
+    if (request.type !== 'loadModel' || !('modelSrc' in request)) {
         return request;
     }
     let canonicalType;
@@ -66,9 +66,7 @@ function executeDirectHandler(request, handler, isDelegated) {
     return directHandler(request);
 }
 function isAsyncGenerator(result) {
-    return (typeof result === "object" &&
-        result !== null &&
-        Symbol.asyncIterator in result);
+    return typeof result === 'object' && result !== null && Symbol.asyncIterator in result;
 }
 async function* streamWithProgress(request, handler, isDelegated) {
     const queue = [];
@@ -78,9 +76,7 @@ async function* streamWithProgress(request, handler, isDelegated) {
         queue.push(update);
     }
     const directHandler = handler;
-    Promise.resolve(directHandler(request, isDelegated
-        ? createDelegatedOptions(request, progressCallback)
-        : progressCallback))
+    Promise.resolve(directHandler(request, isDelegated ? createDelegatedOptions(request, progressCallback) : progressCallback))
         .then((final) => {
         queue.push(final);
         done = true;
@@ -142,9 +138,9 @@ function createMockRPCRequest() {
                 throw new RPCRequestNotSentError();
             }
             // Handle special internal config initialization message
-            if (typeof requestData === "object" &&
-                "type" in requestData &&
-                requestData.type === "__init_config") {
+            if (typeof requestData === 'object' &&
+                'type' in requestData &&
+                requestData.type === '__init_config') {
                 try {
                     const initData = requestData;
                     if (initData.config) {
@@ -158,16 +154,16 @@ function createMockRPCRequest() {
                 catch (error) {
                     return Buffer.from(JSON.stringify({
                         success: false,
-                        error: error instanceof Error ? error.message : String(error),
+                        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__") {
+            if (typeof requestData === 'object' &&
+                'type' in requestData &&
+                requestData.type === '__shutdown__') {
                 try {
                     await cleanupForTerminate();
                     return Buffer.from(JSON.stringify({ success: true }));
@@ -175,7 +171,7 @@ function createMockRPCRequest() {
                 catch (error) {
                     return Buffer.from(JSON.stringify({
                         success: false,
-                        error: error instanceof Error ? error.message : String(error),
+                        error: error instanceof Error ? error.message : String(error)
                     }));
                 }
             }
@@ -187,9 +183,9 @@ function createMockRPCRequest() {
                 throw new RPCRequestNotSentError();
             }
             for await (const response of stream(requestData)) {
-                yield Buffer.from(JSON.stringify(response) + "\n");
+                yield Buffer.from(JSON.stringify(response) + '\n');
             }
-        },
+        }
     };
 }
 let configInitialized = false;
@@ -197,18 +193,20 @@ let configInitialized = false;
 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(),
+            runtime: 'bare',
+            platform: os.platform()
         };
         await initializeConfig(mockRPC, resolveConfig, runtimeContext);
         configInitialized = true;
@@ -221,11 +219,11 @@ export async function close() {
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function createDuplexSession(payload, _commandId) {
     await getRPC();
-    const { PassThrough } = await import("bare-stream");
+    const { PassThrough } = await import('bare-stream');
     const request = JSON.parse(payload);
     assertLifecycleAllowed(request);
     const entry = registry[request.type];
-    if (!entry || entry.type !== "duplex") {
+    if (!entry || entry.type !== 'duplex') {
         throw new RPCNoHandlerError(request.type);
     }
     const inputStream = new PassThrough();
@@ -234,13 +232,13 @@ export async function createDuplexSession(payload, _commandId) {
     void (async () => {
         try {
             for await (const response of duplexHandler(request, inputStream)) {
-                outputStream.write(JSON.stringify(response) + "\n", "utf-8");
+                outputStream.write(JSON.stringify(response) + '\n', 'utf-8');
             }
         }
         catch (error) {
             inputStream.destroy();
             const errorResponse = createErrorResponse(error);
-            outputStream.write(JSON.stringify(errorResponse) + "\n", "utf-8");
+            outputStream.write(JSON.stringify(errorResponse) + '\n', 'utf-8');
         }
         finally {
             outputStream.end();
@@ -248,6 +246,6 @@ export async function createDuplexSession(payload, _commandId) {
     })();
     return {
         requestStream: inputStream,
-        responseStream: outputStream,
+        responseStream: outputStream
     };
 }

package/dist/client/rpc/ensure-worker-ready.js

@@ -1,6 +1,6 @@
-import { getAllPlugins } from "../../server/plugins/index.js";
-import { PearWorkerEntryRequiredError, WorkerPluginsNotRegisteredError, } from "../../utils/errors-client.js";
-const PEAR_WORKER_ENTRY_PATH = "qvac/worker.pear.entry.mjs";
+import { getAllPlugins } from '../../server/plugins/index.js';
+import { PearWorkerEntryRequiredError, WorkerPluginsNotRegisteredError } from '../../utils/errors-client.js';
+const PEAR_WORKER_ENTRY_PATH = 'qvac/worker.pear.entry.mjs';
 /**
  * Throw if no plugins are registered before an SDK call. On Pear,
  * point at the generated worker entry; otherwise raise a generic
@@ -9,7 +9,7 @@ const PEAR_WORKER_ENTRY_PATH = "qvac/worker.pear.entry.mjs";
 export async function ensurePluginsRegistered(opts) {
     if (getAllPlugins().length > 0)
         return;
-    const isPear = opts?.isPear ?? (await import("which-runtime")).isPear;
+    const isPear = opts?.isPear ?? (await import('which-runtime')).isPear;
     if (isPear) {
         throw new PearWorkerEntryRequiredError(PEAR_WORKER_ENTRY_PATH);
     }

package/dist/client/rpc/expo-device-info.d.ts

@@ -1,5 +1,5 @@
 export declare function getDeviceInfo(): Promise<{
-    platform: "android" | "ios" | undefined;
+    platform: 'android' | 'ios' | undefined;
     deviceModel: string | undefined;
     deviceBrand: string | undefined;
 }>;

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

@@ -1,32 +1,32 @@
-import { getClientLogger } from "../../logging/index.js";
+import { getClientLogger } from '../../logging/index.js';
 const logger = getClientLogger();
 export async function getDeviceInfo() {
     try {
-        const expoModulesCore = await import("expo-modules-core");
+        const expoModulesCore = await import('expo-modules-core');
         // this looks odd, but is necessary to ensure that import can be used safely.
         // It will crash the app if the module is not installed, but the node dependency is present.
-        const nativeDeviceModule = expoModulesCore.requireOptionalNativeModule("ExpoDevice");
+        const nativeDeviceModule = expoModulesCore.requireOptionalNativeModule('ExpoDevice');
         if (nativeDeviceModule) {
-            const Device = await import("expo-device");
+            const Device = await import('expo-device');
             logger.info(`Device: ${Device.modelName} ${Device.brand} ${Device.osName}`);
             const osName = Device?.osName?.toLowerCase();
             return {
-                platform: osName?.includes("ios")
-                    ? "ios"
-                    : osName?.includes("android")
-                        ? "android"
+                platform: osName?.includes('ios')
+                    ? 'ios'
+                    : osName?.includes('android')
+                        ? 'android'
                         : undefined,
                 deviceModel: Device.modelName ?? undefined,
-                deviceBrand: Device.brand ?? undefined,
+                deviceBrand: Device.brand ?? undefined
             };
         }
     }
     catch {
-        logger.debug("expo-device not available, device info will be omitted");
+        logger.debug('expo-device not available, device info will be omitted');
     }
     return {
         platform: undefined,
         deviceModel: undefined,
-        deviceBrand: undefined,
+        deviceBrand: undefined
     };
 }

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

@@ -1,5 +1,6 @@
-import RPC from "bare-rpc";
+import RPC from 'bare-rpc';
 export declare function getWorkerLifeSignal(): AbortSignal | null;
+export declare function notifyChannelClosed(): void;
 export declare function getRPC(): Promise<RPC>;
 export declare function close(): Promise<void>;
 export declare function createDuplexSession(payload: string, commandId: number): Promise<{

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

@@ -1,9 +1,9 @@
-import RPC from "bare-rpc";
-import { RPCConnectionFailedError } from "../../utils/errors-client.js";
-import { initializeConfig } from "../init-hooks.js";
-import { resolveConfig } from "../config-loader/resolve-config.expo.js";
-import { getClientLogger } from "../../logging/index.js";
-import { getDeviceInfo } from "./expo-device-info.js";
+import RPC from 'bare-rpc';
+import { RPCConnectionFailedError } from '../../utils/errors-client.js';
+import { initializeConfig } from '../init-hooks.js';
+import { resolveConfig } from '../config-loader/resolve-config.expo.js';
+import { getClientLogger } from '../../logging/index.js';
+import { getDeviceInfo } from './expo-device-info.js';
 const logger = getClientLogger();
 let rpcInstance = null;
 let rpcPromise = null;
@@ -14,17 +14,17 @@ let cachedRuntimeContext;
 // 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");
+logger.debug('EXPO RPC Client bundle');
 async function getRuntimeContext() {
     if (cachedRuntimeContext) {
         return cachedRuntimeContext;
     }
     const { platform, deviceModel, deviceBrand } = await getDeviceInfo();
     cachedRuntimeContext = {
-        runtime: "react-native",
+        runtime: 'react-native',
         platform,
         deviceModel,
-        deviceBrand,
+        deviceBrand
     };
     return cachedRuntimeContext;
 }
@@ -32,6 +32,8 @@ async function getRuntimeContext() {
 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;
@@ -41,7 +43,7 @@ export async function getRPC() {
     }
     rpcPromise = (async () => {
         if (workletInstance) {
-            logger.debug("🔄 Reusing existing worklet");
+            logger.debug('🔄 Reusing existing worklet');
             rpcInstance = new RPC(workletInstance.IPC, () => { });
             // Only initialize once per worklet - server state persists
             if (!workletInitialized) {
@@ -51,11 +53,11 @@ export async function getRPC() {
             }
             return rpcInstance;
         }
-        const { Paths } = await import("expo-file-system");
-        const bareKitModule = await import("react-native-bare-kit");
+        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");
+        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)
@@ -64,24 +66,24 @@ export async function getRPC() {
         let mobileBundle;
         try {
             // eslint-disable-next-line @typescript-eslint/no-require-imports
-            mobileBundle = require("@qvac/sdk/worker.mobile.bundle");
+            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. " +
+            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, [
+        worklet.start('worker.bundle', mobileBundle, [
             // Normalize arg number across platforms
-            "react-native-bare-kit",
-            "worker.js",
+            'react-native-bare-kit',
+            'worker.js',
             JSON.stringify({
-                HOME_DIR: Paths.document.uri.replace("file://", ""),
-            }),
+                HOME_DIR: Paths.document.uri.replace('file://', '')
+            })
         ]);
-        logger.info("Worklet started");
+        logger.info('Worklet started');
         rpcInstance = new RPC(worklet.IPC, () => {
             // Use this for async callbacks
         });
@@ -120,16 +122,16 @@ async function sendShutdownMessage(rpc) {
         await Promise.race([
             (async () => {
                 const req = rpc.request(1);
-                req.send(JSON.stringify({ type: "__shutdown__" }), "utf8");
-                const response = await req.reply("utf8");
+                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");
+                    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) {
@@ -148,37 +150,26 @@ export async function close() {
     if (closingPromise)
         return closingPromise;
     closingPromise = (async () => {
-        logger.info("🧹 Closing RPC client (Expo)");
-        // terminate() crashes on Android (addon dlclose leaves pthread_key_t
-        // destructors dangling); iOS dyld no-ops dlclose so it's safe there.
-        // Non-iOS: drop refs only -- sending __shutdown__ without a follow-up
-        // terminate would clear the worker plugin registry.
-        let platform;
-        try {
-            platform = (await getRuntimeContext()).platform;
-        }
-        catch (err) {
-            logger.debug("Failed to resolve runtime context for close()", { err });
-        }
-        if (platform !== "ios") {
-            rpcInstance = null;
-            rpcPromise = null;
-            return;
-        }
-        // iOS: existing pre-terminate cleanup + terminate.
+        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");
+            logger.info('🧹 Requesting worker pre-terminate cleanup');
             await sendShutdownMessage(rpcInstance);
         }
         rpcInstance = null;
         rpcPromise = null;
         if (workletInstance) {
-            logger.info("🐻🔫 Terminating bare worklet");
+            logger.info('🐻🔫 Terminating bare worklet');
             try {
                 workletInstance.terminate();
             }
             catch (error) {
-                logger.debug("Failed to terminate worklet", { error });
+                logger.debug('Failed to terminate worklet', { error });
             }
             workletInstance = null;
             workletInitialized = false;
@@ -198,7 +189,7 @@ 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" });
+    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 };

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

@@ -1,5 +1,6 @@
-import RPC from "bare-rpc";
+import RPC from 'bare-rpc';
 export declare function getWorkerLifeSignal(): AbortSignal | null;
+export declare function notifyChannelClosed(): void;
 export declare function getRPC(): Promise<RPC>;
 export declare function createDuplexSession(payload: string, commandId: number): Promise<{
     requestStream: RPC.OutgoingStream;