@qvac/sdk 0.8.1 → 1.1.0

package/dist/server/rpc/profiling/operation-metrics.js

@@ -1,199 +0,0 @@
-/**
- * Declarative extraction of operation-level metrics from request/response data.
- * Used by operation wrappers to capture handler-specific profiling events.
- */
-const metricsRegistry = new Map();
-function extractDownloadStatsGauges(stats, gauges) {
-    if (stats?.downloadTimeMs !== undefined) {
-        gauges["downloadTime"] = stats.downloadTimeMs;
-    }
-    if (stats?.totalBytesDownloaded !== undefined) {
-        gauges["totalBytesDownloaded"] = stats.totalBytesDownloaded;
-    }
-    if (stats?.downloadSpeedBps !== undefined) {
-        gauges["downloadSpeedBps"] = stats.downloadSpeedBps;
-    }
-}
-export function registerOperationMetrics(config) {
-    metricsRegistry.set(config.op, config);
-}
-export function buildOperationEvent(op, profileId, ts, executionMs, request, finalResponse, ttfb) {
-    const config = metricsRegistry.get(op);
-    if (!config) {
-        return {
-            ts,
-            op,
-            kind: "handler",
-            profileId,
-            ms: executionMs,
-        };
-    }
-    const gauges = {};
-    if (ttfb !== undefined) {
-        gauges["ttfb"] = ttfb;
-    }
-    if (config.fromRequest && request) {
-        const extracted = config.fromRequest(request);
-        if (extracted)
-            Object.assign(gauges, extracted);
-    }
-    if (config.fromFinalChunk && finalResponse) {
-        const extracted = config.fromFinalChunk(finalResponse);
-        if (extracted)
-            Object.assign(gauges, extracted);
-    }
-    if (config.fromResult && finalResponse) {
-        const extracted = config.fromResult(finalResponse);
-        if (extracted)
-            Object.assign(gauges, extracted);
-    }
-    const requestTags = config.getTags?.(request);
-    const resultTags = config.getTagsFromResult?.(finalResponse);
-    const tags = { ...requestTags, ...resultTags };
-    const hasGauges = Object.keys(gauges).length > 0;
-    const hasTags = Object.keys(tags).length > 0;
-    const event = {
-        ts,
-        op: config.op,
-        kind: config.kind,
-        profileId,
-        ms: executionMs,
-    };
-    if (hasGauges) {
-        event.gauges = gauges;
-    }
-    if (hasTags) {
-        event.tags = tags;
-    }
-    return event;
-}
-registerOperationMetrics({
-    op: "completionStream",
-    kind: "handler",
-    getTags: (req) => (req.modelId ? { modelId: req.modelId } : {}),
-    fromFinalChunk: (res) => {
-        if (!res.stats)
-            return undefined;
-        const gauges = {};
-        if (res.stats.timeToFirstToken !== undefined)
-            gauges["timeToFirstToken"] = res.stats.timeToFirstToken;
-        if (res.stats.tokensPerSecond !== undefined)
-            gauges["tokensPerSecond"] = res.stats.tokensPerSecond;
-        if (res.stats.cacheTokens !== undefined)
-            gauges["cacheTokens"] = res.stats.cacheTokens;
-        return Object.keys(gauges).length > 0 ? gauges : undefined;
-    },
-});
-registerOperationMetrics({
-    op: "translate",
-    kind: "handler",
-    getTags: (req) => (req.modelId ? { modelId: req.modelId } : {}),
-    fromFinalChunk: (res) => {
-        if (!res.stats)
-            return undefined;
-        const gauges = {};
-        if (res.stats.processedTokens !== undefined)
-            gauges["processedTokens"] = res.stats.processedTokens;
-        if (res.stats.processingTime !== undefined)
-            gauges["processingTime"] = res.stats.processingTime;
-        return Object.keys(gauges).length > 0 ? gauges : undefined;
-    },
-});
-registerOperationMetrics({
-    op: "transcribeStream",
-    kind: "handler",
-    getTags: (req) => (req.modelId ? { modelId: req.modelId } : {}),
-});
-registerOperationMetrics({
-    op: "textToSpeech",
-    kind: "handler",
-    getTags: (req) => (req.modelId ? { modelId: req.modelId } : {}),
-});
-registerOperationMetrics({
-    op: "embed",
-    kind: "handler",
-    getTags: (req) => (req.modelId ? { modelId: req.modelId } : {}),
-});
-registerOperationMetrics({
-    op: "ocrStream",
-    kind: "handler",
-    getTags: (req) => (req.modelId ? { modelId: req.modelId } : {}),
-    fromFinalChunk: (res) => {
-        if (!res.stats)
-            return undefined;
-        const gauges = {};
-        if (res.stats.detectionTime !== undefined)
-            gauges["detectionTime"] = res.stats.detectionTime;
-        if (res.stats.recognitionTime !== undefined)
-            gauges["recognitionTime"] = res.stats.recognitionTime;
-        if (res.stats.totalTime !== undefined)
-            gauges["totalTime"] = res.stats.totalTime;
-        return Object.keys(gauges).length > 0 ? gauges : undefined;
-    },
-});
-registerOperationMetrics({
-    op: "pluginInvoke",
-    kind: "handler",
-    getTags: (req) => {
-        const tags = {};
-        if (req.modelId)
-            tags["modelId"] = req.modelId;
-        if (req.handler)
-            tags["handler"] = req.handler;
-        return tags;
-    },
-});
-registerOperationMetrics({
-    op: "pluginInvokeStream",
-    kind: "handler",
-    getTags: (req) => {
-        const tags = {};
-        if (req.modelId)
-            tags["modelId"] = req.modelId;
-        if (req.handler)
-            tags["handler"] = req.handler;
-        return tags;
-    },
-});
-registerOperationMetrics({
-    op: "loadModel",
-    kind: "handler",
-    getTags: (req) => (req.modelType ? { modelType: req.modelType } : {}),
-    getTagsFromResult: (res) => {
-        const sourceType = res.__profilingMeta?.sourceType;
-        return sourceType ? { sourceType } : undefined;
-    },
-    fromResult: (res) => {
-        const meta = res.__profilingMeta;
-        if (!meta)
-            return undefined;
-        const gauges = {};
-        extractDownloadStatsGauges(meta.downloadStats, gauges);
-        if (meta.modelInitializationTimeMs !== undefined) {
-            gauges["modelInitializationTime"] = meta.modelInitializationTimeMs;
-        }
-        if (meta.totalLoadTimeMs !== undefined) {
-            gauges["totalLoadTime"] = meta.totalLoadTimeMs;
-        }
-        return Object.keys(gauges).length > 0 ? gauges : undefined;
-    },
-});
-registerOperationMetrics({
-    op: "downloadAsset",
-    kind: "handler",
-    getTagsFromResult: (res) => {
-        const sourceType = res.__profilingMeta?.sourceType;
-        return sourceType ? { sourceType } : undefined;
-    },
-    fromResult: (res) => {
-        const meta = res.__profilingMeta;
-        if (!meta)
-            return undefined;
-        const gauges = {};
-        extractDownloadStatsGauges(meta.downloadStats, gauges);
-        if (meta.totalDownloadTimeMs !== undefined) {
-            gauges["totalDownloadTime"] = meta.totalDownloadTimeMs;
-        }
-        return Object.keys(gauges).length > 0 ? gauges : undefined;
-    },
-});

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

