@qvac/sdk 0.14.1 → 0.15.0

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

@@ -1,13 +1,13 @@
-import { requestSchema, responseSchema, PROFILING_TRAILER_KEY, } from "../../schemas/index.js";
-import { reconstructError } from "./rpc-error.js";
-import { withTimeout, withTimeoutStream } from "../../utils/withTimeout.js";
-import { getClientLogger, summarizeRequest } from "../../logging/index.js";
-import { getRPC, close as closeRPC, createDuplexSession, getWorkerLifeSignal, } from "#rpc";
-import { WorkerCrashedError, RequestValidationFailedError, } from "../../utils/errors-client.js";
-import { formatZodError } from "../../utils/zod-error.js";
-import { z } from "zod";
-import { nowMs, shouldProfile, shouldIncludeServerBreakdown, generateId as createProfileId, createProfilingMeta, createProfilingDisabledMeta, injectProfilingMetaIntoObject, extractProfilingMeta, stripProfilingMeta, recordFailure, } from "../../profiling/index.js";
-import { createClientTimings, createClientStreamTimings, recordClientEvents, recordClientStreamEvents, cacheConnectionTime, flushConnectionTime, resetConnectionTracking, } from "./profiling/index.js";
+import { requestSchema, responseSchema, PROFILING_TRAILER_KEY } from '../../schemas/index.js';
+import { reconstructError } from './rpc-error.js';
+import { withTimeout, withTimeoutStream, OperationTimeoutError } from '../../utils/withTimeout.js';
+import { getClientLogger, summarizeRequest } from '../../logging/index.js';
+import { getRPC, close as closeRPC, createDuplexSession, getWorkerLifeSignal, notifyChannelClosed } from '#rpc';
+import { WorkerCrashedError, RequestValidationFailedError } from '../../utils/errors-client.js';
+import { formatZodError } from '../../utils/zod-error.js';
+import { z } from 'zod';
+import { nowMs, shouldProfile, shouldIncludeServerBreakdown, generateId as createProfileId, createProfilingMeta, createProfilingDisabledMeta, injectProfilingMetaIntoObject, extractProfilingMeta, stripProfilingMeta, recordFailure } from '../../profiling/index.js';
+import { createClientTimings, createClientStreamTimings, recordClientEvents, recordClientStreamEvents, cacheConnectionTime, flushConnectionTime, resetConnectionTracking } from './profiling/index.js';
 const logger = getClientLogger();
 let rpcInstance = null;
 let commandCounter = 0;
