@qvac/sdk 0.8.0 → 1.0.0

package/dist/server/rpc/handlers/plugin-dispatch.js

@@ -1,59 +0,0 @@
-import { getModelEntry } from "../../bare/registry/model-registry.js";
-import { getPlugin } from "../../plugins/index.js";
-import { profileReplyHandler, profileStreamHandler, } from "../profiling/index.js";
-import { ModelNotFoundError, ModelIsDelegatedError, PluginNotFoundError, PluginHandlerNotFoundError, PluginHandlerTypeMismatchError, } from "../../../utils/errors-server.js";
-/**
- * Resolves the plugin handler and returns both the result and streaming flag.
- */
-function resolvePluginHandler(modelId, handlerName, request) {
-    const entry = getModelEntry(modelId);
-    if (!entry) {
-        throw new ModelNotFoundError(modelId);
-    }
-    if (entry.isDelegated || !entry.local) {
-        throw new ModelIsDelegatedError(modelId);
-    }
-    const plugin = getPlugin(entry.local.modelType);
-    if (!plugin) {
-        throw new PluginNotFoundError(entry.local.modelType);
-    }
-    const handlerDef = plugin.handlers[handlerName];
-    if (!handlerDef) {
-        const availableHandlers = Object.keys(plugin.handlers);
-        throw new PluginHandlerNotFoundError(entry.local.modelType, handlerName, availableHandlers);
-    }
-    return {
-        result: handlerDef.handler(request),
-        streaming: handlerDef.streaming,
-    };
-}
-/**
- * Dispatches a request to a plugin handler and returns a Promise.
- * Use for non-streaming (reply) handlers.
- *
- * @throws PluginHandlerTypeMismatchError if the handler is streaming
- */
-export async function dispatchPluginReply(modelId, handlerName, request) {
-    return profileReplyHandler({ op: handlerName, request }, async () => {
-        const { result, streaming } = resolvePluginHandler(modelId, handlerName, request);
-        if (streaming) {
-            throw new PluginHandlerTypeMismatchError(handlerName, "reply", "streaming");
-        }
-        return result;
-    });
-}
-/**
- * Dispatches a request to a plugin handler and returns an AsyncGenerator.
- * Use for streaming handlers.
- *
- * @throws PluginHandlerTypeMismatchError if the handler is not streaming
- */
-export async function* dispatchPluginStream(modelId, handlerName, request) {
-    yield* profileStreamHandler({ op: handlerName, request }, async function* () {
-        const { result, streaming } = resolvePluginHandler(modelId, handlerName, request);
-        if (!streaming) {
-            throw new PluginHandlerTypeMismatchError(handlerName, "streaming", "reply");
-        }
-        yield* result;
-    });
-}

package/dist/server/rpc/handlers/plugin-invoke.d.ts

@@ -1,4 +0,0 @@
-import type { PluginInvokeRequest, PluginInvokeResponse, PluginInvokeStreamRequest, PluginInvokeStreamResponse } from "../../../schemas/plugin";
-export declare function handlePluginInvoke(request: PluginInvokeRequest): Promise<PluginInvokeResponse>;
-export declare function handlePluginInvokeStream(request: PluginInvokeStreamRequest): AsyncGenerator<PluginInvokeStreamResponse>;
-//# sourceMappingURL=plugin-invoke.d.ts.map

package/dist/server/rpc/handlers/plugin-invoke.js

