@qvac/sdk 0.18.2 → 0.19.0

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

@@ -1,505 +0,0 @@
-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 '../../client/init-hooks.js';
-import { resolveConfig } from '../../client/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();
-// 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.
- *
- * `path.resolve(__dirname, ...)` is invisible to static analysis, so packaged
- * consumers ship without worker.js. We use `import.meta.asset(<literal>)` on
- * Bare (detected by bare-module-lexer) and fall back to
- * `new URL(<literal>, import.meta.url)` elsewhere. Specs must be string
- * literals at the call site.
- */
-function getDefaultWorkerPath() {
-    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);
-    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);
-    return fileURLToPath(devUrl);
-}
-/**
- * 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 createWorkerStartupError(details, stderrTail) {
-    const stderr = stderrTail.trimEnd();
-    if (!stderr)
-        return new Error(details);
-    return new Error(`${details}\n\nWorker stderr:\n${stderr}`);
-}
-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);
-}
-async function ensureRPC() {
-    if (rpcInstance)
-        return rpcInstance;
-    if (rpcPromise)
-        return rpcPromise;
-    if (closePromise) {
-        await closePromise;
-    }
-    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 = '';
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            const cause = workerStderrTail
-                ? createWorkerStartupError('Worker did not establish IPC before the RPC initialization timeout', workerStderrTail)
-                : undefined;
-            teardownFailedInit();
-            reject(new RPCInitTimeoutError(RPC_INIT_TIMEOUT_MS, cause));
-        }, RPC_INIT_TIMEOUT_MS);
-        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;
-                    }
-                    // Pre-handshake failures are rejected from "close" so stderr has
-                    // drained before we assemble the startup error cause.
-                });
-                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(RPC_INIT_TIMEOUT_MS, createWorkerStartupError(`Worker process exited with code ${code}, signal ${exitSignal} before IPC connection was established`, workerStderrTail)));
-                });
-            }
-        });
-    });
-    const rpc = await rpcPromise;
-    const runtimeContext = {
-        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)
-    ]);
-    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/client/rpc/profiling/profiler.d.ts

@@ -1,27 +0,0 @@
-import { type BaseTimings } from '../../../profiling/index.js';
-import type { ProfilingResponseMeta } from '../../../schemas/index.js';
-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/client/rpc/profiling/profiler.js

@@ -1,140 +0,0 @@
-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
-        };
-    });
-}
-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?.delegation) {
-        recordDelegationBreakdownPhases(base, serverMeta.delegation);
-    }
-    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?.delegation) {
-        recordDelegationBreakdownPhases(base, serverMeta.delegation);
-    }
-    if (serverMeta?.operation) {
-        recordOperationEvent(serverMeta.operation);
-    }
-}
-export function resetConnectionTracking() {
-    const state = getConnectionTrackingState();
-    state.connectionTimeRecorded = false;
-    state.pendingConnectionTimeMs = undefined;
-}

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

@@ -1,19 +0,0 @@
-import type RPC from 'bare-rpc';
-import { type Request, type Response, type RPCOptions } from '../../schemas/index.js';
-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 {
-    write(chunk: Uint8Array): void;
-    end(): void;
-    destroy(): void;
-}
-export interface DuplexReadable extends AsyncIterable<Buffer | string> {
-    destroy(): void;
-}
-export interface DuplexSession {
-    requestStream: DuplexWritable;
-    responseStream: DuplexReadable;
-}
-export declare function duplex<T extends Request>(request: T, options?: RPCOptions): Promise<DuplexSession>;
-export declare function close(): Promise<void>;
-//# sourceMappingURL=rpc-client.d.ts.map