@qvac/sdk 0.7.1 → 0.8.0

package/dist/models/update-models/codegen.js

@@ -74,7 +74,7 @@ export type RegistryItem = {
   blobBlockLength: number;
   blobByteOffset: number;
   modelId: string;
-  addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | "ocr" | "other";
+  addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | "ocr" | "parakeet" | "other";
   expectedSize: number;
   sha256Checksum: string;
   engine: string;
@@ -103,7 +103,7 @@ export type ModelConstant = {
   modelId: string;
   expectedSize: number;
   sha256Checksum: string;
-  addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | "ocr" | "other";
+  addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | "ocr" | "parakeet" | "other";
   engine: string;
   quantization: string;
   params: string;

package/dist/models/update-models/history.d.ts

@@ -7,6 +7,17 @@ export declare function compareModels(remoteModels: ProcessedModel[], currentMod
 export declare function assignNames(models: ProcessedModel[]): (ProcessedModel & {
     name: string;
 })[];
+export declare function separateUpdates(added: (ProcessedModel & {
+    name: string;
+})[], removed: CurrentModel[]): {
+    added: (ProcessedModel & {
+        name: string;
+    })[];
+    updated: (ProcessedModel & {
+        name: string;
+    })[];
+    removed: CurrentModel[];
+};
 export declare function createHistoryFile(added: (ProcessedModel & {
     name: string;
 })[], removed: CurrentModel[], currentModels: CurrentModel[], historyDir: string): string | null;

package/dist/models/update-models/history.js

@@ -53,10 +53,21 @@ export function assignNames(models) {
         }),
     }));
 }
