@qvac/sdk 0.14.1 → 0.15.0

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

@@ -1,16 +1,16 @@
-import RPC from "bare-rpc";
-import spawn, {} from "bare-runtime/spawn";
-import { randomBytes } from "node:crypto";
-import { existsSync, unlinkSync } from "node:fs";
-import { createServer } from "node:net";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { initializeConfig } from "../init-hooks.js";
-import { resolveConfig } from "../config-loader/resolve-config.node.js";
-import { getClientLogger, getLogger, SDK_SERVER_NAMESPACE } from "../../logging/index.js";
-import { BareRuntimeBinaryNotFoundError, RPCInitTimeoutError, WorkerCrashedError, WorkerShutdownError, } from "../../utils/errors-client.js";
+import RPC from 'bare-rpc';
+import spawn, {} from 'bare-runtime/spawn';
+import { randomBytes } from 'node:crypto';
+import { existsSync, unlinkSync } from 'node:fs';
+import { createServer } from 'node:net';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { initializeConfig } from '../init-hooks.js';
+import { resolveConfig } from '../config-loader/resolve-config.node.js';
+import { getClientLogger, getLogger, SDK_SERVER_NAMESPACE } from '../../logging/index.js';
+import { BareRuntimeBinaryNotFoundError, RPCInitTimeoutError, WorkerCrashedError, WorkerShutdownError } from '../../utils/errors-client.js';
 const RPC_INIT_TIMEOUT_MS = 30_000;
 const WORKER_STDERR_TAIL_CHARS = 16_384;
 const logger = getClientLogger();