@@ -1,92 +0,0 @@
-import { getModelEntry } from "../../bare/registry/model-registry.js";
-import { getPlugin, getPluginHandler } from "../../plugins/index.js";
-import { profileReplyHandler, profileStreamHandler, } from "../profiling/index.js";
-import { PluginNotFoundError, PluginHandlerNotFoundError, PluginHandlerTypeMismatchError, PluginRequestValidationFailedError, PluginResponseValidationFailedError, ModelIsDelegatedError, ModelNotFoundError, } from "../../../utils/errors-server.js";
-import { getServerLogger } from "../../../logging/index.js";
-const logger = getServerLogger();
-function resolvePluginHandler(modelId, handlerName) {
-    const modelEntry = getModelEntry(modelId);
-    if (!modelEntry) {
-        throw new ModelNotFoundError(modelId);
-    }
-    if (modelEntry.isDelegated || !modelEntry.local) {
-        throw new ModelIsDelegatedError(modelId);
-    }
-    const modelType = modelEntry.local.modelType;
-    const plugin = getPlugin(modelType);
-    if (!plugin) {
-        throw new PluginNotFoundError(modelType);
-    }
-    const handlerDef = getPluginHandler(modelType, handlerName);
-    if (!handlerDef) {
-        const availableHandlers = Object.keys(plugin.handlers);
-        throw new PluginHandlerNotFoundError(modelType, handlerName, availableHandlers);
-    }
-    return { modelType, plugin, handlerDef };
-}
-export async function handlePluginInvoke(request) {
-    return profileReplyHandler({ op: "pluginInvoke", request }, async () => {
-        const { modelId, handler: handlerName, params } = request;
-        logger.debug(`[pluginInvoke] modelId=${modelId} handler=${handlerName}`);
-        const { handlerDef } = resolvePluginHandler(modelId, handlerName);
-        if (handlerDef.streaming) {
-            throw new PluginHandlerTypeMismatchError(handlerName, "reply", "streaming");
-        }
-        const parseResult = handlerDef.requestSchema.safeParse(params);
-        if (!parseResult.success) {
-            const details = parseResult.error.issues
-                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-                .join(", ");
-            throw new PluginRequestValidationFailedError(handlerName, details);
-        }
-        const result = await handlerDef.handler(parseResult.data);
-        const responseParseResult = handlerDef.responseSchema.safeParse(result);
-        if (!responseParseResult.success) {
-            const details = responseParseResult.error.issues
-                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-                .join(", ");
-            throw new PluginResponseValidationFailedError(handlerName, details);
-        }
-        return {
-            type: "pluginInvoke",
-            result: responseParseResult.data,
-        };
-    });
-}
-export async function* handlePluginInvokeStream(request) {
-    yield* profileStreamHandler({ op: "pluginInvokeStream", request }, async function* () {
-        const { modelId, handler: handlerName, params } = request;
-        logger.debug(`[pluginInvokeStream] modelId=${modelId} handler=${handlerName}`);
-        const { handlerDef } = resolvePluginHandler(modelId, handlerName);
-        if (!handlerDef.streaming) {
-            throw new PluginHandlerTypeMismatchError(handlerName, "streaming", "reply");
-        }
-        const parseResult = handlerDef.requestSchema.safeParse(params);
-        if (!parseResult.success) {
-            const details = parseResult.error.issues
-                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-                .join(", ");
-            throw new PluginRequestValidationFailedError(handlerName, details);
-        }
-        const generator = handlerDef.handler(parseResult.data);
-        for await (const chunk of generator) {
-            const responseParseResult = handlerDef.responseSchema.safeParse(chunk);
-            if (!responseParseResult.success) {
-                const details = responseParseResult.error.issues
-                    .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-                    .join(", ");
-                throw new PluginResponseValidationFailedError(handlerName, details);
-            }
-            yield {
-                type: "pluginInvokeStream",
-                result: responseParseResult.data,
-                done: false,
-            };
-        }
-        yield {
-            type: "pluginInvokeStream",
-            result: null,
-            done: true,
-        };
-    });
-}

package/dist/server/rpc/handlers/registry.d.ts

@@ -1,5 +0,0 @@
-import type { ModelRegistryListResponse, ModelRegistrySearchRequest, ModelRegistrySearchResponse, ModelRegistryGetModelRequest, ModelRegistryGetModelResponse } from "../../../schemas/index";
-export declare function handleModelRegistryList(): Promise<ModelRegistryListResponse>;
-export declare function handleModelRegistrySearch(request: ModelRegistrySearchRequest): Promise<ModelRegistrySearchResponse>;
-export declare function handleModelRegistryGetModel(request: ModelRegistryGetModelRequest): Promise<ModelRegistryGetModelResponse>;
-//# sourceMappingURL=registry.d.ts.map

package/dist/server/rpc/handlers/registry.js

