@qvac/sdk 0.18.2 → 0.19.0

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

@@ -0,0 +1,525 @@
+import RPC from 'bare-rpc';
+import spawn, {} from 'bare-runtime/spawn';
+import { randomBytes } from 'node:crypto';
+import fs, { existsSync, unlinkSync } from 'node:fs';
+import { createServer } from 'node:net';
+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 { createRPCInitTimeoutCause } from './worker-startup-error.js';
+import { RPC_INIT_TIMEOUT_ENV_VAR, resolveRPCInitTimeoutMs } from './init-timeout.js';
+const WORKER_STDERR_TAIL_CHARS = 16_384;
+const logger = getClientLogger();
+// Addons route real logs through their JS callback; anything written straight to the
+// worker's stderr is treated as debug.
+const workerLogger = getLogger(SDK_SERVER_NAMESPACE, { enableConsole: false });
+let rpcInstance = null;
+let rpcPromise = null;
+let bareWorkerProc = null;
+let ipcServer = null;
+let currentSocketPath = null;
+let closePromise = null;
+// Aborted when the worker dies (crash) or close() runs (planned). Used
+// to unblock in-flight `req.reply()` callers — bare-rpc's `_onerror`
+// does not iterate `_outgoingRequests`, so without this signal they
+// would hang on the dead socket.
+let workerLifeController = null;
+/**
+ * Find project root by looking for package.json (sync version)
+ * Safe to call at module load time
+ */
+function findProjectRootSync() {
+    let dir = process.cwd();
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            return dir;
+        }
+        dir = path.dirname(dir);
+    }
+    return undefined;
+}
+function getResourcesPathSync() {
+    const { resourcesPath } = process;
+    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')
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+/**
+ * Resolve the SDK's default worker entry via bundler-visible asset references.
+ *
+ * The worker is transpiled with its `@/` aliases resolved into
+ * `dist/src/worker/index.js`; Bare cannot run the `@/`-laden source. This file
+ * compiles to `dist/src/client/rpc/node-rpc-client.js`, so the built worker sits
+ * at `../../worker/index.js` for both the dev and packaged layouts.
+ *
+ * `path.resolve(__dirname, ...)` is invisible to static analysis, so packaged
+ * consumers ship without the worker. We use `import.meta.asset(<literal>)` on
+ * Bare (detected by bare-module-lexer) and fall back to
+ * `new URL(<literal>, import.meta.url)` elsewhere. The spec must be a string
+ * literal at the call site.
+ */
+function getDefaultWorkerPath() {
+    const hasAsset = typeof import.meta.asset === 'function';
+    const workerUrl = hasAsset
+        ? new URL(import.meta.asset('../../worker/index.js'))
+        : new URL('../../worker/index.js', import.meta.url);
+    return fileURLToPath(workerUrl);
+}
+/**
+ * Resolve worker path with priority:
+ * 1. QVAC_WORKER_PATH environment variable
+ * 2. Packaged Electron app worker entry
+ * 3. qvac/worker.entry.mjs in project root (generated by npx qvac bundle sdk)
+ * 4. Default SDK worker
+ */
+function resolveWorkerPath() {
+    const envWorkerPath = process.env['QVAC_WORKER_PATH'];
+    if (envWorkerPath) {
+        const normalized = path.resolve(envWorkerPath);
+        if (fs.existsSync(normalized)) {
+            logger.info(`🔧 Using worker entry from QVAC_WORKER_PATH: ${normalized}`);
+            return normalized;
+        }
+        logger.warn(`⚠️ QVAC_WORKER_PATH was set but file was not found: ${normalized}. Falling back.`);
+    }
+    // Prefer packaged worker entry when running as a packaged Electron app.
+    // This avoids accidental coupling to the project's cwd, and ensures the
+    // bare worker reads JS modules from the filesystem (not app.asar).
+    const packagedWorker = resolvePackagedWorkerPath();
+    if (packagedWorker) {
+        logger.info(`🔧 Using packaged worker entry: ${packagedWorker}`);
+        return packagedWorker;
+    }
+    // Check for custom worker entry at project root
+    // Note: We use worker.entry.mjs (unbundled ESM) for desktop because bare can
+    // 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');
+        if (fs.existsSync(customEntry)) {
+            logger.info(`🔧 Using custom worker entry: ${customEntry}`);
+            return customEntry;
+        }
+    }
+    // Fallback to default SDK worker
+    const defaultPath = getDefaultWorkerPath();
+    logger.debug(`🔧 Using default SDK worker: ${defaultPath}`);
+    return defaultPath;
+}
+const WORKER_PATH = resolveWorkerPath();
+function createSocketPath() {
+    const timestamp = Date.now().toString(36);
+    const randomSuffix = randomBytes(2).toString('hex');
+    const socketName = `qvac-worker-${process.pid}-${timestamp}-${randomSuffix}`;
+    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')
+        return;
+    try {
+        if (existsSync(socketPath)) {
+            unlinkSync(socketPath);
+        }
+    }
+    catch (error) {
+        logger.debug('Failed to unlink IPC socket path', { socketPath, error });
+    }
+}
+function appendWorkerStderrTail(current, chunk) {
+    const next = current + chunk;
+    if (next.length <= WORKER_STDERR_TAIL_CHARS)
+        return next;
+    return next.slice(next.length - WORKER_STDERR_TAIL_CHARS);
+}
+function resetModuleState() {
+    rpcInstance = null;
+    rpcPromise = null;
+    bareWorkerProc = null;
+    ipcServer = null;
+    currentSocketPath = null;
+    workerLifeController = null;
+}
+function snapshotAndResetState() {
+    const workerToClose = bareWorkerProc;
+    const serverToClose = ipcServer;
+    const socketPathToClose = currentSocketPath;
+    resetModuleState();
+    return { workerToClose, serverToClose, socketPathToClose };
+}
+// Shared cleanup for every init reject path: reset module state, stop the
+// worker + IPC server, and remove the socket so a failed start never leaks
+// resources. Mirrors closeSyncForExit without the planned-shutdown abort.
+function teardownFailedInit() {
+    const { workerToClose, serverToClose, socketPathToClose } = snapshotAndResetState();
+    if (workerToClose) {
+        try {
+            workerToClose.kill('SIGTERM');
+        }
+        catch (error) {
+            logger.debug('Failed to kill bare worker after init failure', { error });
+        }
+    }
+    if (serverToClose) {
+        try {
+            serverToClose.close();
+        }
+        catch (error) {
+            logger.debug('Failed to close IPC server after init failure', { error });
+        }
+    }
+    bestEffortUnlinkSocket(socketPathToClose);
+}
+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;
+}
+// `bare-runtime` resolves its platform binary with
+// `require('bare-runtime-<platform>-<arch>')` and throws a terse
+// `No binaries found for target '<platform>-<arch>'` whenever that package —
+// or one of its nested deps — is absent. Under pnpm that happens even on a
+// supported platform, so surface an actionable error instead of the raw throw.
+function mapBareSpawnError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/No binar(?:y|ies) found for target/i.test(message)) {
+        return new BareRuntimeBinaryNotFoundError(process.platform, process.arch, error);
+    }
+    return error instanceof Error ? error : new Error(message);
+}
+// `spawn` carries this listener's own captured resources. Module-level
+// state may belong to a newer ensureRPC() by the time we fire.
+function handlePostHandshakeExit(code, exitSignal, spawn) {
+    if (spawn.controller.signal.aborted) {
+        // close() already handled teardown.
+        logger.debug(`Bare worker exited after planned shutdown (code=${code}, signal=${exitSignal})`);
+        return;
+    }
+    logger.info(`🪦 Bare worker exited post-handshake (code=${code}, signal=${exitSignal})`);
+    // Only clear module state if we're still the active spawn.
+    if (workerLifeController === spawn.controller) {
+        resetModuleState();
+    }
+    try {
+        spawn.server.close();
+    }
+    catch (err) {
+        logger.debug('Failed to close IPC server after worker crash', { err });
+    }
+    spawn.controller.abort(new WorkerCrashedError(code, exitSignal));
+    bestEffortUnlinkSocket(spawn.socketPath);
+}
+function closeSyncForExit() {
+    // Abort before kill so the exit handler sees planned intent.
+    workerLifeController?.abort(new WorkerShutdownError());
+    const { workerToClose, serverToClose, socketPathToClose } = snapshotAndResetState();
+    if (workerToClose) {
+        try {
+            workerToClose.kill('SIGTERM');
+        }
+        catch (error) {
+            logger.debug('Failed to kill bare worker during process exit', { error });
+        }
+    }
+    if (serverToClose) {
+        try {
+            serverToClose.close();
+        }
+        catch (error) {
+            logger.debug('Failed to close IPC server during process exit', { error });
+        }
+    }
+    bestEffortUnlinkSocket(socketPathToClose);
+}
+/** Distinguishes "config file failed to load" from "no config file present". */
+const CONFIG_UNRESOLVED = Symbol('config-unresolved');
+/**
+ * The handshake timeout has to be known before the worker is spawned, but the
+ * config file is normally read after it (init-hooks). Read it early and hand
+ * the same object to init-hooks so the file is not parsed twice.
+ *
+ * A config that fails to load is swallowed here. init-hooks re-runs the
+ * resolver post-handshake, so the config error surfaces there rather than as a
+ * spawn failure.
+ */
+async function preresolveConfig() {
+    try {
+        return await resolveConfig();
+    }
+    catch (error) {
+        logger.debug('Config preload for the RPC init timeout failed; using the default', { error });
+        return CONFIG_UNRESOLVED;
+    }
+}
+async function ensureRPC() {
+    if (rpcInstance)
+        return rpcInstance;
+    if (rpcPromise)
+        return rpcPromise;
+    if (closePromise) {
+        await closePromise;
+    }
+    const preresolved = await preresolveConfig();
+    const initTimeoutMs = resolveRPCInitTimeoutMs({
+        envValue: process.env[RPC_INIT_TIMEOUT_ENV_VAR],
+        configValue: preresolved === CONFIG_UNRESOLVED ? undefined : (preresolved?.rpcInitTimeoutMs ?? undefined),
+        onInvalidEnvValue: (value) => logger.warn(`Ignoring invalid ${RPC_INIT_TIMEOUT_ENV_VAR}=${value}; expected a positive integer of milliseconds`)
+    });
+    const socketPath = createSocketPath();
+    currentSocketPath = socketPath;
+    // Allocated here so the init race and exit handler share one controller.
+    const spawnController = new AbortController();
+    workerLifeController = spawnController;
+    rpcPromise = new Promise((resolve, reject) => {
+        let settled = false;
+        let workerStderrTail = '';
+        let workerExitBeforeHandshake = null;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            const cause = createRPCInitTimeoutCause(workerStderrTail, workerExitBeforeHandshake);
+            teardownFailedInit();
+            reject(new RPCInitTimeoutError(initTimeoutMs, cause));
+        }, initTimeoutMs);
+        ipcServer = createServer((socket) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            rpcInstance = new RPC(socket, () => { });
+            resolve(rpcInstance);
+        });
+        ipcServer.on('error', (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            teardownFailedInit();
+            reject(error);
+        });
+        ipcServer.listen(socketPath, () => {
+            const spawnResources = {
+                controller: spawnController,
+                server: ipcServer,
+                socketPath
+            };
+            try {
+                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()
+                        })
+                    ],
+                    platform: process.platform,
+                    arch: process.arch,
+                    stdio: ['inherit', 'inherit', 'pipe']
+                });
+            }
+            catch (error) {
+                // `spawn` resolves the bare binary synchronously and can throw before
+                // the worker exists, so there is no process to emit "exit". Without
+                // this, the throw escapes the `listen` callback as an uncaught
+                // exception and crashes the host process.
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                teardownFailedInit();
+                reject(mapBareSpawnError(error));
+                return;
+            }
+            if (bareWorkerProc) {
+                getWorkerStderr(bareWorkerProc)?.on('data', (chunk) => {
+                    const text = chunk.toString();
+                    workerStderrTail = appendWorkerStderrTail(workerStderrTail, text);
+                    for (const line of text.split('\n')) {
+                        if (line.trim())
+                            workerLogger.debug(line);
+                    }
+                });
+                bareWorkerProc.on('exit', (code, exitSignal) => {
+                    if (settled) {
+                        handlePostHandshakeExit(code, exitSignal, spawnResources);
+                        return;
+                    }
+                    // Keep waiting for "close" so piped stderr can drain, but retain the
+                    // exit status in case a slow stream (for example, a core dump) lets
+                    // the initialization timer win that race.
+                    workerExitBeforeHandshake = { code, signal: exitSignal };
+                });
+                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;
+                    // Worker died before handshake. Use close, not exit, so piped
+                    // stderr has drained before we build the error cause.
+                    settled = true;
+                    clearTimeout(timer);
+                    teardownFailedInit();
+                    reject(new RPCInitTimeoutError(initTimeoutMs, createRPCInitTimeoutCause(workerStderrTail, { code, signal: exitSignal })));
+                });
+            }
+        });
+    });
+    const rpc = await rpcPromise;
+    const runtimeContext = {
+        runtime: 'node',
+        platform: process.platform
+    };
+    // init-hooks calls bare-rpc directly, bypassing rpc-client's race.
+    const resolveConfigForInit = preresolved === CONFIG_UNRESOLVED ? resolveConfig : async () => preresolved;
+    await Promise.race([
+        initializeConfig(rpc, resolveConfigForInit, runtimeContext),
+        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));
+        if (signal.aborted) {
+            fail();
+            return;
+        }
+        signal.addEventListener('abort', fail, { once: true });
+    });
+}
+export async function getRPC() {
+    return ensureRPC();
+}
+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');
+    // 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);
+            try {
+                ;
+                requestStream.destroy?.(err);
+            }
+            catch { }
+            try {
+                ;
+                responseStream.destroy?.(err);
+            }
+            catch { }
+        };
+        lifeSignal.addEventListener('abort', onAbort, { once: true });
+    }
+    return { requestStream, responseStream };
+}
+export async function close() {
+    if (closePromise) {
+        await closePromise;
+        return;
+    }
+    if (!rpcInstance && !rpcPromise && !bareWorkerProc && !ipcServer)
+        return;
+    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');
+            try {
+                workerToClose.kill('SIGTERM');
+            }
+            catch (error) {
+                logger.debug('Failed to kill bare worker process', { error });
+            }
+        }
+        if (serverToClose) {
+            logger.info('🔌 Closing IPC server');
+            await new Promise((resolve) => {
+                try {
+                    serverToClose.close(() => resolve());
+                }
+                catch (error) {
+                    logger.debug('Failed to close IPC server', { error });
+                    resolve();
+                }
+            });
+        }
+        bestEffortUnlinkSocket(socketPathToClose);
+    })();
+    try {
+        await closePromise;
+    }
+    finally {
+        closePromise = null;
+    }
+}
+function handleTerminationSignal(signal) {
+    logger.info(`Received ${signal}, closing RPC resources...`);
+    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);

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