@@ -36,7 +36,7 @@ function findProjectRootSync() {
     let dir = process.cwd();
     const root = path.parse(dir).root;
     while (dir !== root) {
-        if (fs.existsSync(path.join(dir, "package.json"))) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
             return dir;
         }
         dir = path.dirname(dir);
@@ -45,16 +45,16 @@ function findProjectRootSync() {
 }
 function getResourcesPathSync() {
     const { resourcesPath } = process;
-    return typeof resourcesPath === "string" ? resourcesPath : undefined;
+    return typeof resourcesPath === 'string' ? resourcesPath : undefined;
 }
 function resolvePackagedWorkerPath() {
     const resourcesPath = getResourcesPathSync();
     if (!resourcesPath)
         return undefined;
     const candidates = [
-        path.join(resourcesPath, "app.asar.unpacked", "qvac", "worker.entry.mjs"),
-        path.join(resourcesPath, "app", "qvac", "worker.entry.mjs"),
-        path.join(resourcesPath, "qvac", "worker.entry.mjs"),
+        path.join(resourcesPath, 'app.asar.unpacked', 'qvac', 'worker.entry.mjs'),
+        path.join(resourcesPath, 'app', 'qvac', 'worker.entry.mjs'),
+        path.join(resourcesPath, 'qvac', 'worker.entry.mjs')
     ];
     for (const candidate of candidates) {
         if (fs.existsSync(candidate))
@@ -72,17 +72,17 @@ function resolvePackagedWorkerPath() {
  * literals at the call site.
  */
 function getDefaultWorkerPath() {
-    const hasAsset = typeof import.meta.asset === "function";
+    const hasAsset = typeof import.meta.asset === 'function';
     const packagedUrl = hasAsset
-        ? new URL(import.meta.asset("../../server/worker.js"))
-        : new URL("../../server/worker.js", import.meta.url);
+        ? new URL(import.meta.asset('../../server/worker.js'))
+        : new URL('../../server/worker.js', import.meta.url);
     const packaged = fileURLToPath(packagedUrl);
     if (fs.existsSync(packaged))
         return packaged;
     // Dev/source layout fallback
     const devUrl = hasAsset
-        ? new URL(import.meta.asset("../../dist/server/worker.js"))
-        : new URL("../../dist/server/worker.js", import.meta.url);
+        ? new URL(import.meta.asset('../../dist/server/worker.js'))
+        : new URL('../../dist/server/worker.js', import.meta.url);
     return fileURLToPath(devUrl);
 }
 /**
@@ -93,7 +93,7 @@ function getDefaultWorkerPath() {
  * 4. Default SDK worker
  */
 function resolveWorkerPath() {
-    const envWorkerPath = process.env["QVAC_WORKER_PATH"];
+    const envWorkerPath = process.env['QVAC_WORKER_PATH'];
     if (envWorkerPath) {
         const normalized = path.resolve(envWorkerPath);
         if (fs.existsSync(normalized)) {
@@ -115,7 +115,7 @@ function resolveWorkerPath() {
     // load ES modules directly. The packed bundle is for mobile only.
     const projectRoot = findProjectRootSync();
     if (projectRoot) {
-        const customEntry = path.join(projectRoot, "qvac", "worker.entry.mjs");
+        const customEntry = path.join(projectRoot, 'qvac', 'worker.entry.mjs');
         if (fs.existsSync(customEntry)) {
             logger.info(`🔧 Using custom worker entry: ${customEntry}`);
             return customEntry;
@@ -129,15 +129,15 @@ function resolveWorkerPath() {
 const WORKER_PATH = resolveWorkerPath();
 function createSocketPath() {
     const timestamp = Date.now().toString(36);
-    const randomSuffix = randomBytes(2).toString("hex");
+    const randomSuffix = randomBytes(2).toString('hex');
     const socketName = `qvac-worker-${process.pid}-${timestamp}-${randomSuffix}`;
-    return process.platform === "win32"
+    return process.platform === 'win32'
         ? `\\\\.\\pipe\\${socketName}`
         : path.join(os.tmpdir(), `${socketName}.sock`);
 }
 function bestEffortUnlinkSocket(socketPath) {
     // Windows named pipes are not filesystem paths, so unlink is Unix-only.
-    if (!socketPath || process.platform === "win32")
+    if (!socketPath || process.platform === 'win32')
         return;
     try {
         if (existsSync(socketPath)) {
@@ -145,7 +145,7 @@ function bestEffortUnlinkSocket(socketPath) {
         }
     }
     catch (error) {
-        logger.debug("Failed to unlink IPC socket path", { socketPath, error });
+        logger.debug('Failed to unlink IPC socket path', { socketPath, error });
     }
 }
 function appendWorkerStderrTail(current, chunk) {
@@ -182,10 +182,10 @@ function teardownFailedInit() {
     const { workerToClose, serverToClose, socketPathToClose } = snapshotAndResetState();
     if (workerToClose) {
         try {
-            workerToClose.kill("SIGTERM");
+            workerToClose.kill('SIGTERM');
         }
         catch (error) {
-            logger.debug("Failed to kill bare worker after init failure", { error });
+            logger.debug('Failed to kill bare worker after init failure', { error });
         }
     }
     if (serverToClose) {
@@ -193,7 +193,7 @@ function teardownFailedInit() {
             serverToClose.close();
         }
         catch (error) {
-            logger.debug("Failed to close IPC server after init failure", { error });
+            logger.debug('Failed to close IPC server after init failure', { error });
         }
     }
     bestEffortUnlinkSocket(socketPathToClose);
@@ -201,6 +201,36 @@ function teardownFailedInit() {
 export function getWorkerLifeSignal() {
     return workerLifeController?.signal ?? null;
 }
+// Called by the RPC layer when it detects the channel closed out from under
+// an in-flight call (bare-rpc's own teardown beat the child `'exit'` event
+// we normally rely on). Tears down immediately rather than waiting on that
+// slower signal, so the next call respawns instead of reusing the dead
+// connection. A no-op if the life signal already aborted — e.g. the real
+// exit handler got there first, or a concurrent caller already tore down.
+export function notifyChannelClosed() {
+    const controller = workerLifeController;
+    if (!controller || controller.signal.aborted)
+        return;
+    const { workerToClose, serverToClose, socketPathToClose } = snapshotAndResetState();
+    if (workerToClose) {
+        try {
+            workerToClose.kill('SIGTERM');
+        }
+        catch (error) {
+            logger.debug('Failed to kill bare worker after channel close', { error });
+        }
+    }
+    if (serverToClose) {
+        try {
+            serverToClose.close();
+        }
+        catch (error) {
+            logger.debug('Failed to close IPC server after channel close', { error });
+        }
+    }
+    bestEffortUnlinkSocket(socketPathToClose);
+    controller.abort(new WorkerCrashedError(null, null));
+}
 function getWorkerStderr(proc) {
     return proc.stderr ?? null;
 }
@@ -233,7 +263,7 @@ function handlePostHandshakeExit(code, exitSignal, spawn) {
         spawn.server.close();
     }
     catch (err) {
-        logger.debug("Failed to close IPC server after worker crash", { err });
+        logger.debug('Failed to close IPC server after worker crash', { err });
     }
     spawn.controller.abort(new WorkerCrashedError(code, exitSignal));
     bestEffortUnlinkSocket(spawn.socketPath);
@@ -244,10 +274,10 @@ function closeSyncForExit() {
     const { workerToClose, serverToClose, socketPathToClose } = snapshotAndResetState();
     if (workerToClose) {
         try {
-            workerToClose.kill("SIGTERM");
+            workerToClose.kill('SIGTERM');
         }
         catch (error) {
-            logger.debug("Failed to kill bare worker during process exit", { error });
+            logger.debug('Failed to kill bare worker during process exit', { error });
         }
     }
     if (serverToClose) {
@@ -255,7 +285,7 @@ function closeSyncForExit() {
             serverToClose.close();
         }
         catch (error) {
-            logger.debug("Failed to close IPC server during process exit", { error });
+            logger.debug('Failed to close IPC server during process exit', { error });
         }
     }
     bestEffortUnlinkSocket(socketPathToClose);
@@ -275,13 +305,13 @@ async function ensureRPC() {
     workerLifeController = spawnController;
     rpcPromise = new Promise((resolve, reject) => {
         let settled = false;
-        let workerStderrTail = "";
+        let workerStderrTail = '';
         const timer = setTimeout(() => {
             if (settled)
                 return;
             settled = true;
             const cause = workerStderrTail
-                ? createWorkerStartupError("Worker did not establish IPC before the RPC initialization timeout", workerStderrTail)
+                ? createWorkerStartupError('Worker did not establish IPC before the RPC initialization timeout', workerStderrTail)
                 : undefined;
             teardownFailedInit();
             reject(new RPCInitTimeoutError(RPC_INIT_TIMEOUT_MS, cause));
@@ -294,7 +324,7 @@ async function ensureRPC() {
             rpcInstance = new RPC(socket, () => { });
             resolve(rpcInstance);
         });
-        ipcServer.on("error", (error) => {
+        ipcServer.on('error', (error) => {
             if (settled)
                 return;
             settled = true;
@@ -306,23 +336,23 @@ async function ensureRPC() {
             const spawnResources = {
                 controller: spawnController,
                 server: ipcServer,
-                socketPath,
+                socketPath
             };
             try {
-                bareWorkerProc = spawn("bare", {
+                bareWorkerProc = spawn('bare', {
                     args: [
                         WORKER_PATH,
                         JSON.stringify({
                             QVAC_IPC_SOCKET_PATH: socketPath,
                             // Snap's HOME can be revision-scoped; SNAP_USER_COMMON is stable.
-                            HOME_DIR: process.env["SNAP_USER_COMMON"]
-                                ? String(process.env["SNAP_USER_COMMON"])
-                                : os.homedir(),
-                        }),
+                            HOME_DIR: process.env['SNAP_USER_COMMON']
+                                ? String(process.env['SNAP_USER_COMMON'])
+                                : os.homedir()
+                        })
                     ],
                     platform: process.platform,
                     arch: process.arch,
-                    stdio: ["inherit", "inherit", "pipe"],
+                    stdio: ['inherit', 'inherit', 'pipe']
                 });
             }
             catch (error) {
@@ -339,15 +369,15 @@ async function ensureRPC() {
                 return;
             }
             if (bareWorkerProc) {
-                getWorkerStderr(bareWorkerProc)?.on("data", (chunk) => {
+                getWorkerStderr(bareWorkerProc)?.on('data', (chunk) => {
                     const text = chunk.toString();
                     workerStderrTail = appendWorkerStderrTail(workerStderrTail, text);
-                    for (const line of text.split("\n")) {
+                    for (const line of text.split('\n')) {
                         if (line.trim())
                             workerLogger.debug(line);
                     }
                 });
-                bareWorkerProc.on("exit", (code, exitSignal) => {
+                bareWorkerProc.on('exit', (code, exitSignal) => {
                     if (settled) {
                         handlePostHandshakeExit(code, exitSignal, spawnResources);
                         return;
@@ -355,11 +385,11 @@ async function ensureRPC() {
                     // Pre-handshake failures are rejected from "close" so stderr has
                     // drained before we assemble the startup error cause.
                 });
-                bareWorkerProc.on("close", (...args) => {
+                bareWorkerProc.on('close', (...args) => {
                     if (settled)
                         return;
-                    const code = typeof args[0] === "number" ? args[0] : null;
-                    const exitSignal = typeof args[1] === "string" ? args[1] : null;
+                    const code = typeof args[0] === 'number' ? args[0] : null;
+                    const exitSignal = typeof args[1] === 'string' ? args[1] : null;
                     // Worker died before handshake. Use close, not exit, so piped
                     // stderr has drained before we build the error cause.
                     settled = true;
@@ -372,26 +402,24 @@ async function ensureRPC() {
     });
     const rpc = await rpcPromise;
     const runtimeContext = {
-        runtime: "node",
-        platform: process.platform,
+        runtime: 'node',
+        platform: process.platform
     };
     // init-hooks calls bare-rpc directly, bypassing rpc-client's race.
     await Promise.race([
         initializeConfig(rpc, resolveConfig, runtimeContext),
-        rejectOnAbort(spawnController.signal),
+        rejectOnAbort(spawnController.signal)
     ]);
     return rpc;
 }
 function rejectOnAbort(signal) {
     return new Promise((_, reject) => {
-        const fail = () => reject(signal.reason instanceof Error
-            ? signal.reason
-            : new WorkerCrashedError(null, null));
+        const fail = () => reject(signal.reason instanceof Error ? signal.reason : new WorkerCrashedError(null, null));
         if (signal.aborted) {
             fail();
             return;
         }
-        signal.addEventListener("abort", fail, { once: true });
+        signal.addEventListener('abort', fail, { once: true });
     });
 }
 export async function getRPC() {
@@ -401,25 +429,25 @@ export async function createDuplexSession(payload, commandId) {
     const rpc = await ensureRPC();
     const req = rpc.request(commandId);
     const requestStream = req.createRequestStream();
-    const responseStream = req.createResponseStream({ encoding: "utf-8" });
-    requestStream.write(payload, "utf-8");
+    const responseStream = req.createResponseStream({ encoding: 'utf-8' });
+    requestStream.write(payload, 'utf-8');
     // Destroy on worker death so consumers' for-await throws instead of hangs.
     const lifeSignal = workerLifeController?.signal;
     if (lifeSignal && !lifeSignal.aborted) {
         const onAbort = () => {
-            const err = lifeSignal.reason instanceof Error
-                ? lifeSignal.reason
-                : new WorkerCrashedError(null, null);
+            const err = lifeSignal.reason instanceof Error ? lifeSignal.reason : new WorkerCrashedError(null, null);
             try {
+                ;
                 requestStream.destroy?.(err);
             }
             catch { }
             try {
+                ;
                 responseStream.destroy?.(err);
             }
             catch { }
         };
-        lifeSignal.addEventListener("abort", onAbort, { once: true });
+        lifeSignal.addEventListener('abort', onAbort, { once: true });
     }
     return { requestStream, responseStream };
 }
@@ -430,29 +458,29 @@ export async function close() {
     }
     if (!rpcInstance && !rpcPromise && !bareWorkerProc && !ipcServer)
         return;
-    logger.info("🧹 Closing RPC client");
+    logger.info('🧹 Closing RPC client');
     // Abort before kill: exit handler sees planned intent; any in-flight
     // caller (contract violators) rejects with WorkerShutdownError.
     workerLifeController?.abort(new WorkerShutdownError());
     const { workerToClose, serverToClose, socketPathToClose } = snapshotAndResetState();
     closePromise = (async () => {
         if (workerToClose) {
-            logger.info("🐻🔫 Killing bare worker process");
+            logger.info('🐻🔫 Killing bare worker process');
             try {
-                workerToClose.kill("SIGTERM");
+                workerToClose.kill('SIGTERM');
             }
             catch (error) {
-                logger.debug("Failed to kill bare worker process", { error });
+                logger.debug('Failed to kill bare worker process', { error });
             }
         }
         if (serverToClose) {
-            logger.info("🔌 Closing IPC server");
+            logger.info('🔌 Closing IPC server');
             await new Promise((resolve) => {
                 try {
                     serverToClose.close(() => resolve());
                 }
                 catch (error) {
-                    logger.debug("Failed to close IPC server", { error });
+                    logger.debug('Failed to close IPC server', { error });
                     resolve();
                 }
             });
@@ -471,7 +499,7 @@ function handleTerminationSignal(signal) {
     closeSyncForExit();
     process.kill(process.pid, signal);
 }
-process.once("SIGINT", () => handleTerminationSignal("SIGINT"));
-process.once("SIGTERM", () => handleTerminationSignal("SIGTERM"));
-process.once("SIGHUP", () => handleTerminationSignal("SIGHUP"));
-process.once("exit", closeSyncForExit);
+process.once('SIGINT', () => handleTerminationSignal('SIGINT'));
+process.once('SIGTERM', () => handleTerminationSignal('SIGTERM'));
+process.once('SIGHUP', () => handleTerminationSignal('SIGHUP'));
+process.once('exit', closeSyncForExit);

package/dist/client/rpc/profiling/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./profiler";
+export * from './profiler';
 //# sourceMappingURL=index.d.ts.map

package/dist/client/rpc/profiling/index.js

@@ -1 +1 @@
-export * from "./profiler.js";
+export * from './profiler.js';

package/dist/client/rpc/profiling/profiler.d.ts

@@ -1,5 +1,5 @@
-import { type BaseTimings } from "../../../profiling/index";
-import type { ProfilingResponseMeta } from "../../../schemas/index";
+import { type BaseTimings } from '../../../profiling/index';
+import type { ProfilingResponseMeta } from '../../../schemas/index';
 interface BaseClientTimings extends BaseTimings {
     requestZodValidationMs?: number;
     requestStringifyMs?: number;

package/dist/client/rpc/profiling/profiler.js

@@ -1,20 +1,19 @@
-import { nowMs, record, recordPhase, recordServerBreakdownPhases, recordDelegationBreakdownPhases, } from "../../../profiling/index.js";
-import { getGlobalSingleton } from "../../../utils/global-singleton.js";
-const CONNECTION_TRACKING_STATE_KEY = Symbol.for("@qvac/sdk:rpc-connection-tracking-state");
+import { nowMs, record, recordPhase, recordServerBreakdownPhases, recordDelegationBreakdownPhases } from '../../../profiling/index.js';
+import { getGlobalSingleton } from '../../../utils/global-singleton.js';
+const CONNECTION_TRACKING_STATE_KEY = Symbol.for('@qvac/sdk:rpc-connection-tracking-state');
 function getConnectionTrackingState() {
     return getGlobalSingleton(CONNECTION_TRACKING_STATE_KEY, () => {
         return {
             connectionTimeRecorded: false,
-            pendingConnectionTimeMs: undefined,
+            pendingConnectionTimeMs: undefined
         };
     });
 }
 function recordRequestPhases(base, timings) {
-    recordPhase(base, "request.zodValidation", timings.requestZodValidationMs);
-    recordPhase(base, "request.stringify", timings.requestStringifyMs);
-    if (timings.requestZodValidationMs !== undefined &&
-        timings.requestStringifyMs !== undefined) {
-        recordPhase(base, "request.totalSerialization", timings.requestZodValidationMs + timings.requestStringifyMs);
+    recordPhase(base, 'request.zodValidation', timings.requestZodValidationMs);
+    recordPhase(base, 'request.stringify', timings.requestStringifyMs);
+    if (timings.requestZodValidationMs !== undefined && timings.requestStringifyMs !== undefined) {
+        recordPhase(base, 'request.totalSerialization', timings.requestZodValidationMs + timings.requestStringifyMs);
     }
 }
 function createBaseTimings(profileId, requestType) {
@@ -45,10 +44,10 @@ export function flushConnectionTime() {
     state.connectionTimeRecorded = true;
     record({
         ts: nowMs(),
-        op: "rpc",
-        kind: "rpc",
-        phase: "connection",
-        ms: durationMs,
+        op: 'rpc',
+        kind: 'rpc',
+        phase: 'connection',
+        ms: durationMs
     });
 }
 export function recordClientEvents(timings, serverMeta) {
@@ -57,26 +56,24 @@ export function recordClientEvents(timings, serverMeta) {
     const base = {
         ts: now,
         op: timings.requestType,
-        kind: "rpc",
-        profileId: timings.profileId,
+        kind: 'rpc',
+        profileId: timings.profileId
     };
     recordRequestPhases(base, timings);
     // For unary requests, this measures send → full response received
-    if (timings.sendStart !== undefined &&
-        timings.firstResponseAt !== undefined) {
-        recordPhase(base, "serverWait", timings.firstResponseAt - timings.sendStart);
+    if (timings.sendStart !== undefined && timings.firstResponseAt !== undefined) {
+        recordPhase(base, 'serverWait', timings.firstResponseAt - timings.sendStart);
     }
-    recordPhase(base, "response.jsonParse", timings.responseJsonParseMs);
-    recordPhase(base, "response.zodValidation", timings.responseZodValidationMs);
-    if (timings.responseJsonParseMs !== undefined &&
-        timings.responseZodValidationMs !== undefined) {
-        recordPhase(base, "response.totalParsing", timings.responseJsonParseMs + timings.responseZodValidationMs);
+    recordPhase(base, 'response.jsonParse', timings.responseJsonParseMs);
+    recordPhase(base, 'response.zodValidation', timings.responseZodValidationMs);
+    if (timings.responseJsonParseMs !== undefined && timings.responseZodValidationMs !== undefined) {
+        recordPhase(base, 'response.totalParsing', timings.responseJsonParseMs + timings.responseZodValidationMs);
     }
-    recordPhase(base, "totalClientTime", totalClientTime);
+    recordPhase(base, 'totalClientTime', totalClientTime);
     if (serverMeta?.server) {
-        recordServerBreakdownPhases(base, serverMeta.server, "server");
+        recordServerBreakdownPhases(base, serverMeta.server, 'server');
         if (serverMeta.server.totalServerMs !== undefined) {
-            recordPhase(base, "clientOverhead", Math.max(0, totalClientTime - serverMeta.server.totalServerMs));
+            recordPhase(base, 'clientOverhead', Math.max(0, totalClientTime - serverMeta.server.totalServerMs));
         }
     }
     if (serverMeta?.delegation) {
@@ -91,7 +88,7 @@ function recordOperationEvent(op) {
         ts: nowMs(),
         op: op.op,
         kind: op.kind,
-        ms: op.ms,
+        ms: op.ms
     };
     if (op.profileId !== undefined)
         event.profileId = op.profileId;
@@ -109,21 +106,21 @@ export function recordClientStreamEvents(timings, serverMeta) {
     const base = {
         ts: now,
         op: timings.requestType,
-        kind: "rpc",
-        profileId: timings.profileId,
+        kind: 'rpc',
+        profileId: timings.profileId
     };
     recordRequestPhases(base, timings);
     if (timings.sendStart !== undefined && timings.firstChunkAt !== undefined) {
-        recordPhase(base, "ttfb", timings.firstChunkAt - timings.sendStart);
+        recordPhase(base, 'ttfb', timings.firstChunkAt - timings.sendStart);
     }
     if (timings.firstChunkAt !== undefined && timings.lastChunkAt !== undefined) {
-        recordPhase(base, "streamDuration", timings.lastChunkAt - timings.firstChunkAt);
+        recordPhase(base, 'streamDuration', timings.lastChunkAt - timings.firstChunkAt);
     }
-    recordPhase(base, "totalClientTime", totalClientTime, {
-        count: timings.chunkCount,
+    recordPhase(base, 'totalClientTime', totalClientTime, {
+        count: timings.chunkCount
     });
     if (serverMeta?.server) {
-        recordServerBreakdownPhases(base, serverMeta.server, "server");
+        recordServerBreakdownPhases(base, serverMeta.server, 'server');
     }
     if (serverMeta?.delegation) {
         recordDelegationBreakdownPhases(base, serverMeta.delegation);

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

@@ -1,5 +1,5 @@
-import type RPC from "bare-rpc";
-import { type Request, type Response, type RPCOptions } from "../../schemas/index";
+import type RPC from 'bare-rpc';
+import { type Request, type Response, type RPCOptions } from '../../schemas/index';
 export declare function send<T extends Request>(request: T, options?: RPCOptions, rpc?: RPC): Promise<Response>;
 export declare function stream<T extends Request>(request: T, options?: RPCOptions, rpc?: RPC): AsyncGenerator<Response>;
 export interface DuplexWritable {