@@ -1,157 +0,0 @@
-import { REGISTRY_ERROR_CODES } from "../../../schemas/sdk-errors-registry.js";
-import { getAddonFromEngine, resolveCanonicalEngine, } from "../../../schemas/engine-addon-map.js";
-import { getRegistryClient } from "../../bare/registry/registry-client.js";
-import { getServerLogger } from "../../../logging/index.js";
-import { ModelRegistryQueryFailedError } from "../../../utils/errors-server.js";
-const logger = getServerLogger();
-function toHexString(value) {
-    if (!value)
-        return "";
-    if (Buffer.isBuffer(value))
-        return value.toString("hex");
-    if (typeof value === "string")
-        return value;
-    if (typeof value === "object" && "data" in value) {
-        return Buffer.from(value.data).toString("hex");
-    }
-    return "";
-}
-function processRegistryModel(model) {
-    const engine = resolveCanonicalEngine(model.engine || "");
-    if (!engine) {
-        logger.warn(`Skipping model with unknown engine "${model.engine}": ${model.path}`);
-        return null;
-    }
-    const filename = model.path.split("/").pop() || model.path;
-    const blobBinding = model.blobBinding;
-    const blobCoreKey = toHexString(blobBinding?.coreKey);
-    const blobBlockOffset = blobBinding?.blockOffset ?? 0;
-    const blobBlockLength = blobBinding?.blockLength ?? 0;
-    const blobByteOffset = blobBinding?.byteOffset ?? 0;
-    const expectedSize = blobBinding?.byteLength ?? 0;
-    // sha256 lives on blobBinding at runtime (per hyperschema), fall back to top-level
-    const sha256Checksum = blobBinding?.["sha256"] ||
-        model.sha256 ||
-        "";
-    const addon = getAddonFromEngine(engine);
-    // Use the filename without extension as the display name
-    const name = filename.replace(/\.\w+$/, "");
-    return {
-        name,
-        registryPath: model.path,
-        registrySource: model.source,
-        blobCoreKey,
-        blobBlockOffset,
-        blobBlockLength,
-        blobByteOffset,
-        modelId: filename,
-        addon,
-        expectedSize,
-        sha256Checksum,
-        engine,
-        quantization: model.quantization || "",
-        params: model.params || "",
-    };
-}
-export async function handleModelRegistryList() {
-    logger.debug("Handling QVAC model registry list request");
-    try {
-        const client = await getRegistryClient();
-        const registryModels = await client.findBy();
-        const models = registryModels
-            .map(processRegistryModel)
-            .filter((m) => m !== null);
-        logger.debug(`QVAC model registry list returned ${models.length} models`);
-        return {
-            type: "modelRegistryList",
-            success: true,
-            models,
-        };
-    }
-    catch (error) {
-        logger.error("QVAC model registry list failed:", error);
-        // Re-throw registry client errors directly (19001-19003)
-        const qvacError = error;
-        if (qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CONNECT ||
-            qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CLOSE ||
-            qvacError.code === REGISTRY_ERROR_CODES.MODEL_NOT_FOUND) {
-            throw error;
-        }
-        // Wrap unknown errors in SDK error
-        throw new ModelRegistryQueryFailedError(error instanceof Error ? error.message : "Unknown error", error);
-    }
-}
-export async function handleModelRegistrySearch(request) {
-    logger.debug("Handling QVAC model registry search request", request);
-    try {
-        const client = await getRegistryClient();
-        const registryModels = await client.findBy({
-            ...(request.quantization && { quantization: request.quantization }),
-        });
-        let models = registryModels
-            .map(processRegistryModel)
-            .filter((m) => m !== null);
-        if (request.engine) {
-            const canonicalEngine = resolveCanonicalEngine(request.engine);
-            models = models.filter((m) => m.engine === (canonicalEngine ?? request.engine));
-        }
-        if (request.filter) {
-            const filterLower = request.filter.toLowerCase();
-            models = models.filter((m) => m.name.toLowerCase().includes(filterLower) ||
-                m.registryPath.toLowerCase().includes(filterLower) ||
-                m.addon.toLowerCase().includes(filterLower) ||
-                m.engine.toLowerCase().includes(filterLower));
-        }
-        if (request.addon) {
-            models = models.filter((m) => m.addon === request.addon);
-        }
-        logger.debug(`QVAC model registry search returned ${models.length} models`);
-        return {
-            type: "modelRegistrySearch",
-            success: true,
-            models,
-        };
-    }
-    catch (error) {
-        logger.error("QVAC model registry search failed:", error);
-        // Re-throw registry client errors directly (19001-19003)
-        const qvacError = error;
-        if (qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CONNECT ||
-            qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CLOSE ||
-            qvacError.code === REGISTRY_ERROR_CODES.MODEL_NOT_FOUND) {
-            throw error;
-        }
-        throw new ModelRegistryQueryFailedError(error instanceof Error ? error.message : "Unknown error", error);
-    }
-}
-export async function handleModelRegistryGetModel(request) {
-    logger.debug("Handling QVAC model registry get model request", request);
-    try {
-        const client = await getRegistryClient();
-        const rawModel = await client.getModel(request.registryPath, request.registrySource);
-        if (!rawModel) {
-            throw new ModelRegistryQueryFailedError(`Model not found: ${request.registrySource}/${request.registryPath}`);
-        }
-        const model = processRegistryModel(rawModel);
-        if (!model) {
-            throw new ModelRegistryQueryFailedError(`Model has unknown engine "${rawModel.engine}": ${request.registryPath}`);
-        }
-        logger.debug("QVAC model registry get model found:", model.name);
-        return {
-            type: "modelRegistryGetModel",
-            success: true,
-            model,
-        };
-    }
-    catch (error) {
-        logger.error("QVAC model registry get model failed:", error);
-        // Re-throw registry client errors directly (19001-19003)
-        const qvacError = error;
-        if (qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CONNECT ||
-            qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CLOSE ||
-            qvacError.code === REGISTRY_ERROR_CODES.MODEL_NOT_FOUND) {
-            throw error;
-        }
-        throw new ModelRegistryQueryFailedError(error instanceof Error ? error.message : "Unknown error", error);
-    }
-}