@@ -0,0 +1,27 @@
+import { type BaseTimings } from '@qvac/inference/surface';
+import type { ProfilingResponseMeta } from '@qvac/inference/surface';
+interface BaseClientTimings extends BaseTimings {
+    requestZodValidationMs?: number;
+    requestStringifyMs?: number;
+    sendStart?: number;
+    requestEnd?: number;
+}
+export interface ClientTimings extends BaseClientTimings {
+    firstResponseAt?: number;
+    responseJsonParseMs?: number;
+    responseZodValidationMs?: number;
+}
+export interface ClientStreamTimings extends BaseClientTimings {
+    firstChunkAt?: number;
+    lastChunkAt?: number;
+    chunkCount: number;
+}
+export declare function createClientTimings(profileId: string, requestType: string): ClientTimings;
+export declare function createClientStreamTimings(profileId: string, requestType: string): ClientStreamTimings;
+export declare function cacheConnectionTime(durationMs: number): void;
+export declare function flushConnectionTime(): void;
+export declare function recordClientEvents(timings: ClientTimings, serverMeta?: ProfilingResponseMeta): void;
+export declare function recordClientStreamEvents(timings: ClientStreamTimings, serverMeta?: ProfilingResponseMeta): void;
+export declare function resetConnectionTracking(): void;
+export {};
+//# sourceMappingURL=profiler.d.ts.map

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