@@ -18,14 +18,14 @@ function getNextCommandId() {
 }
 function memberDiscriminator(option) {
     const direct = option.shape?.type?.value;
-    if (typeof direct === "string")
+    if (typeof direct === 'string')
         return direct;
     const nested = option.options?.[0]?.shape?.type?.value;
-    return typeof nested === "string" ? nested : undefined;
+    return typeof nested === 'string' ? nested : undefined;
 }
 function pinpointRequestError(request, fallback) {
     const type = request?.type;
-    if (typeof type !== "string")
+    if (typeof type !== 'string')
         return fallback;
     for (const option of requestSchema.options) {
         if (memberDiscriminator(option) !== type)
@@ -47,9 +47,25 @@ function parseRequest(request) {
     }
 }
 // Race in-flight reply/stream pulls against the worker-life signal —
-// bare-rpc's `_onerror` does not iterate `_outgoingRequests`, so without
-// this they hang on a dead socket.
+// bare-rpc's `_onerror`/`_onclose` reject a pending reply or destroy a
+// stream with its own generic `RPCError` (e.g. `CHANNEL_CLOSED`) as soon
+// as the channel dies, which can beat the SDK's own crash detection
+// (driven by the child process's `'exit'` event). Since `req.reply()` and
+// response streams never reject with an application-level error — those
+// always arrive as a resolved payload handled by `checkAndThrowError` —
+// any rejection reaching these helpers other than our own `withTimeout`
+// is transport failure. Under our IPC transport a channel close always
+// means the worker is gone, so remapping it to the life signal's reason
+// (or a generic crash if the signal hasn't fired yet) is safe.
+//
+// When we win that race, the life signal hasn't aborted yet, so nothing
+// has invalidated the cached RPC connection — the next call would reuse
+// the same dead channel and fail again. `notifyChannelClosed()` tears it
+// down eagerly instead of waiting on the slow exit event; it's a no-op
+// once the signal is already aborted, so this is safe to call every time.
 function lifeSignalAbortError(signal) {
+    if (!signal.aborted)
+        notifyChannelClosed();
     if (signal.reason instanceof Error)
         return signal.reason;
     return new WorkerCrashedError(null, null);
@@ -59,31 +75,36 @@ async function awaitWithLifeSignal(p) {
     const lifeSignal = getWorkerLifeSignal();
     if (!lifeSignal)
         return p;
-    if (lifeSignal.aborted)
+    if (lifeSignal.aborted) {
+        // `p` (e.g. `req.reply()`) may already be a rejected promise — bare-rpc
+        // 1.3.8 rejects synchronously once its channel is closed. We're
+        // discarding it in favour of the life signal's classification, so give
+        // it a handler or its rejection surfaces as an unhandled rejection.
+        p.catch(() => { });
         throw lifeSignalAbortError(lifeSignal);
+    }
     return await new Promise((resolve, reject) => {
         let settled = false;
         const onAbort = () => {
             if (settled)
                 return;
             settled = true;
-            lifeSignal.removeEventListener("abort", onAbort);
+            lifeSignal.removeEventListener('abort', onAbort);
             reject(lifeSignalAbortError(lifeSignal));
         };
-        lifeSignal.addEventListener("abort", onAbort, { once: true });
+        lifeSignal.addEventListener('abort', onAbort, { once: true });
         p.then((value) => {
             if (settled)
                 return;
             settled = true;
-            lifeSignal.removeEventListener("abort", onAbort);
+            lifeSignal.removeEventListener('abort', onAbort);
             resolve(value);
         }, (err) => {
             if (settled)
                 return;
             settled = true;
-            lifeSignal.removeEventListener("abort", onAbort);
-            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors -- forwarding upstream rejection as-is
-            reject(err);
+            lifeSignal.removeEventListener('abort', onAbort);
+            reject(err instanceof OperationTimeoutError ? err : lifeSignalAbortError(lifeSignal));
         });
     });
 }
@@ -105,23 +126,22 @@ async function* iterateWithLifeSignal(source) {
                     if (settled)
                         return;
                     settled = true;
-                    lifeSignal.removeEventListener("abort", onAbort);
+                    lifeSignal.removeEventListener('abort', onAbort);
                     reject(lifeSignalAbortError(lifeSignal));
                 };
-                lifeSignal.addEventListener("abort", onAbort, { once: true });
+                lifeSignal.addEventListener('abort', onAbort, { once: true });
                 nextP.then((value) => {
                     if (settled)
                         return;
                     settled = true;
-                    lifeSignal.removeEventListener("abort", onAbort);
+                    lifeSignal.removeEventListener('abort', onAbort);
                     resolve(value);
                 }, (err) => {
                     if (settled)
                         return;
                     settled = true;
-                    lifeSignal.removeEventListener("abort", onAbort);
-                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors -- forwarding upstream rejection as-is
-                    reject(err);
+                    lifeSignal.removeEventListener('abort', onAbort);
+                    reject(err instanceof OperationTimeoutError ? err : lifeSignalAbortError(lifeSignal));
                 });
             });
             if (result.done)