package/dist/server/rpc/handlers/unload-model-delegated.d.ts

@@ -1,3 +0,0 @@
-import type { UnloadModelRequest, UnloadModelResponse } from "../../../schemas/index";
-export declare function handleUnloadModelDelegated(request: UnloadModelRequest): Promise<UnloadModelResponse>;
-//# sourceMappingURL=unload-model-delegated.d.ts.map

package/dist/server/rpc/handlers/unload-model-delegated.js

@@ -1,32 +0,0 @@
-import { getModelEntry, unregisterModel } from "../../bare/registry/model-registry.js";
-import { getRPC } from "../../bare/delegate-rpc-client.js";
-import { send } from "../delegate-transport.js";
-import { hasActiveProviders } from "../../bare/hyperswarm.js";
-import { getRegistryStats } from "../../bare/registry/model-registry.js";
-import { ModelIsDelegatedError } from "../../../utils/errors-server.js";
-import { getServerLogger } from "../../../logging/index.js";
-const logger = getServerLogger();
-export async function handleUnloadModelDelegated(request) {
-    const entry = getModelEntry(request.modelId);
-    if (!entry?.isDelegated || !entry.delegated) {
-        throw new ModelIsDelegatedError(request.modelId);
-    }
-    const { topic, providerPublicKey, timeout } = entry.delegated;
-    unregisterModel(request.modelId);
-    try {
-        logger.info(`Sending delegated unload for model ${request.modelId} to provider: ${providerPublicKey}`);
-        const rpc = await getRPC(topic, providerPublicKey, { timeout });
-        await send({ type: "unloadModel", modelId: request.modelId, clearStorage: false }, rpc, { timeout });
-        logger.info(`Delegated model ${request.modelId} unloaded on provider`);
-    }
-    catch (error) {
-        logger.error(`Failed to unload delegated model ${request.modelId} on provider:`, error);
-    }
-    const stats = getRegistryStats();
-    return {
-        type: "unloadModel",
-        success: true,
-        hasActiveModels: stats.totalModels > 0,
-        hasActiveProviders: hasActiveProviders(),
-    };
-}

package/dist/server/rpc/profiling/context.d.ts

@@ -1,18 +0,0 @@
-import { type ProfilingRequestMeta, type DelegationBreakdown, type OperationEvent } from "../../../schemas/index";
-export interface ServerProfilingContext {
-    meta: ProfilingRequestMeta;
-    requestStart: number;
-    jsonParseMs?: number;
-    zodValidationMs?: number;
-    handlerExecutionMs?: number;
-    responseZodValidationMs?: number;
-    responseStringifyMs?: number;
-}
-export declare function createProfilingContext(meta: ProfilingRequestMeta): ServerProfilingContext;
-export interface ProfilingInjectionOptions {
-    ctx?: ServerProfilingContext;
-    delegation?: DelegationBreakdown;
-    operation?: OperationEvent;
-}
-export declare function injectProfilingIntoString(jsonString: string, options: ProfilingInjectionOptions): string;
-//# sourceMappingURL=context.d.ts.map