+export function separateUpdates(added, removed) {
+    const removedNames = new Set(removed.map((m) => m.name));
+    const addedNames = new Set(added.map((m) => m.name));
+    const updatedNames = new Set([...addedNames].filter((name) => removedNames.has(name)));
+    return {
+        added: added.filter((m) => !updatedNames.has(m.name)),
+        updated: added.filter((m) => updatedNames.has(m.name)),
+        removed: removed.filter((m) => !updatedNames.has(m.name)),
+    };
+}
 export function createHistoryFile(added, removed, currentModels, historyDir) {
     if (added.length === 0 && removed.length === 0) {
         return null;
     }
+    const { added: trulyAdded, updated, removed: trulyRemoved, } = separateUpdates(added, removed);
     if (!fs.existsSync(historyDir)) {
         fs.mkdirSync(historyDir, { recursive: true });
     }
@@ -68,20 +79,28 @@ export function createHistoryFile(added, removed, currentModels, historyDir) {
     let content = `commit=${fullHash}\n`;
     content += `timestamp=${timestamp}\n`;
     content += `previous_count=${currentModels.length}\n`;
-    content += `new_count=${currentModels.length + added.length - removed.length}\n`;
+    content += `new_count=${currentModels.length + trulyAdded.length - trulyRemoved.length}\n`;
     content += `\n`;
-    if (added.length > 0) {
+    if (trulyAdded.length > 0) {
         content += `[added]\n`;
-        added.forEach((m) => {
+        trulyAdded.forEach((m) => {
+            content += `${m.name}\n`;
+        });
+        content += `\n`;
+    }
+    if (updated.length > 0) {
+        content += `[updated]\n`;
+        updated.forEach((m) => {
             content += `${m.name}\n`;
         });
         content += `\n`;
     }
-    if (removed.length > 0) {
+    if (trulyRemoved.length > 0) {
         content += `[removed]\n`;
-        removed.forEach((m) => {
+        trulyRemoved.forEach((m) => {
             content += `${m.name}\n`;
         });
+        content += `\n`;
     }
     fs.writeFileSync(filepath, content);
     return filepath;

package/dist/models/update-models/index.js

@@ -2,8 +2,7 @@ import fs from "fs";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
 import { generateModelsFileContent } from "./codegen.js";
-import { generateExportName } from "./naming.js";
-import { assignNames, compareModels, createHistoryFile, loadCurrentModels, } from "./history.js";
+import { assignNames, compareModels, createHistoryFile, loadCurrentModels, separateUpdates, } from "./history.js";
 import { collectModels } from "./registry.js";
 import { formatSize } from "./utils.js";
 const OUTPUT_FILE = fileURLToPath(new URL("../registry/models.ts", import.meta.url));
@@ -34,32 +33,33 @@ async function checkOnly(nonBlocking = false, showDuplicates = false) {
             process.exit(nonBlocking ? 0 : 1);
         }
         const { remoteModels, currentModels } = result;
-        const { added, removed } = compareModels(remoteModels, currentModels);
-        if (added.length === 0 && removed.length === 0) {
+        const { added: rawAdded, removed: rawRemoved } = compareModels(remoteModels, currentModels);
+        if (rawAdded.length === 0 && rawRemoved.length === 0) {
             console.log(`✅ Models are up to date (${remoteModels.length} models)`);
             process.exit(0);
         }
+        const addedWithNames = assignNames(rawAdded);
+        const { added, updated, removed } = separateUpdates(addedWithNames, rawRemoved);
         console.log("");
         console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
         if (added.length > 0) {
             console.log(`✨ ${added.length} new model${added.length === 1 ? "" : "s"} available:`);
-            const usedNames = new Set();
             added.slice(0, 10).forEach((m) => {
-                const exportName = generateExportName({
-                    path: m.registryPath,
-                    engine: m.engine,
-                    name: m.modelName,
-                    quantization: m.quantization,
-                    params: m.params,
-                    tags: m.tags,
-                    usedNames,
-                });
-                console.log(`  + ${exportName} (${m.addon}, ${formatSize(m.expectedSize)})`);
+                console.log(`  + ${m.name} (${m.addon}, ${formatSize(m.expectedSize)})`);
             });
             if (added.length > 10) {
                 console.log(`  ... and ${added.length - 10} more`);
             }
         }
+        if (updated.length > 0) {
+            console.log(`\n🔄 ${updated.length} model${updated.length === 1 ? "" : "s"} updated:`);
+            updated.slice(0, 10).forEach((m) => {
+                console.log(`  ~ ${m.name} (${m.addon}, ${formatSize(m.expectedSize)})`);
+            });
+            if (updated.length > 10) {
+                console.log(`  ... and ${updated.length - 10} more`);
+            }
+        }
         if (removed.length > 0) {
             console.log(`\n⚠️  ${removed.length} model${removed.length === 1 ? "" : "s"} removed:`);
             removed.slice(0, 5).forEach((m) => {
@@ -104,8 +104,9 @@ async function updateModels(showDuplicates = false, noDedup = false) {
     if (added.length > 0 || removed.length > 0) {
         const historyFile = createHistoryFile(addedWithNames, removed, currentModels, HISTORY_DIR);
         if (historyFile) {
+            const { added: trulyAdded, updated, removed: trulyRemoved, } = separateUpdates(addedWithNames, removed);
             console.log(`📜 Created history file → ${historyFile}`);
-            console.log(`   Added: ${added.length}, Removed: ${removed.length}`);
+            console.log(`   Added: ${trulyAdded.length}, Updated: ${updated.length}, Removed: ${trulyRemoved.length}`);
         }
     }
 }

package/dist/models/update-models/naming.js

@@ -99,6 +99,8 @@ function generateBaseName(input) {
             return generateTtsName(input);
         case "ocr":
             return generateOcrName(input);
+        case "parakeet":
+            return generateParakeetName(input);
         default:
             return cleanPart(input.filename.replace(/\.\w+$/, ""));
     }
@@ -312,3 +314,57 @@ function generateOcrName({ filename, tagName, modelName, tagExtra, }) {
     const nameParts = [name, language, fileType].filter((p) => p && p !== "");
     return `OCR_${nameParts.map(cleanPart).join("_")}`;
 }
+function generateParakeetName({ filename, lowerPath, quantization, }) {
+    const lower = filename.toLowerCase();
+    // Detect model variant from registry path
+    let variant = "";
+    if (lowerPath.includes("parakeet-tdt") || lowerPath.includes("parakeet/")) {
+        variant = "TDT";
+    }
+    else if (lowerPath.includes("parakeet-ctc")) {
+        variant = "CTC";
+    }
+    else if (lowerPath.includes("eou") || lowerPath.includes("parakeet-rs")) {
+        variant = "EOU";
+    }
+    else if (lowerPath.includes("sortformer")) {
+        variant = "SORTFORMER";
+    }
+    // Detect file role from filename
+    let fileRole = "";
+    if (lower.includes("encoder") && (lower.endsWith(".data") || lower.endsWith(".onnx.data"))) {
+        fileRole = "ENCODER_DATA";
+    }
+    else if (lower.includes("encoder")) {
+        fileRole = "ENCODER";
+    }
+    else if (lower.includes("decoder")) {
+        fileRole = "DECODER";
+    }
+    else if (lower.includes("vocab")) {
+        fileRole = "VOCAB";
+    }
+    else if (lower.includes("tokenizer")) {
+        fileRole = "TOKENIZER";
+    }
+    else if (lower.includes("preprocessor") || lower.includes("nemo")) {
+        fileRole = "PREPROCESSOR";
+    }
+    else if (lower === "config.json") {
+        fileRole = "CONFIG";
+    }
+    else if (lower.endsWith(".onnx.data") || lower.endsWith(".onnx_data")) {
+        fileRole = "DATA";
+    }
+    else if (lower.includes("sortformer")) {
+        fileRole = "";
+    }
+    else if (lower.endsWith(".onnx") || lower.endsWith(".int8.onnx")) {
+        fileRole = "";
+    }
+    else {
+        fileRole = cleanPart(filename.replace(/\.\w+$/, ""));
+    }
+    const nameParts = [variant, fileRole, quantization].filter((p) => p && p !== "");
+    return `PARAKEET_${nameParts.map(cleanPart).join("_")}`;
+}

package/dist/profiling/aggregator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Accumulates profiling statistics and maintains a bounded buffer of recent events.
+ * Uses a ring buffer for O(1) event insertion.
+ */
+import type { ProfilingEvent, AggregatedStats } from "./types";
+export declare function createAggregator(maxRecentEvents?: number): void;
+export declare function recordEvent(event: ProfilingEvent, storeInBuffer?: boolean): void;
+export declare function getAggregates(): Record<string, AggregatedStats>;
+/** Returns events in chronological order (oldest first). */
+export declare function getRecentEvents(): ProfilingEvent[];
+export declare function getEventCount(): number;
+export declare function getDroppedCount(): number;
+export declare function clearAggregator(): void;
+export declare function setMaxRecentEvents(max: number): void;
+//# sourceMappingURL=aggregator.d.ts.map

package/dist/profiling/aggregator.js

@@ -0,0 +1,100 @@
+/**
+ * Accumulates profiling statistics and maintains a bounded buffer of recent events.
+ * Uses a ring buffer for O(1) event insertion.
+ */
+import { getGlobalSingleton } from "../utils/global-singleton.js";
+import { createRingBuffer, ringBufferPush, ringBufferToArray, ringBufferClear, ringBufferResize, ringBufferDroppedCount, } from "./ring-buffer.js";
+const DEFAULT_MAX_RECENT_EVENTS = 1000;
+const AGGREGATOR_STATE_KEY = Symbol.for("@qvac/sdk:profiler-aggregator-state");
+function getAggregatorState() {
+    return getGlobalSingleton(AGGREGATOR_STATE_KEY, () => {
+        return {
+            stats: new Map(),
+            eventBuffer: createRingBuffer(DEFAULT_MAX_RECENT_EVENTS),
+        };
+    });
+}
+export function createAggregator(maxRecentEvents = DEFAULT_MAX_RECENT_EVENTS) {
+    const state = getAggregatorState();
+    state.stats = new Map();
+    state.eventBuffer = createRingBuffer(maxRecentEvents);
+}
+function recordStats(key, value) {
+    const aggregator = getAggregatorState();
+    let statsState = aggregator.stats.get(key);
+    if (!statsState) {
+        statsState = {
+            count: 0,
+            min: Infinity,
+            max: -Infinity,
+            sum: 0,
+            last: 0,
+        };
+        aggregator.stats.set(key, statsState);
+    }
+    statsState.count++;
+    statsState.sum += value;
+    statsState.last = value;
+    if (value < statsState.min)
+        statsState.min = value;
+    if (value > statsState.max)
+        statsState.max = value;
+}
+function getStats(state) {
+    return {
+        count: state.count,
+        min: state.count > 0 ? state.min : 0,
+        max: state.count > 0 ? state.max : 0,
+        avg: state.count > 0 ? state.sum / state.count : 0,
+        sum: state.sum,
+        last: state.last,
+    };
+}
+export function recordEvent(event, storeInBuffer = true) {
+    const state = getAggregatorState();
+    if (storeInBuffer) {
+        ringBufferPush(state.eventBuffer, event);
+    }
+    if (event.ms !== undefined) {
+        const key = event.phase ? `${event.op}.${event.phase}` : event.op;
+        recordStats(key, event.ms);
+    }
+    if (event.gauges) {
+        const baseKey = event.phase ? `${event.op}.${event.phase}` : event.op;
+        for (const [gaugeName, value] of Object.entries(event.gauges)) {
+            recordStats(`${baseKey}.${gaugeName}`, value);
+        }
+    }
+}
+export function getAggregates() {
+    const state = getAggregatorState();
+    const result = {};
+    for (const [key, statsState] of state.stats) {
+        result[key] = getStats(statsState);
+    }
+    return result;
+}
+/** Returns events in chronological order (oldest first). */
+export function getRecentEvents() {
+    return ringBufferToArray(getAggregatorState().eventBuffer);
+}
+export function getEventCount() {
+    const state = getAggregatorState();
+    let total = 0;
+    for (const statsState of state.stats.values()) {
+        total += statsState.count;
+    }
+    return total;
+}
+export function getDroppedCount() {
+    return ringBufferDroppedCount(getAggregatorState().eventBuffer);
+}
+export function clearAggregator() {
+    const state = getAggregatorState();
+    state.stats.clear();
+    ringBufferClear(state.eventBuffer);
+}
+export function setMaxRecentEvents(max) {
+    const state = getAggregatorState();
+    state.eventBuffer = ringBufferResize(state.eventBuffer, max);
+}

package/dist/profiling/clock.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Runtime-safe monotonic clock for profiling.
+ * Priority: performance.now > process.hrtime > Date.now
+ */
+export type ClockSource = "performance" | "hrtime" | "date";
+export declare function getClockSource(): ClockSource;
+export declare function isMonotonic(): boolean;
+export declare function nowMs(): number;
+export declare function measureAsync<T>(fn: () => Promise<T>): Promise<[T, number]>;
+export declare function measureSync<T>(fn: () => T): [T, number];
+export declare function generateProfileId(): string;
+//# sourceMappingURL=clock.d.ts.map

package/dist/profiling/clock.js

@@ -0,0 +1,51 @@
+/**
+ * Runtime-safe monotonic clock for profiling.
+ * Priority: performance.now > process.hrtime > Date.now
+ */
+let clockSource;
+let nowMsImpl;
+// Detect and cache the best available clock source at module load
+if (typeof globalThis !== "undefined" &&
+    typeof globalThis.performance !== "undefined" &&
+    typeof globalThis.performance.now === "function") {
+    clockSource = "performance";
+    const perfNow = globalThis.performance.now.bind(globalThis.performance);
+    nowMsImpl = () => perfNow();
+}
+else if (typeof process !== "undefined" &&
+    typeof process.hrtime === "function" &&
+    typeof process.hrtime.bigint === "function") {
+    clockSource = "hrtime";
+    const hrtime = process.hrtime.bigint.bind(process.hrtime);
+    const startNs = hrtime();
+    nowMsImpl = () => Number(hrtime() - startNs) / 1_000_000;
+}
+else {
+    clockSource = "date";
+    const startMs = Date.now();
+    nowMsImpl = () => Date.now() - startMs;
+}
+export function getClockSource() {
+    return clockSource;
+}
+export function isMonotonic() {
+    return clockSource === "performance" || clockSource === "hrtime";
+}
+export function nowMs() {
+    return nowMsImpl();
+}
+export async function measureAsync(fn) {
+    const start = nowMs();
+    const result = await fn();
+    return [result, nowMs() - start];
+}
+export function measureSync(fn) {
+    const start = nowMs();
+    const result = fn();
+    return [result, nowMs() - start];
+}
+export function generateProfileId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `${timestamp}-${random}`;
+}

package/dist/profiling/controller.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Central state management for profiling enablement, configuration, and recording.
+ *
+ * Precedence (highest to lowest):
+ * 1. Per-call override
+ * 2. Runtime API (enable/disable)
+ * 3. Disabled default
+ */
+import type { ProfilerMode, PerCallProfiling } from "../schemas/index";
+import type { ProfilerRuntimeOptions, ProfilingEvent, AggregatedStats } from "./types";
+export interface ResolvedProfilerConfig {
+    enabled: boolean;
+    mode: ProfilerMode;
+    includeServerBreakdown: boolean;
+    operationFilters: string[];
+    maxRecentEvents: number;
+}
+type RecordCallback = (event: ProfilingEvent) => void;
+export declare function enable(options?: ProfilerRuntimeOptions): void;
+export declare function disable(): void;
+export declare function isEnabled(): boolean;
+export declare function getEffectiveConfig(): ResolvedProfilerConfig;
+export declare function shouldProfile(operation: string, perCallOptions?: PerCallProfiling): boolean;
+export declare function shouldIncludeServerBreakdown(perCallOptions?: PerCallProfiling): boolean;
+export declare function generateId(): string;
+export declare function record(event: ProfilingEvent): void;
+/** Returns unsubscribe function. */
+export declare function onRecord(callback: RecordCallback): () => void;
+export declare function getAggregates(): Record<string, AggregatedStats>;
+export declare function getRecentEvents(): ProfilingEvent[];
+export declare function clear(): void;
+export {};
+//# sourceMappingURL=controller.d.ts.map

package/dist/profiling/controller.js

@@ -0,0 +1,123 @@
+/**
+ * Central state management for profiling enablement, configuration, and recording.
+ *
+ * Precedence (highest to lowest):
+ * 1. Per-call override
+ * 2. Runtime API (enable/disable)
+ * 3. Disabled default
+ */
+import { getGlobalSingleton } from "../utils/global-singleton.js";
+import { createAggregator, recordEvent as aggregatorRecord, getAggregates as aggregatorGetAggregates, getRecentEvents as aggregatorGetRecentEvents, clearAggregator, setMaxRecentEvents, } from "./aggregator.js";
+import { nowMs, generateProfileId } from "./clock.js";
+const DEFAULT_CONFIG = {
+    enabled: false,
+    mode: "summary",
+    includeServerBreakdown: false,
+    operationFilters: [],
+    maxRecentEvents: 1000,
+};
+const CONTROLLER_STATE_KEY = Symbol.for("@qvac/sdk:profiler-controller-state");
+function getControllerState() {
+    const state = getGlobalSingleton(CONTROLLER_STATE_KEY, () => {
+        return {
+            runtimeOverride: undefined,
+            runtimeOptions: {},
+            onRecordCallbacks: [],
+            initialized: false,
+        };
+    });
+    if (!state.initialized) {
+        createAggregator(DEFAULT_CONFIG.maxRecentEvents);
+        state.initialized = true;
+    }
+    return state;
+}
+export function enable(options) {
+    const state = getControllerState();
+    state.runtimeOverride = true;
+    state.runtimeOptions = options ? { ...options } : {};
+    clearAggregator();
+    setMaxRecentEvents(DEFAULT_CONFIG.maxRecentEvents);
+}
+export function disable() {
+    const state = getControllerState();
+    state.runtimeOverride = false;
+    state.runtimeOptions = {};
+    setMaxRecentEvents(DEFAULT_CONFIG.maxRecentEvents);
+}
+export function isEnabled() {
+    const state = getControllerState();
+    return state.runtimeOverride ?? false;
+}
+export function getEffectiveConfig() {
+    const state = getControllerState();
+    return {
+        enabled: isEnabled(),
+        mode: state.runtimeOptions.mode ?? DEFAULT_CONFIG.mode,
+        includeServerBreakdown: state.runtimeOptions.includeServerBreakdown ??
+            DEFAULT_CONFIG.includeServerBreakdown,
+        operationFilters: [
+            ...(state.runtimeOptions.operationFilters ?? DEFAULT_CONFIG.operationFilters),
+        ],
+        maxRecentEvents: DEFAULT_CONFIG.maxRecentEvents,
+    };
+}
+export function shouldProfile(operation, perCallOptions) {
+    if (perCallOptions?.enabled !== undefined) {
+        return perCallOptions.enabled;
+    }
+    if (!isEnabled()) {
+        return false;
+    }
+    const config = getEffectiveConfig();
+    if (config.operationFilters.length > 0) {
+        return config.operationFilters.includes(operation);
+    }
+    return true;
+}
+export function shouldIncludeServerBreakdown(perCallOptions) {
+    if (perCallOptions?.includeServerBreakdown !== undefined) {
+        return perCallOptions.includeServerBreakdown;
+    }
+    return getEffectiveConfig().includeServerBreakdown;
+}
+export function generateId() {
+    return generateProfileId();
+}
+export function record(event) {
+    const state = getControllerState();
+    let eventWithTs = event;
+    if (event.ts === undefined) {
+        eventWithTs = { ...event, ts: nowMs() };
+    }
+    const storeInBuffer = getEffectiveConfig().mode === "verbose";
+    aggregatorRecord(eventWithTs, storeInBuffer);
+    for (const cb of state.onRecordCallbacks) {
+        try {
+            cb(eventWithTs);
+        }
+        catch {
+            // Callback errors should not break profiling
+        }
+    }
+}
+/** Returns unsubscribe function. */
+export function onRecord(callback) {
+    const state = getControllerState();
+    state.onRecordCallbacks.push(callback);
+    return () => {
+        const idx = state.onRecordCallbacks.indexOf(callback);
+        if (idx >= 0) {
+            state.onRecordCallbacks.splice(idx, 1);
+        }
+    };
+}
+export function getAggregates() {
+    return aggregatorGetAggregates();
+}
+export function getRecentEvents() {
+    return aggregatorGetRecentEvents();
+}
+export function clear() {
+    clearAggregator();
+}

package/dist/profiling/envelope.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Helpers to inject/extract __profiling metadata in RPC payloads.
+ */
+import { type ProfilingRequestMeta, type ProfilingResponseMeta } from "../schemas/index";
+export declare function createProfilingMeta(profileId: string, includeServerBreakdown: boolean): ProfilingRequestMeta;
+export declare function createProfilingDisabledMeta(): ProfilingRequestMeta;
+export declare function injectProfilingMetaIntoObject(obj: Record<string, unknown>, meta: ProfilingRequestMeta): Record<string, unknown>;
+export declare function extractProfilingMeta(payload: unknown): ProfilingResponseMeta | undefined;
+export declare function stripProfilingMeta<T extends object>(payload: T): T;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/profiling/envelope.js

@@ -0,0 +1,36 @@
+/**
+ * Helpers to inject/extract __profiling metadata in RPC payloads.
+ */
+import { PROFILING_KEY, } from "../schemas/index.js";
+export function createProfilingMeta(profileId, includeServerBreakdown) {
+    return {
+        enabled: true,
+        id: profileId,
+        includeServer: includeServerBreakdown,
+    };
+}
+export function createProfilingDisabledMeta() {
+    return { enabled: false };
+}
+export function injectProfilingMetaIntoObject(obj, meta) {
+    return { ...obj, [PROFILING_KEY]: meta };
+}
+export function extractProfilingMeta(payload) {
+    if (typeof payload === "object" &&
+        payload !== null &&
+        PROFILING_KEY in payload) {
+        const meta = payload[PROFILING_KEY];
+        if (typeof meta === "object" && meta !== null) {
+            return meta;
+        }
+    }
+    return undefined;
+}
+export function stripProfilingMeta(payload) {
+    if (PROFILING_KEY in payload) {
+        const { [PROFILING_KEY]: _unused, ...rest } = payload;
+        void _unused;
+        return rest;
+    }
+    return payload;
+}

package/dist/profiling/events.d.ts

@@ -0,0 +1,20 @@
+import type { ProfilingEventKind } from "./types";
+import type { ServerBreakdown, DelegationBreakdown } from "../schemas/index";
+export interface BaseTimings {
+    profileId: string;
+    requestType: string;
+    requestStart: number;
+}
+export interface BaseEvent {
+    ts: number;
+    op: string;
+    kind: ProfilingEventKind;
+    profileId: string;
+}
+export declare function recordPhase(base: BaseEvent, phase: string, ms?: number, extra?: {
+    count?: number;
+}): void;
+export declare function recordFailure(base: BaseEvent, startTime: number, error: unknown): void;
+export declare function recordServerBreakdownPhases(base: BaseEvent, server: ServerBreakdown, prefix?: string): void;
+export declare function recordDelegationBreakdownPhases(base: BaseEvent, delegation: DelegationBreakdown, prefix?: string): void;
+//# sourceMappingURL=events.d.ts.map

package/dist/profiling/events.js

@@ -0,0 +1,37 @@
+import { nowMs } from "./clock.js";
+import { record } from "./controller.js";
+export function recordPhase(base, phase, ms, extra) {
+    if (ms === undefined)
+        return;
+    record({ ...base, phase, ms, ...extra });
+}
+export function recordFailure(base, startTime, error) {
+    const now = nowMs();
+    record({
+        ...base,
+        ts: now,
+        phase: "failed",
+        ms: now - startTime,
+        tags: {
+            error: error instanceof Error ? error.name : "Unknown",
+            message: error instanceof Error
+                ? error.message.slice(0, 100)
+                : String(error).slice(0, 100),
+        },
+    });
+}
+export function recordServerBreakdownPhases(base, server, prefix = "server") {
+    recordPhase(base, `${prefix}.request.jsonParse`, server.requestJsonParseMs);
+    recordPhase(base, `${prefix}.request.zodValidation`, server.requestZodValidationMs);
+    recordPhase(base, `${prefix}.handlerExecution`, server.handlerExecutionMs);
+    recordPhase(base, `${prefix}.response.zodValidation`, server.responseZodValidationMs);
+    recordPhase(base, `${prefix}.response.stringify`, server.responseStringifyMs);
+    recordPhase(base, `${prefix}.totalServerTime`, server.totalServerMs);
+}
+export function recordDelegationBreakdownPhases(base, delegation, prefix = "delegation") {
+    recordPhase(base, `${prefix}.connection`, delegation.connectionMs);
+    recordPhase(base, `${prefix}.request.stringify`, delegation.requestStringifyMs);
+    recordPhase(base, `${prefix}.serverWait`, delegation.serverWaitMs);
+    recordPhase(base, `${prefix}.response.jsonParse`, delegation.responseJsonParseMs);
+    recordPhase(base, `${prefix}.totalDelegationTime`, delegation.totalDelegationMs);
+}