@@ -1,18 +0,0 @@
-/**
- * Generic wrappers for profiling handler execution.
- * Used to wrap dispatch/invoke functions with timing capture.
- */
-import { type PerCallProfiling } from "../../../schemas/index";
-export interface ProfiledReplyOptions<TRequest> {
-    op: string;
-    request: TRequest;
-    perCall?: PerCallProfiling;
-}
-export interface ProfiledStreamOptions<TRequest> {
-    op: string;
-    request: TRequest;
-    perCall?: PerCallProfiling;
-}
-export declare function profileReplyHandler<TRequest, TResponse>(options: ProfiledReplyOptions<TRequest>, handler: () => Promise<TResponse>): Promise<TResponse>;
-export declare function profileStreamHandler<TRequest, TResponse>(options: ProfiledStreamOptions<TRequest>, handler: () => AsyncGenerator<TResponse>): AsyncGenerator<TResponse>;
-//# sourceMappingURL=operation-wrappers.d.ts.map

package/dist/server/rpc/profiling/operation-wrappers.js

@@ -1,124 +0,0 @@
-/**
- * Generic wrappers for profiling handler execution.
- * Used to wrap dispatch/invoke functions with timing capture.
- */
-import { PROFILING_KEY, } from "../../../schemas/index.js";
-import { nowMs, generateProfileId } from "../../../profiling/clock.js";
-import { record, shouldProfile } from "../../../profiling/controller.js";
-import { buildOperationEvent } from "./operation-metrics.js";
-function getRequestProfilingMeta(request) {
-    if (!request || typeof request !== "object") {
-        return undefined;
-    }
-    const meta = request[PROFILING_KEY];
-    if (!meta || typeof meta !== "object") {
-        return undefined;
-    }
-    return meta;
-}
-function resolvePerCallProfiling(options) {
-    if (options.perCall) {
-        return options.perCall;
-    }
-    const meta = getRequestProfilingMeta(options.request);
-    if (!meta) {
-        return undefined;
-    }
-    if (meta.enabled === false) {
-        return { enabled: false };
-    }
-    return {
-        enabled: true,
-        includeServerBreakdown: meta.includeServer,
-        mode: meta.mode,
-    };
-}
-function recordOperationEvent(params) {
-    const event = buildOperationEvent(params.options.op, params.profileId, params.startTs, params.executionMs, params.options.request, params.finalResponse, params.ttfb);
-    if (!event)
-        return;
-    if (params.errored) {
-        event.tags = { ...event.tags, error: "true" };
-    }
-    if (params.count !== undefined && params.count > 0) {
-        event.count = params.count;
-    }
-    record(event);
-}
-export async function profileReplyHandler(options, handler) {
-    const perCall = resolvePerCallProfiling(options);
-    if (!shouldProfile(options.op, perCall)) {
-        return handler();
-    }
-    const profileId = generateProfileId();
-    const startTs = nowMs();
-    try {
-        const result = await handler();
-        const executionMs = nowMs() - startTs;
-        recordOperationEvent({
-            options,
-            profileId,
-            startTs,
-            executionMs,
-            finalResponse: result,
-        });
-        return result;
-    }
-    catch (error) {
-        const executionMs = nowMs() - startTs;
-        recordOperationEvent({
-            options,
-            profileId,
-            startTs,
-            executionMs,
-            errored: true,
-        });
-        throw error;
-    }
-}
-export async function* profileStreamHandler(options, handler) {
-    const perCall = resolvePerCallProfiling(options);
-    if (!shouldProfile(options.op, perCall)) {
-        yield* handler();
-        return;
-    }
-    const profileId = generateProfileId();
-    const startTs = nowMs();
-    let ttfb;
-    let lastChunk;
-    let chunkCount = 0;
-    try {
-        for await (const chunk of handler()) {
-            if (ttfb === undefined) {
-                ttfb = nowMs() - startTs;
-            }
-            chunkCount++;
-            lastChunk = chunk;
-            yield chunk;
-        }
-        const executionMs = nowMs() - startTs;
-        recordOperationEvent({
-            options,
-            profileId,
-            startTs,
-            executionMs,
-            finalResponse: lastChunk,
-            ttfb,
-            count: chunkCount,
-        });
-    }
-    catch (error) {
-        const executionMs = nowMs() - startTs;
-        recordOperationEvent({
-            options,
-            profileId,
-            startTs,
-            executionMs,
-            finalResponse: lastChunk,
-            ttfb,
-            count: chunkCount,
-            errored: true,
-        });
-        throw error;
-    }
-}

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