package/dist/server/rpc/profiling/context.js

@@ -1,38 +0,0 @@
-import { PROFILING_KEY, } from "../../../schemas/index.js";
-import { nowMs } from "../../../profiling/index.js";
-export function createProfilingContext(meta) {
-    return { meta, requestStart: nowMs() };
-}
-function buildServerBreakdown(ctx) {
-    return {
-        requestJsonParseMs: ctx.jsonParseMs,
-        requestZodValidationMs: ctx.zodValidationMs,
-        handlerExecutionMs: ctx.handlerExecutionMs,
-        responseZodValidationMs: ctx.responseZodValidationMs,
-        responseStringifyMs: ctx.responseStringifyMs,
-        totalServerMs: nowMs() - ctx.requestStart,
-    };
-}
-export function injectProfilingIntoString(jsonString, options) {
-    const { ctx, delegation, operation } = options;
-    const includeServer = ctx?.meta.includeServer ?? false;
-    const hasContent = includeServer || !!delegation || !!operation;
-    if (!hasContent || !jsonString.endsWith("}")) {
-        return jsonString;
-    }
-    const id = ctx?.meta.id ?? delegation?.profileId ?? operation?.profileId ?? "";
-    const profilingMeta = { id };
-    if (includeServer && ctx) {
-        profilingMeta["server"] = buildServerBreakdown(ctx);
-    }
-    if (delegation) {
-        const { profileId: _unused, ...delegationWithoutId } = delegation;
-        void _unused;
-        profilingMeta["delegation"] = delegationWithoutId;
-    }
-    if (operation) {
-        profilingMeta["operation"] = operation;
-    }
-    return (jsonString.slice(0, -1) +
-        `,"${PROFILING_KEY}":${JSON.stringify(profilingMeta)}}`);
-}

package/dist/server/rpc/profiling/delegation-profiler.d.ts

@@ -1,32 +0,0 @@
-import { type BaseTimings } from "../../../profiling/index";
-import type { ProfilingRequestMeta, ProfilingResponseMeta, DelegationBreakdown } from "../../../schemas/index";
-export interface DelegatedHandlerOptions {
-    profilingMeta?: ProfilingRequestMeta;
-}
-interface BaseDelegationTimings extends BaseTimings {
-    requestStringifyMs?: number;
-    sendStart?: number;
-}
-export interface DelegationTimings extends BaseDelegationTimings {
-    firstResponseAt?: number;
-    responseJsonParseMs?: number;
-}
-export interface DelegationStreamTimings extends BaseDelegationTimings {
-    firstChunkAt?: number;
-    lastChunkAt?: number;
-    chunkCount: number;
-}
-export declare function shouldProfileDelegation(op: string, incomingMeta?: ProfilingRequestMeta): boolean;
-export declare function createDelegationTimings(profileId: string, requestType: string): DelegationTimings;
-export declare function createDelegationStreamTimings(profileId: string, requestType: string): DelegationStreamTimings;
-export declare function cacheDelegationConnectionTime(peerKey: string, durationMs: number): void;
-export declare function flushServerConnectionEvent(peerKey: string): void;
-export declare function consumeBreakdownConnectionTime(peerKey: string): number | undefined;
-export declare function buildDelegationBreakdown(timings: DelegationTimings, connectionMs?: number): DelegationBreakdown;
-export declare function buildDelegationStreamBreakdown(timings: DelegationStreamTimings): DelegationBreakdown;
-export declare function recordDelegationEvents(timings: DelegationTimings, serverMeta?: ProfilingResponseMeta, connectionMs?: number): DelegationBreakdown;
-export declare function recordDelegationStreamEvents(timings: DelegationStreamTimings, serverMeta?: ProfilingResponseMeta): void;
-export declare function clearPeerConnectionTracking(peerKey: string): void;
-export declare function resetDelegationConnectionTracking(): void;
-export {};
-//# sourceMappingURL=delegation-profiler.d.ts.map

package/dist/server/rpc/profiling/delegation-profiler.js