@@ -139,7 +159,7 @@ async function* iterateWithLifeSignal(source) {
     }
 }
 function checkAndThrowError(response) {
-    if (response.type === "error") {
+    if (response.type === 'error') {
         // Use the typed-error reconstructor map in `rpc-error.ts` so the
         // original class (e.g. `RequestRejectedByPolicyError`) survives
         // the RPC boundary intact and `err instanceof <Class>` works in
@@ -166,8 +186,8 @@ async function getRPCInstance() {
         invalidateRPCInstance();
     }
     else if (lifeSignal) {
-        lifeSignal.addEventListener("abort", invalidateRPCInstance, {
-            once: true,
+        lifeSignal.addEventListener('abort', invalidateRPCInstance, {
+            once: true
         });
     }
     if (connectionStart !== null && firstConnectionPending) {
@@ -198,15 +218,15 @@ export async function send(request, options, rpc) {
 async function sendBase(request, rpc, options, signalDisable = false) {
     const parsedRequest = parseRequest(request);
     const req = rpc.request(getNextCommandId());
-    logger.debug("RPC Client sending:", summarizeRequest(request));
+    logger.debug('RPC Client sending:', summarizeRequest(request));
     const payloadObj = signalDisable
         ? injectProfilingMetaIntoObject(parsedRequest, createProfilingDisabledMeta())
         : parsedRequest;
     const payload = JSON.stringify(payloadObj);
-    req.send(payload, "utf-8");
-    const response = await awaitWithLifeSignal(withTimeout(req.reply("utf-8"), options?.timeout));
-    const resPayload = responseSchema.parse(JSON.parse(response?.toString() || "{}"));
-    logger.debug("ResPayload", { type: resPayload.type });
+    req.send(payload, 'utf-8');
+    const response = await awaitWithLifeSignal(withTimeout(req.reply('utf-8'), options?.timeout));
+    const resPayload = responseSchema.parse(JSON.parse(response?.toString() || '{}'));
+    logger.debug('ResPayload', { type: resPayload.type });
     checkAndThrowError(resPayload);
     return resPayload;
 }
@@ -220,18 +240,18 @@ async function sendProfiled(request, rpc, options) {
         const parsedRequest = parseRequest(request);
         timings.requestZodValidationMs = nowMs() - zodStart;
         const req = rpc.request(getNextCommandId());
-        logger.debug("RPC Client sending:", summarizeRequest(request));
+        logger.debug('RPC Client sending:', summarizeRequest(request));
         const profilingMeta = createProfilingMeta(profileId, includeServer);
         const requestWithMeta = injectProfilingMetaIntoObject(parsedRequest, profilingMeta);
         const stringifyStart = nowMs();
         const payload = JSON.stringify(requestWithMeta);
         timings.requestStringifyMs = nowMs() - stringifyStart;
         timings.sendStart = nowMs();
-        req.send(payload, "utf-8");
-        const response = await awaitWithLifeSignal(withTimeout(req.reply("utf-8"), options?.timeout));
+        req.send(payload, 'utf-8');
+        const response = await awaitWithLifeSignal(withTimeout(req.reply('utf-8'), options?.timeout));
         timings.firstResponseAt = nowMs();
         const parseStart = nowMs();
-        const rawParsed = JSON.parse(response?.toString() || "{}");
+        const rawParsed = JSON.parse(response?.toString() || '{}');
         timings.responseJsonParseMs = nowMs() - parseStart;
         const responseMeta = extractProfilingMeta(rawParsed);
         const cleanPayload = stripProfilingMeta(rawParsed);
@@ -239,7 +259,7 @@ async function sendProfiled(request, rpc, options) {
         const resPayload = responseSchema.parse(cleanPayload);
         timings.responseZodValidationMs = nowMs() - zodValidateStart;
         timings.requestEnd = nowMs();
-        logger.debug("ResPayload", { type: resPayload.type });
+        logger.debug('ResPayload', { type: resPayload.type });
         recordClientEvents(timings, responseMeta);
         checkAndThrowError(resPayload);
         return resPayload;
@@ -249,8 +269,8 @@ async function sendProfiled(request, rpc, options) {
             const base = {
                 ts: nowMs(),
                 op: timings.requestType,
-                kind: "rpc",
-                profileId: timings.profileId,
+                kind: 'rpc',
+                profileId: timings.profileId
             };
             recordFailure(base, timings.requestStart, error);
         }
@@ -268,13 +288,13 @@ export async function* stream(request, options = {}, rpc) {
 async function* streamBase(request, rpc, options = {}, signalDisable = false) {
     const parsedRequest = parseRequest(request);
     const req = rpc.request(getNextCommandId());
-    logger.debug("RPC Client streaming:", summarizeRequest(request));
+    logger.debug('RPC Client streaming:', summarizeRequest(request));
     const payloadObj = signalDisable
         ? injectProfilingMetaIntoObject(parsedRequest, createProfilingDisabledMeta())
         : parsedRequest;
-    req.send(JSON.stringify(payloadObj), "utf-8");
-    const responseStream = req.createResponseStream({ encoding: "utf-8" });
-    let buffer = "";
+    req.send(JSON.stringify(payloadObj), 'utf-8');
+    const responseStream = req.createResponseStream({ encoding: 'utf-8' });
+    let buffer = '';
     async function* processStream() {
         for await (const chunk of responseStream) {
             yield chunk;
@@ -284,8 +304,8 @@ async function* streamBase(request, rpc, options = {}, signalDisable = false) {
     for await (const chunk of iterateWithLifeSignal(streamWithTimeout)) {
         buffer += chunk.toString();
         // Process complete lines (newline-delimited JSON)
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || ""; // Keep incomplete line in buffer
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || ''; // Keep incomplete line in buffer
         for (const line of lines) {
             if (line.trim()) {
                 const response = responseSchema.parse(JSON.parse(line));
@@ -306,16 +326,16 @@ async function* streamProfiled(request, rpc, options = {}) {
         const parsedRequest = parseRequest(request);
         timings.requestZodValidationMs = nowMs() - zodStart;
         const req = rpc.request(getNextCommandId());
-        logger.debug("RPC Client streaming:", summarizeRequest(request));
+        logger.debug('RPC Client streaming:', summarizeRequest(request));
         const requestMeta = createProfilingMeta(profileId, includeServer);
         const requestWithMeta = injectProfilingMetaIntoObject(parsedRequest, requestMeta);
         const stringifyStart = nowMs();
         const payload = JSON.stringify(requestWithMeta);
         timings.requestStringifyMs = nowMs() - stringifyStart;
         timings.sendStart = nowMs();
-        req.send(payload, "utf-8");
-        const responseStream = req.createResponseStream({ encoding: "utf-8" });
-        let buffer = "";
+        req.send(payload, 'utf-8');
+        const responseStream = req.createResponseStream({ encoding: 'utf-8' });
+        let buffer = '';
         async function* processStream() {
             for await (const chunk of responseStream) {
                 yield chunk;
@@ -329,8 +349,8 @@ async function* streamProfiled(request, rpc, options = {}) {
             }
             timings.lastChunkAt = chunkTime;
             buffer += chunk.toString();
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
             for (const line of lines) {
                 if (line.trim()) {
                     const rawParsed = JSON.parse(line);
@@ -354,8 +374,8 @@ async function* streamProfiled(request, rpc, options = {}) {
             const base = {
                 ts: nowMs(),
                 op: timings.requestType,
-                kind: "rpc",
-                profileId: timings.profileId,
+                kind: 'rpc',
+                profileId: timings.profileId
             };
             recordFailure(base, timings.requestStart, error);
         }
@@ -368,6 +388,27 @@ async function* streamProfiled(request, rpc, options = {}) {
         }
     }
 }
+// bare-rpc's own teardown can destroy the duplex streams with the raw
+// transport error before the worker-life-signal's onAbort handler (in
+// `createDuplexSession`) gets to destroy them with the classified one —
+// same race as the plain reply/stream paths above, so route consumption
+// through the same remap.
+function toAsyncGenerator(iterable) {
+    return (async function* () {
+        yield* iterable;
+    })();
+}
+function withLifeSignalDuplex(raw) {
+    const generator = iterateWithLifeSignal(toAsyncGenerator(raw));
+    return {
+        [Symbol.asyncIterator]() {
+            return generator[Symbol.asyncIterator]();
+        },
+        destroy() {
+            raw.destroy();
+        }
+    };
+}
 export async function duplex(request, options) {
     const ctx = await prepareRPCContext(request.type, options?.profiling);
     if (!ctx.profilingEnabled) {
@@ -377,7 +418,7 @@ export async function duplex(request, options) {
 }
 async function duplexBase(request, signalDisable, timeout) {
     const parsedRequest = parseRequest(request);
-    logger.debug("RPC Client duplex:", summarizeRequest(request));
+    logger.debug('RPC Client duplex:', summarizeRequest(request));
     const payloadObj = signalDisable
         ? injectProfilingMetaIntoObject(parsedRequest, createProfilingDisabledMeta())
         : parsedRequest;
@@ -386,7 +427,7 @@ async function duplexBase(request, signalDisable, timeout) {
     const session = await withTimeout(sessionPromise, timeout);
     return {
         requestStream: session.requestStream,
-        responseStream: session.responseStream,
+        responseStream: withLifeSignalDuplex(session.responseStream)
     };
 }
 async function duplexProfiled(request, options = {}) {
@@ -399,7 +440,7 @@ async function duplexProfiled(request, options = {}) {
         const zodStart = nowMs();
         const parsedRequest = parseRequest(request);
         timings.requestZodValidationMs = nowMs() - zodStart;
-        logger.debug("RPC Client duplex:", summarizeRequest(request));
+        logger.debug('RPC Client duplex:', summarizeRequest(request));
         const requestMeta = createProfilingMeta(profileId, includeServer);
         const requestWithMeta = injectProfilingMetaIntoObject(parsedRequest, requestMeta);
         const stringifyStart = nowMs();
@@ -413,16 +454,16 @@ async function duplexProfiled(request, options = {}) {
         const base = {
             ts: nowMs(),
             op: timings.requestType,
-            kind: "rpc",
-            profileId: timings.profileId,
+            kind: 'rpc',
+            profileId: timings.profileId
         };
         recordFailure(base, timings.requestStart, error);
         throw error;
     }
     let profilingMeta = undefined;
-    const rawReadable = session.responseStream;
+    const rawReadable = withLifeSignalDuplex(session.responseStream);
     async function* profiledResponseStream() {
-        let lineBuffer = "";
+        let lineBuffer = '';
         try {
             for await (const chunk of rawReadable) {
                 const chunkTime = nowMs();
@@ -431,8 +472,8 @@ async function duplexProfiled(request, options = {}) {
                 }
                 timings.lastChunkAt = chunkTime;
                 lineBuffer += chunk.toString();
-                const lines = lineBuffer.split("\n");
-                lineBuffer = lines.pop() || "";
+                const lines = lineBuffer.split('\n');
+                lineBuffer = lines.pop() || '';
                 const outputParts = [];
                 for (const line of lines) {
                     if (!line.trim())
@@ -458,12 +499,12 @@ async function duplexProfiled(request, options = {}) {
                 if (outputParts.length > 0) {
                     timings.chunkCount += outputParts.length;
                     // Yield strings (not Buffer) — RN/Hermes has no global `Buffer`; consumers call `.toString()` either way.
-                    yield outputParts.join("\n") + "\n";
+                    yield outputParts.join('\n') + '\n';
                 }
             }
             if (lineBuffer.trim()) {
                 timings.chunkCount++;
-                yield lineBuffer + "\n";
+                yield lineBuffer + '\n';
             }
         }
         catch (error) {
@@ -471,8 +512,8 @@ async function duplexProfiled(request, options = {}) {
                 const base = {
                     ts: nowMs(),
                     op: timings.requestType,
-                    kind: "rpc",
-                    profileId: timings.profileId,
+                    kind: 'rpc',
+                    profileId: timings.profileId
                 };
                 recordFailure(base, timings.requestStart, error);
             }
@@ -492,11 +533,11 @@ async function duplexProfiled(request, options = {}) {
         },
         destroy() {
             rawReadable.destroy();
-        },
+        }
     };
     return {
         requestStream: session.requestStream,
-        responseStream: wrappedResponseStream,
+        responseStream: wrappedResponseStream
     };
 }
 export async function close() {

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

@@ -1,4 +1,4 @@
-import type { ErrorResponse } from "../../schemas/index";
+import type { ErrorResponse } from '../../schemas/index';
 export declare class RPCError extends Error {
     readonly timestamp?: string;
     readonly remoteStack?: string;

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

@@ -1,4 +1,4 @@
-import { ContextOverflowError, RequestIdConflictError, RequestNotFoundError, RequestRejectedByPolicyError, } from "../../utils/errors-server.js";
+import { ContextOverflowError, RequestIdConflictError, RequestNotFoundError, RequestRejectedByPolicyError } from '../../utils/errors-server.js';
 export class RPCError extends Error {
     timestamp;
     remoteStack;
@@ -15,7 +15,7 @@ export class RPCError extends Error {
             this.isQvacError = true;
         }
         else {
-            this.name = "RPCError";
+            this.name = 'RPCError';
             this.isQvacError = false;
         }
         if (errorResponse.timestamp) {
@@ -34,7 +34,7 @@ export class RPCError extends Error {
             stack: this.stack,
             cause: this.cause,
             timestamp: this.timestamp,
-            isQvacError: this.isQvacError,
+            isQvacError: this.isQvacError
         };
     }
 }
@@ -46,10 +46,12 @@ export class RPCError extends Error {
  */
 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;
@@ -57,17 +59,17 @@ function attachRemoteContext(err, response) {
 /** 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;
+    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;
+    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;
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
 /**
  * Map of server-thrown `QvacErrorBase` subclasses that need to survive
@@ -100,17 +102,17 @@ function readOptionalStringField(fields, key) {
  */
 const RECONSTRUCTORS = {
     REQUEST_ID_CONFLICT: (response) => {
-        return new RequestIdConflictError(readStringField(response.typedFields, "requestId", ""), response.cause);
+        return new RequestIdConflictError(readStringField(response.typedFields, 'requestId', ''), response.cause);
     },
     REQUEST_NOT_FOUND: (response) => {
-        return new RequestNotFoundError(readStringField(response.typedFields, "requestId", ""), response.cause);
+        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);
+        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);
-    },
+        return new ContextOverflowError(readOptionalNumberField(response.typedFields, 'promptTokens'), readOptionalNumberField(response.typedFields, 'ctxSize'), readOptionalStringField(response.typedFields, 'modelId'), response.cause);
+    }
 };
 /**
  * Rebuild the original server-thrown typed error from its serialised
@@ -121,9 +123,7 @@ const RECONSTRUCTORS = {
  * code-based predicates.
  */
 export function reconstructError(response) {
-    const reconstructor = response.name
-        ? RECONSTRUCTORS[response.name]
-        : undefined;
+    const reconstructor = response.name ? RECONSTRUCTORS[response.name] : undefined;
     if (!reconstructor) {
         return new RPCError(response);
     }

package/dist/commands/bundle/bare-pack.d.ts

@@ -1,4 +1,4 @@
-import type { Logger } from "../../logging/types";
+import type { Logger } from '../../logging/types';
 interface RunBarePackOptions {
     entryPath: string;
     outputPath: string;

package/dist/commands/bundle/bare-pack.js

@@ -1,47 +1,47 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createRequire } from "node:module";
-import { spawn } from "node:child_process";
-import { platform, execPath } from "node:process";
-import { BarePackNotInstalledError, BarePackError, } from "../../utils/errors-client.js";
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { spawn } from 'node:child_process';
+import { platform, execPath } from 'node:process';
+import { BarePackNotInstalledError, BarePackError } from '../../utils/errors-client.js';
 const require = createRequire(import.meta.url);
 function resolveBarePackBin() {
     try {
-        const barePackPkgPath = require.resolve("bare-pack/package");
+        const barePackPkgPath = require.resolve('bare-pack/package');
         const barePackDir = path.dirname(barePackPkgPath);
-        return path.join(barePackDir, "bin.js");
+        return path.join(barePackDir, 'bin.js');
     }
     catch {
         return null;
     }
 }
 export async function runBarePack(options) {
-    const { entryPath, outputPath, hosts, importsMapPath, deferModules, quiet, logger, } = options;
+    const { entryPath, outputPath, hosts, importsMapPath, deferModules, quiet, logger } = options;
     const barePackBin = resolveBarePackBin();
     if (!barePackBin || !fs.existsSync(barePackBin)) {
         throw new BarePackNotInstalledError();
     }
     return new Promise((resolve, reject) => {
-        const hostArgs = hosts.flatMap((h) => ["--host", h]);
-        const deferArgs = deferModules.flatMap((m) => ["--defer", m]);
+        const hostArgs = hosts.flatMap((h) => ['--host', h]);
+        const deferArgs = deferModules.flatMap((m) => ['--defer', m]);
         const args = [
             ...hostArgs,
-            "--linked",
-            "--imports",
+            '--linked',
+            '--imports',
             importsMapPath,
             ...deferArgs,
-            "--out",
+            '--out',
             outputPath,
-            entryPath,
+            entryPath
         ];
-        const isWindows = platform === "win32";
+        const isWindows = platform === 'win32';
         const command = isWindows ? execPath : barePackBin;
         const spawnArgs = isWindows ? [barePackBin, ...args] : args;
-        logger.debug(`\n📦 Running: ${command} ${spawnArgs.join(" ")}`);
+        logger.debug(`\n📦 Running: ${command} ${spawnArgs.join(' ')}`);
         const proc = spawn(command, spawnArgs, {
-            stdio: quiet ? "ignore" : "inherit",
+            stdio: quiet ? 'ignore' : 'inherit'
         });
-        proc.on("close", (code) => {
+        proc.on('close', (code) => {
             if (code === 0) {
                 resolve();
             }
@@ -49,6 +49,6 @@ export async function runBarePack(options) {
                 reject(new BarePackError(code ?? 1, entryPath, outputPath));
             }
         });
-        proc.on("error", reject);
+        proc.on('error', reject);
     });
 }

package/dist/commands/bundle/constants.js

@@ -1,26 +1,26 @@
 export const BUILTIN_PLUGINS = {
-    "llamacpp-completion": { exportName: "llmPlugin" },
-    "llamacpp-embedding": { exportName: "embeddingsPlugin" },
-    "whispercpp-transcription": { exportName: "whisperPlugin" },
-    "bci-whispercpp-transcription": { exportName: "bciPlugin" },
-    "parakeet-transcription": { exportName: "parakeetPlugin" },
-    "nmtcpp-translation": { exportName: "nmtPlugin" },
-    "tts-ggml": { exportName: "ttsPlugin" },
-    "ggml-ocr": { exportName: "ocrPlugin" },
-    "sdcpp-generation": { exportName: "diffusionPlugin" },
-    "ggml-vla": { exportName: "vlaPlugin" },
-    "ggml-classification": { exportName: "classificationPlugin" },
+    'llamacpp-completion': { exportName: 'llmPlugin' },
+    'llamacpp-embedding': { exportName: 'embeddingsPlugin' },
+    'whispercpp-transcription': { exportName: 'whisperPlugin' },
+    'bci-whispercpp-transcription': { exportName: 'bciPlugin' },
+    'parakeet-transcription': { exportName: 'parakeetPlugin' },
+    'nmtcpp-translation': { exportName: 'nmtPlugin' },
+    'tts-ggml': { exportName: 'ttsPlugin' },
+    'ggml-ocr': { exportName: 'ocrPlugin' },
+    'sdcpp-generation': { exportName: 'diffusionPlugin' },
+    'ggml-vla': { exportName: 'vlaPlugin' },
+    'ggml-classification': { exportName: 'classificationPlugin' }
 };
 export const BUILTIN_SUFFIXES = Object.keys(BUILTIN_PLUGINS);
 export const DEFAULT_HOSTS = [
-    "darwin-arm64",
-    "darwin-x64",
-    "linux-arm64",
-    "linux-x64",
-    "win32-x64",
-    "android-arm64",
-    "ios-arm64",
-    "ios-arm64-simulator",
-    "ios-x64-simulator",
+    'darwin-arm64',
+    'darwin-x64',
+    'linux-arm64',
+    'linux-x64',
+    'win32-x64',
+    'android-arm64',
+    'ios-arm64',
+    'ios-arm64-simulator',
+    'ios-x64-simulator'
 ];
-export const DEFAULT_SDK_NAME = "@qvac/sdk";
+export const DEFAULT_SDK_NAME = '@qvac/sdk';