@@ -0,0 +1,134 @@
+import { nowMs, record, recordPhase, recordServerBreakdownPhases } from '@qvac/inference/surface';
+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
+        };
+    });
+}
+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);
+    }
+}
+function createBaseTimings(profileId, requestType) {
+    return { profileId, requestType, requestStart: nowMs() };
+}
+export function createClientTimings(profileId, requestType) {
+    return createBaseTimings(profileId, requestType);
+}
+export function createClientStreamTimings(profileId, requestType) {
+    return { ...createBaseTimings(profileId, requestType), chunkCount: 0 };
+}
+export function cacheConnectionTime(durationMs) {
+    const state = getConnectionTrackingState();
+    if (state.connectionTimeRecorded)
+        return;
+    if (state.pendingConnectionTimeMs !== undefined)
+        return;
+    state.pendingConnectionTimeMs = durationMs;
+}
+export function flushConnectionTime() {
+    const state = getConnectionTrackingState();
+    if (state.connectionTimeRecorded)
+        return;
+    if (state.pendingConnectionTimeMs === undefined)
+        return;
+    const durationMs = state.pendingConnectionTimeMs;
+    state.pendingConnectionTimeMs = undefined;
+    state.connectionTimeRecorded = true;
+    record({
+        ts: nowMs(),
+        op: 'rpc',
+        kind: 'rpc',
+        phase: 'connection',
+        ms: durationMs
+    });
+}
+export function recordClientEvents(timings, serverMeta) {
+    const now = nowMs();
+    const totalClientTime = now - timings.requestStart;
+    const base = {
+        ts: now,
+        op: timings.requestType,
+        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);
+    }
+    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);
+    if (serverMeta?.server) {
+        recordServerBreakdownPhases(base, serverMeta.server, 'server');
+        if (serverMeta.server.totalServerMs !== undefined) {
+            recordPhase(base, 'clientOverhead', Math.max(0, totalClientTime - serverMeta.server.totalServerMs));
+        }
+    }
+    if (serverMeta?.operation) {
+        recordOperationEvent(serverMeta.operation);
+    }
+}
+function recordOperationEvent(op) {
+    const event = {
+        ts: nowMs(),
+        op: op.op,
+        kind: op.kind,
+        ms: op.ms
+    };
+    if (op.profileId !== undefined)
+        event.profileId = op.profileId;
+    if (op.gauges !== undefined)
+        event.gauges = op.gauges;
+    if (op.resources !== undefined)
+        event.resources = op.resources;
+    if (op.backend !== undefined)
+        event.backend = op.backend;
+    if (op.tags !== undefined)
+        event.tags = op.tags;
+    if (op.count !== undefined)
+        event.count = op.count;
+    record(event);
+}
+export function recordClientStreamEvents(timings, serverMeta) {
+    const now = nowMs();
+    const totalClientTime = now - timings.requestStart;
+    const base = {
+        ts: now,
+        op: timings.requestType,
+        kind: 'rpc',
+        profileId: timings.profileId
+    };
+    recordRequestPhases(base, timings);
+    if (timings.sendStart !== undefined && timings.firstChunkAt !== undefined) {
+        recordPhase(base, 'ttfb', timings.firstChunkAt - timings.sendStart);
+    }
+    if (timings.firstChunkAt !== undefined && timings.lastChunkAt !== undefined) {
+        recordPhase(base, 'streamDuration', timings.lastChunkAt - timings.firstChunkAt);
+    }
+    recordPhase(base, 'totalClientTime', totalClientTime, {
+        count: timings.chunkCount
+    });
+    if (serverMeta?.server) {
+        recordServerBreakdownPhases(base, serverMeta.server, 'server');
+    }
+    if (serverMeta?.operation) {
+        recordOperationEvent(serverMeta.operation);
+    }
+}
+export function resetConnectionTracking() {
+    const state = getConnectionTrackingState();
+    state.connectionTimeRecorded = false;
+    state.pendingConnectionTimeMs = undefined;
+}