@@ -1,154 +0,0 @@
-import { nowMs, record, shouldProfile, recordPhase, recordServerBreakdownPhases, } from "../../../profiling/index.js";
-/**
- * Per-peer connection tracking for delegation.
- * Separate tracking for server-side event recording vs breakdown injection.
- *
- * Flow:
- * 1. Connection happens → cacheDelegationConnectionTime stores ms
- * 2. First profiled call (stream or unary) → flushServerConnectionEvent records server event
- * 3. First unary call → consumeBreakdownConnectionTime returns ms for breakdown injection
- */
-const pendingConnectionTimes = new Map();
-const serverConnectionRecorded = new Map();
-const breakdownConnectionMs = new Map();
-const breakdownConnectionInjected = new Map();
-export function shouldProfileDelegation(op, incomingMeta) {
-    if (incomingMeta?.enabled === false) {
-        return false;
-    }
-    if (incomingMeta?.enabled === true) {
-        return true;
-    }
-    return shouldProfile(op);
-}
-export function createDelegationTimings(profileId, requestType) {
-    return { profileId, requestType, requestStart: nowMs() };
-}
-export function createDelegationStreamTimings(profileId, requestType) {
-    return { profileId, requestType, requestStart: nowMs(), chunkCount: 0 };
-}
-export function cacheDelegationConnectionTime(peerKey, durationMs) {
-    if (serverConnectionRecorded.get(peerKey))
-        return;
-    if (pendingConnectionTimes.has(peerKey))
-        return;
-    pendingConnectionTimes.set(peerKey, durationMs);
-}
-export function flushServerConnectionEvent(peerKey) {
-    if (serverConnectionRecorded.get(peerKey))
-        return;
-    const ms = pendingConnectionTimes.get(peerKey);
-    if (ms === undefined)
-        return;
-    pendingConnectionTimes.delete(peerKey);
-    serverConnectionRecorded.set(peerKey, true);
-    if (!breakdownConnectionInjected.get(peerKey)) {
-        breakdownConnectionMs.set(peerKey, ms);
-    }
-    record({
-        ts: nowMs(),
-        op: "delegation",
-        kind: "delegation",
-        phase: "connection",
-        ms,
-        tags: { peer: peerKey.slice(0, 16) },
-    });
-}
-export function consumeBreakdownConnectionTime(peerKey) {
-    if (breakdownConnectionInjected.get(peerKey))
-        return undefined;
-    const ms = breakdownConnectionMs.get(peerKey);
-    if (ms === undefined)
-        return undefined;
-    breakdownConnectionMs.delete(peerKey);
-    breakdownConnectionInjected.set(peerKey, true);
-    return ms;
-}
-export function buildDelegationBreakdown(timings, connectionMs) {
-    const now = nowMs();
-    const breakdown = {
-        profileId: timings.profileId,
-    };
-    if (connectionMs !== undefined) {
-        breakdown.connectionMs = connectionMs;
-    }
-    if (timings.requestStringifyMs !== undefined) {
-        breakdown.requestStringifyMs = timings.requestStringifyMs;
-    }
-    if (timings.sendStart !== undefined &&
-        timings.firstResponseAt !== undefined) {
-        breakdown.serverWaitMs = timings.firstResponseAt - timings.sendStart;
-    }
-    if (timings.responseJsonParseMs !== undefined) {
-        breakdown.responseJsonParseMs = timings.responseJsonParseMs;
-    }
-    breakdown.totalDelegationMs = now - timings.requestStart;
-    return breakdown;
-}
-export function buildDelegationStreamBreakdown(timings) {
-    const now = nowMs();
-    const breakdown = {
-        profileId: timings.profileId,
-    };
-    if (timings.requestStringifyMs !== undefined) {
-        breakdown.requestStringifyMs = timings.requestStringifyMs;
-    }
-    if (timings.sendStart !== undefined && timings.firstChunkAt !== undefined) {
-        breakdown.serverWaitMs = timings.firstChunkAt - timings.sendStart;
-    }
-    breakdown.totalDelegationMs = now - timings.requestStart;
-    return breakdown;
-}
-export function recordDelegationEvents(timings, serverMeta, connectionMs) {
-    const now = nowMs();
-    const base = {
-        ts: now,
-        op: timings.requestType,
-        kind: "delegation",
-        profileId: timings.profileId,
-    };
-    const breakdown = buildDelegationBreakdown(timings, connectionMs);
-    recordPhase(base, "request.stringify", breakdown.requestStringifyMs);
-    recordPhase(base, "serverWait", breakdown.serverWaitMs);
-    recordPhase(base, "response.jsonParse", breakdown.responseJsonParseMs);
-    recordPhase(base, "totalDelegationTime", breakdown.totalDelegationMs);
-    if (serverMeta?.server) {
-        recordServerBreakdownPhases(base, serverMeta.server, "delegated");
-    }
-    return breakdown;
-}
-export function recordDelegationStreamEvents(timings, serverMeta) {
-    const now = nowMs();
-    const totalTime = now - timings.requestStart;
-    const base = {
-        ts: now,
-        op: timings.requestType,
-        kind: "delegation",
-        profileId: timings.profileId,
-    };
-    recordPhase(base, "request.stringify", timings.requestStringifyMs);
-    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, "totalDelegationTime", totalTime, {
-        count: timings.chunkCount,
-    });
-    if (serverMeta?.server) {
-        recordServerBreakdownPhases(base, serverMeta.server, "delegated");
-    }
-}
-export function clearPeerConnectionTracking(peerKey) {
-    pendingConnectionTimes.delete(peerKey);
-    serverConnectionRecorded.delete(peerKey);
-    breakdownConnectionMs.delete(peerKey);
-    breakdownConnectionInjected.delete(peerKey);
-}
-export function resetDelegationConnectionTracking() {
-    pendingConnectionTimes.clear();
-    serverConnectionRecorded.clear();
-    breakdownConnectionMs.clear();
-    breakdownConnectionInjected.clear();
-}

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