@@ -1,13 +0,0 @@
-import { type Response, type ProfilingRequestMeta } from "../../../schemas/index";
-import { type ServerProfilingContext } from "./context";
-export type ServerProfiler = {
-    markRequestParsed: (ms: number) => void;
-    markRequestValidated: (ms: number) => void;
-    startHandler: () => void;
-    endHandler: () => void;
-    serialize: (response?: Response, final?: boolean) => string;
-    serializeError: (json: string) => string;
-    getContext: () => ServerProfilingContext | undefined;
-};
-export declare function createServerProfiler(meta?: ProfilingRequestMeta): ServerProfiler;
-//# sourceMappingURL=profiler.d.ts.map

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

@@ -1,97 +0,0 @@
-import { nowMs } from "../../../profiling/index.js";
-import { responseSchema, DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, PROFILING_TRAILER_KEY, } from "../../../schemas/index.js";
-import { createProfilingContext, injectProfilingIntoString, } from "./context.js";
-const noopProfiler = {
-    markRequestParsed: () => { },
-    markRequestValidated: () => { },
-    startHandler: () => { },
-    endHandler: () => { },
-    serialize: (response) => {
-        if (!response)
-            return "";
-        const extended = response;
-        const delegation = extended[DELEGATION_BREAKDOWN_KEY];
-        const operation = extended[OPERATION_EVENT_KEY];
-        const json = JSON.stringify(responseSchema.parse(response));
-        if (delegation || operation) {
-            const opts = {};
-            if (delegation)
-                opts.delegation = delegation;
-            if (operation)
-                opts.operation = operation;
-            return injectProfilingIntoString(json, opts);
-        }
-        return json;
-    },
-    serializeError: (json) => json,
-    getContext: () => undefined,
-};
-function createActiveProfiler(meta) {
-    const ctx = createProfilingContext(meta);
-    let handlerStart = 0;
-    let handlerEnded = false;
-    let cachedDelegation;
-    let cachedOperation;
-    return {
-        markRequestParsed: (ms) => {
-            ctx.jsonParseMs = ms;
-        },
-        markRequestValidated: (ms) => {
-            ctx.zodValidationMs = ms;
-        },
-        startHandler: () => {
-            handlerStart = nowMs();
-            handlerEnded = false;
-        },
-        endHandler: () => {
-            if (handlerEnded)
-                return;
-            handlerEnded = true;
-            ctx.handlerExecutionMs = nowMs() - handlerStart;
-        },
-        serialize: (response, final = true) => {
-            if (!response) {
-                const opts = { ctx };
-                if (cachedDelegation)
-                    opts.delegation = cachedDelegation;
-                if (cachedOperation)
-                    opts.operation = cachedOperation;
-                return injectProfilingIntoString(`{"${PROFILING_TRAILER_KEY}":true}`, opts);
-            }
-            const extended = response;
-            const delegation = extended[DELEGATION_BREAKDOWN_KEY];
-            const operation = extended[OPERATION_EVENT_KEY];
-            if (delegation)
-                cachedDelegation = delegation;
-            if (operation)
-                cachedOperation = operation;
-            const zodStart = nowMs();
-            const validated = responseSchema.parse(response);
-            ctx.responseZodValidationMs =
-                (ctx.responseZodValidationMs ?? 0) + (nowMs() - zodStart);
-            const stringifyStart = nowMs();
-            const json = JSON.stringify(validated);
-            ctx.responseStringifyMs =
-                (ctx.responseStringifyMs ?? 0) + (nowMs() - stringifyStart);
-            if (final) {
-                const opts = { ctx };
-                if (delegation)
-                    opts.delegation = delegation;
-                if (operation)
-                    opts.operation = operation;
-                return injectProfilingIntoString(json, opts);
-            }
-            return json;
-        },
-        serializeError: (json) => injectProfilingIntoString(json, { ctx }),
-        getContext: () => ctx,
-    };
-}
-export function createServerProfiler(meta) {
-    if (meta?.includeServer &&
-        typeof meta.id === "string" &&
-        meta.id.length > 0) {
-        return createActiveProfiler(meta);
-    }
-    return noopProfiler;
-}