@@ -1,5 +0,0 @@
-export { createServerProfiler, type ServerProfiler } from "./profiler";
-export { profileReplyHandler, profileStreamHandler, } from "./operation-wrappers";
-export { registerOperationMetrics, buildOperationEvent, type OperationMetricsConfig, } from "./operation-metrics";
-export { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, cacheDelegationConnectionTime, flushServerConnectionEvent, consumeBreakdownConnectionTime, clearPeerConnectionTracking, resetDelegationConnectionTracking, type DelegationTimings, type DelegationStreamTimings, type DelegatedHandlerOptions, } from "./delegation-profiler";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,4 +0,0 @@
-export { createServerProfiler } from "./profiler.js";
-export { profileReplyHandler, profileStreamHandler, } from "./operation-wrappers.js";
-export { registerOperationMetrics, buildOperationEvent, } from "./operation-metrics.js";
-export { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, cacheDelegationConnectionTime, flushServerConnectionEvent, consumeBreakdownConnectionTime, clearPeerConnectionTracking, resetDelegationConnectionTracking, } from "./delegation-profiler.js";

package/dist/server/rpc/profiling/operation-metrics.d.ts

@@ -1,25 +0,0 @@
-/**
- * Declarative extraction of operation-level metrics from request/response data.
- * Used by operation wrappers to capture handler-specific profiling events.
- */
-import type { ProfilingEvent, ProfilingEventKind } from "../../../profiling/types";
-import type { DownloadStats } from "../handlers/load-model/types";
-export type MetricExtractor<T> = (data: T) => Record<string, number> | undefined;
-export type TagExtractor<T> = (data: T) => Record<string, string> | undefined;
-export interface OperationMetricsConfig<TRequest = unknown, TResponse = unknown> {
-    op: string;
-    kind: ProfilingEventKind;
-    fromRequest?: MetricExtractor<TRequest>;
-    fromFinalChunk?: MetricExtractor<TResponse>;
-    fromResult?: MetricExtractor<TResponse>;
-    getTags?: (request: TRequest) => Record<string, string>;
-    getTagsFromResult?: TagExtractor<TResponse>;
-}
-export interface DownloadAssetProfilingMeta {
-    sourceType?: string;
-    downloadStats?: DownloadStats;
-    totalDownloadTimeMs?: number;
-}
-export declare function registerOperationMetrics<TRequest, TResponse>(config: OperationMetricsConfig<TRequest, TResponse>): void;
-export declare function buildOperationEvent(op: string, profileId: string, ts: number, executionMs: number, request?: unknown, finalResponse?: unknown, ttfb?: number): ProfilingEvent | undefined;
-//# sourceMappingURL=operation-metrics.d.ts.map