package/dist/server/utils/archive.d.ts

@@ -1,4 +0,0 @@
-export declare function isArchiveUrl(url: string): boolean;
-export declare function extractTarStream(archivePath: string, extractDir: string, useGunzip: boolean, signal?: AbortSignal): Promise<void>;
-export declare function extractAndValidateShardedArchive(archivePath: string, extractDir: string, signal?: AbortSignal): Promise<string>;
-//# sourceMappingURL=archive.d.ts.map

package/dist/server/utils/archive.js

@@ -1,179 +0,0 @@
-import { promises as fsPromises } from "bare-fs";
-import path from "bare-path";
-import fs from "bare-fs";
-import { createGunzip } from "bare-zlib";
-import tarStream from "tar-stream";
-import { detectShardedModel, generateShardFilenames, extractTensorsFromShards, validateShardedModelCache, } from "./shard-utils.js";
-import { ModelLoadFailedError, ArchiveExtractionFailedError, ArchiveUnsupportedTypeError, ArchiveMissingShardsError, DownloadCancelledError, } from "../../utils/errors-server.js";
-import { isPathWithinBase } from "./path-security.js";
-import { getServerLogger } from "../../logging/index.js";
-import { SUPPORTED_ARCHIVE_EXTENSIONS, filenameToArchiveTypeSchema, } from "../../schemas/archive.js";
-const logger = getServerLogger();
-// Gzip magic bytes: 1f 8b 08
-const GZIP_MAGIC_0 = 0x1f;
-const GZIP_MAGIC_1 = 0x8b;
-const GZIP_MAGIC_2 = 0x08;
-export function isArchiveUrl(url) {
-    const filename = url.split("/").pop()?.split("?")[0]?.toLowerCase() || "";
-    return SUPPORTED_ARCHIVE_EXTENSIONS.some((ext) => filename.endsWith(ext));
-}
-// Whitelist of model file extensions to extract from archives
-const ALLOWED_MODEL_EXTENSIONS = [".gguf", ".tensors.txt"];
-function isModelFile(entryName) {
-    const basename = path.basename(entryName);
-    // Skip resource forks (._filename)
-    if (basename.startsWith("._")) {
-        return false;
-    }
-    return ALLOWED_MODEL_EXTENSIONS.some((ext) => basename.toLowerCase().endsWith(ext));
-}
-async function isGzip(archivePath) {
-    return new Promise((resolve, reject) => {
-        const stream = fs.createReadStream(archivePath, { start: 0, end: 2 });
-        const chunks = [];
-        stream.on("data", (chunk) => {
-            chunks.push(chunk);
-        });
-        stream.on("end", () => {
-            stream.destroy();
-            const buffer = Buffer.concat(chunks);
-            // Check for gzip magic bytes
-            const isGzipped = buffer[0] === GZIP_MAGIC_0 &&
-                buffer[1] === GZIP_MAGIC_1 &&
-                buffer[2] === GZIP_MAGIC_2;
-            resolve(isGzipped);
-        });
-        stream.on("error", reject);
-    });
-}
-async function extractArchive(archivePath, extractDir, signal) {
-    const parseResult = filenameToArchiveTypeSchema.safeParse(archivePath);
-    const extensionType = parseResult.success ? parseResult.data : null;
-    if (!extensionType) {
-        throw new ArchiveUnsupportedTypeError(archivePath);
-    }
-    if (signal?.aborted) {
-        throw new DownloadCancelledError();
-    }
-    // Detect actual format from magic bytes (extension might be wrong)
-    const isGzipped = await isGzip(archivePath);
-    const actualType = isGzipped ? "tar.gz" : "tar";
-    if (actualType !== extensionType) {
-        logger.warn(`⚠️ Archive extension suggests ${extensionType} but content is ${actualType}`);
-    }
-    await fsPromises.mkdir(extractDir, { recursive: true });
-    await extractTarStream(archivePath, extractDir, isGzipped, signal);
-}
-export async function extractTarStream(archivePath, extractDir, useGunzip, signal) {
-    const extract = tarStream.extract();
-    const gunzip = useGunzip ? createGunzip() : null;
-    return new Promise((resolve, reject) => {
-        let aborted = false;
-        let readStream = null;
-        const cleanup = () => {
-            aborted = true;
-            readStream?.destroy();
-            gunzip?.destroy();
-            extract.destroy();
-        };
-        if (signal) {
-            signal.addEventListener("abort", () => {
-                cleanup();
-                reject(new DownloadCancelledError());
-            });
-        }
-        extract.on("entry", (header, stream, next) => {
-            if (aborted) {
-                stream.resume();
-                return;
-            }
-            if (!isModelFile(header.name)) {
-                stream.resume();
-                next();
-                return;
-            }
-            // Prevent zip-slip: reject entries that escape extractDir (CWE-22)
-            const filePath = path.resolve(path.join(extractDir, header.name));
-            if (!isPathWithinBase(extractDir, filePath)) {
-                logger.warn(`⚠️ Skipping archive entry with path traversal: ${header.name}`);
-                stream.resume();
-                next();
-                return;
-            }
-            if (header.type === "file") {
-                const dir = path.dirname(filePath);
-                fs.mkdirSync(dir, { recursive: true });
-                const writeStream = fs.createWriteStream(filePath);
-                stream.pipe(writeStream);
-                writeStream.on("finish", next);
-                writeStream.on("error", reject);
-            }
-            else {
-                stream.on("end", next);
-                stream.resume();
-            }
-        });
-        extract.on("finish", resolve);
-        extract.on("error", reject);
-        if (gunzip) {
-            gunzip.on("error", reject);
-        }
-        readStream = fs.createReadStream(archivePath);
-        if (gunzip) {
-            readStream.pipe(gunzip).pipe(extract);
-        }
-        else {
-            readStream.pipe(extract);
-        }
-    });
-}
-export async function extractAndValidateShardedArchive(archivePath, extractDir, signal) {
-    // Check if shards already extracted
-    try {
-        const existingFiles = await fsPromises.readdir(extractDir);
-        const existingShard = existingFiles.find((f) => detectShardedModel(String(f)).isSharded);
-        if (existingShard) {
-            const isComplete = await validateShardedModelCache(extractDir, String(existingShard));
-            if (isComplete) {
-                logger.info(`✅ Archive already extracted: ${extractDir}`);
-                const shardFilenames = generateShardFilenames(String(existingShard));
-                return path.join(extractDir, shardFilenames[0]);
-            }
-            logger.warn(`⚠️ Incomplete extraction found, re-extracting archive`);
-        }
-    }
-    catch {
-        // Directory doesn't exist, proceed with extraction
-    }
-    logger.info(`Extracting archive: ${path.basename(archivePath)}`);
-    try {
-        await extractArchive(archivePath, extractDir, signal);
-    }
-    catch (error) {
-        throw new ArchiveExtractionFailedError(archivePath, error);
-    }
-    const files = await fsPromises.readdir(extractDir);
-    const shardedFile = files.find((f) => detectShardedModel(String(f)).isSharded);
-    if (!shardedFile) {
-        throw new ModelLoadFailedError(`No sharded model files found in archive. Expected pattern: *-00001-of-0000X.*`);
-    }
-    const shardedFileName = String(shardedFile);
-    const shardInfo = detectShardedModel(shardedFileName);
-    if (!shardInfo.baseFilename) {
-        throw new ModelLoadFailedError(`Could not extract base filename from sharded model: ${shardedFileName}`);
-    }
-    const shardFilenames = generateShardFilenames(shardedFileName);
-    for (const shardFilename of shardFilenames) {
-        const filePath = path.join(extractDir, shardFilename);
-        try {
-            await fsPromises.access(filePath);
-        }
-        catch {
-            throw new ArchiveMissingShardsError(shardFilename);
-        }
-    }
-    // Generate tensors.txt if it doesn't exist
-    await extractTensorsFromShards(extractDir, shardedFileName);
-    logger.info(`Archive extracted to ${extractDir} successfully: ${files.length} files`);
-    return path.join(extractDir, shardFilenames[0]);
-}

package/dist/server/utils/checksum.d.ts

@@ -1,4 +0,0 @@
-import type { DownloadMetricsHooks } from "../rpc/handlers/load-model/types";
-export declare function calculateFileChecksum(filePath: string): Promise<string>;
-export declare function measureChecksum(filePath: string, hooks?: DownloadMetricsHooks): Promise<string>;
-//# sourceMappingURL=checksum.d.ts.map

package/dist/server/utils/checksum.js

@@ -1,31 +0,0 @@
-import fs from "bare-fs";
-import crypto from "bare-crypto";
-import { nowMs } from "../../profiling/index.js";
-export async function calculateFileChecksum(filePath) {
-    return new Promise((resolve, reject) => {
-        try {
-            const hash = crypto.createHash("sha256");
-            const stream = fs.createReadStream(filePath);
-            stream.on("data", (chunk) => {
-                hash.update(chunk);
-            });
-            stream.on("end", () => {
-                resolve(hash.digest("hex"));
-            });
-            stream.on("error", (error) => {
-                reject(new Error(`Checksum calculation error: ${error.message}`));
-            });
-        }
-        catch (error) {
-            reject(error instanceof Error
-                ? error
-                : new Error(`Checksum calculation error: ${String(error)}`));
-        }
-    });
-}
-export async function measureChecksum(filePath, hooks) {
-    const start = nowMs();
-    const checksum = await calculateFileChecksum(filePath);
-    hooks?.addChecksumValidationTimeMs(nowMs() - start);
-    return checksum;
-}

package/dist/server/utils/config-transform.d.ts

@@ -1,3 +0,0 @@
-import { type ModelTypeInput } from "../../schemas/index";
-export declare function transformConfigForReload(modelType: ModelTypeInput, config: unknown): unknown;
-//# sourceMappingURL=config-transform.d.ts.map