ydb-qdrant 5.2.1 → 7.0.1

package/dist/repositories/pointsRepo.one-table.js

@@ -1,403 +1,3 @@
-import { TypedValues, Types, withSession, createExecuteQuerySettings, createExecuteQuerySettingsWithTimeout, } from "../ydb/client.js";
-import { buildVectorParam, buildVectorBinaryParams } from "../ydb/helpers.js";
-import { mapDistanceToKnnFn, mapDistanceToBitKnnFn, } from "../utils/distance.js";
-import { withRetry, isTransientYdbError } from "../utils/retry.js";
-import { UPSERT_BATCH_SIZE } from "../ydb/schema.js";
-import { CLIENT_SIDE_SERIALIZATION_ENABLED, SearchMode, UPSERT_OPERATION_TIMEOUT_MS, SEARCH_OPERATION_TIMEOUT_MS, } from "../config/env.js";
-import { logger } from "../logging/logger.js";
-export async function upsertPointsOneTable(tableName, points, dimension, uid) {
-    for (const p of points) {
-        const id = String(p.id);
-        if (p.vector.length !== dimension) {
-            const previewLength = Math.min(16, p.vector.length);
-            const vectorPreview = previewLength > 0 ? p.vector.slice(0, previewLength) : [];
-            logger.warn({
-                tableName,
-                uid,
-                pointId: id,
-                vectorLen: p.vector.length,
-                expectedDimension: dimension,
-                vectorPreview,
-            }, "upsertPointsOneTable: vector dimension mismatch");
-            throw new Error(`Vector dimension mismatch for id=${id}: got ${p.vector.length}, expected ${dimension}`);
-        }
-    }
-    let upserted = 0;
-    await withSession(async (s) => {
-        const settings = createExecuteQuerySettingsWithTimeout({
-            keepInCache: true,
-            idempotent: true,
-            timeoutMs: UPSERT_OPERATION_TIMEOUT_MS,
-        });
-        for (let i = 0; i < points.length; i += UPSERT_BATCH_SIZE) {
-            const batch = points.slice(i, i + UPSERT_BATCH_SIZE);
-            let ddl;
-            let params;
-            if (CLIENT_SIDE_SERIALIZATION_ENABLED) {
-                ddl = `
-          DECLARE $rows AS List<Struct<
-            uid: Utf8,
-            point_id: Utf8,
-            embedding: String,
-            embedding_quantized: String,
-            payload: JsonDocument
-          >>;
-
-          UPSERT INTO ${tableName} (uid, point_id, embedding, embedding_quantized, payload)
-          SELECT
-            uid,
-            point_id,
-            embedding,
-            embedding_quantized,
-            payload
-          FROM AS_TABLE($rows);
-        `;
-                const rowType = Types.struct({
-                    uid: Types.UTF8,
-                    point_id: Types.UTF8,
-                    embedding: Types.BYTES,
-                    embedding_quantized: Types.BYTES,
-                    payload: Types.JSON_DOCUMENT,
-                });
-                const rowsValue = TypedValues.list(rowType, batch.map((p) => {
-                    const binaries = buildVectorBinaryParams(p.vector);
-                    return {
-                        uid,
-                        point_id: String(p.id),
-                        embedding: binaries.float,
-                        embedding_quantized: binaries.bit,
-                        payload: JSON.stringify(p.payload ?? {}),
-                    };
-                }));
-                params = {
-                    $rows: rowsValue,
-                };
-            }
-            else {
-                ddl = `
-          DECLARE $rows AS List<Struct<
-            uid: Utf8,
-            point_id: Utf8,
-            vec: List<Float>,
-            payload: JsonDocument
-          >>;
-
-          UPSERT INTO ${tableName} (uid, point_id, embedding, embedding_quantized, payload)
-          SELECT
-            uid,
-            point_id,
-            Untag(Knn::ToBinaryStringFloat(vec), "FloatVector") AS embedding,
-            Untag(Knn::ToBinaryStringBit(vec), "BitVector") AS embedding_quantized,
-            payload
-          FROM AS_TABLE($rows);
-        `;
-                const rowType = Types.struct({
-                    uid: Types.UTF8,
-                    point_id: Types.UTF8,
-                    vec: Types.list(Types.FLOAT),
-                    payload: Types.JSON_DOCUMENT,
-                });
-                const rowsValue = TypedValues.list(rowType, batch.map((p) => ({
-                    uid,
-                    point_id: String(p.id),
-                    vec: p.vector,
-                    payload: JSON.stringify(p.payload ?? {}),
-                })));
-                params = {
-                    $rows: rowsValue,
-                };
-            }
-            logger.debug({
-                tableName,
-                mode: CLIENT_SIDE_SERIALIZATION_ENABLED
-                    ? "one_table_upsert_client_side_serialization"
-                    : "one_table_upsert_server_side_knn",
-                batchSize: batch.length,
-                yql: ddl,
-                params: {
-                    rows: batch.map((p) => ({
-                        uid,
-                        point_id: String(p.id),
-                        vectorLength: p.vector.length,
-                        vectorPreview: p.vector.slice(0, 3),
-                        payload: p.payload ?? {},
-                    })),
-                },
-            }, "one_table upsert: executing YQL");
-            await withRetry(() => s.executeQuery(ddl, params, undefined, settings), {
-                isTransient: isTransientYdbError,
-                context: { tableName, batchSize: batch.length },
-            });
-            upserted += batch.length;
-        }
-    });
-    return upserted;
-}
-async function searchPointsOneTableExact(tableName, queryVector, top, withPayload, distance, dimension, uid) {
-    if (queryVector.length !== dimension) {
-        throw new Error(`Vector dimension mismatch: got ${queryVector.length}, expected ${dimension}`);
-    }
-    const { fn, order } = mapDistanceToKnnFn(distance);
-    const results = await withSession(async (s) => {
-        let yql;
-        let params;
-        if (CLIENT_SIDE_SERIALIZATION_ENABLED) {
-            const binaries = buildVectorBinaryParams(queryVector);
-            yql = `
-        DECLARE $qbinf AS String;
-        DECLARE $k AS Uint32;
-        DECLARE $uid AS Utf8;
-        SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
-        FROM ${tableName}
-        WHERE uid = $uid
-        ORDER BY score ${order}
-        LIMIT $k;
-      `;
-            params = {
-                $qbinf: typeof TypedValues.bytes === "function"
-                    ? TypedValues.bytes(binaries.float)
-                    : binaries.float,
-                $k: TypedValues.uint32(top),
-                $uid: TypedValues.utf8(uid),
-            };
-        }
-        else {
-            const qf = buildVectorParam(queryVector);
-            yql = `
-        DECLARE $qf AS List<Float>;
-        DECLARE $k AS Uint32;
-        DECLARE $uid AS Utf8;
-        $qbinf = Knn::ToBinaryStringFloat($qf);
-        SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
-        FROM ${tableName}
-        WHERE uid = $uid
-        ORDER BY score ${order}
-        LIMIT $k;
-      `;
-            params = {
-                $qf: qf,
-                $k: TypedValues.uint32(top),
-                $uid: TypedValues.utf8(uid),
-            };
-        }
-        logger.debug({
-            tableName,
-            distance,
-            top,
-            withPayload,
-            mode: CLIENT_SIDE_SERIALIZATION_ENABLED
-                ? "one_table_exact_client_side_serialization"
-                : "one_table_exact",
-            yql,
-            params: {
-                uid,
-                top,
-                vectorLength: queryVector.length,
-                vectorPreview: queryVector.slice(0, 3),
-            },
-        }, "one_table search (exact): executing YQL");
-        const settings = createExecuteQuerySettingsWithTimeout({
-            keepInCache: true,
-            idempotent: true,
-            timeoutMs: SEARCH_OPERATION_TIMEOUT_MS,
-        });
-        const rs = await s.executeQuery(yql, params, undefined, settings);
-        const rowset = rs.resultSets?.[0];
-        const rows = (rowset?.rows ?? []);
-        return rows.map((row) => {
-            const id = row.items?.[0]?.textValue;
-            if (typeof id !== "string") {
-                throw new Error("point_id is missing in YDB search result");
-            }
-            let payload;
-            let scoreIdx = 1;
-            if (withPayload) {
-                const payloadText = row.items?.[1]?.textValue;
-                if (payloadText) {
-                    try {
-                        payload = JSON.parse(payloadText);
-                    }
-                    catch {
-                        payload = undefined;
-                    }
-                }
-                scoreIdx = 2;
-            }
-            const score = Number(row.items?.[scoreIdx]?.floatValue ?? row.items?.[scoreIdx]?.textValue);
-            return { id, score, ...(payload ? { payload } : {}) };
-        });
-    });
-    return results;
-}
-async function searchPointsOneTableApproximate(tableName, queryVector, top, withPayload, distance, dimension, uid, overfetchMultiplier) {
-    if (queryVector.length !== dimension) {
-        throw new Error(`Vector dimension mismatch: got ${queryVector.length}, expected ${dimension}`);
-    }
-    const { fn, order } = mapDistanceToKnnFn(distance);
-    const { fn: bitFn, order: bitOrder } = mapDistanceToBitKnnFn(distance);
-    const safeTop = top > 0 ? top : 1;
-    const rawCandidateLimit = safeTop * overfetchMultiplier;
-    const candidateLimit = Math.max(safeTop, rawCandidateLimit);
-    const results = await withSession(async (s) => {
-        let yql;
-        let params;
-        if (CLIENT_SIDE_SERIALIZATION_ENABLED) {
-            const binaries = buildVectorBinaryParams(queryVector);
-            yql = `
-        DECLARE $qbin_bit AS String;
-        DECLARE $qbinf AS String;
-        DECLARE $candidateLimit AS Uint32;
-        DECLARE $safeTop AS Uint32;
-        DECLARE $uid AS Utf8;
-
-        $candidates = (
-          SELECT point_id
-          FROM ${tableName}
-          WHERE uid = $uid AND embedding_quantized IS NOT NULL
-          ORDER BY ${bitFn}(embedding_quantized, $qbin_bit) ${bitOrder}
-          LIMIT $candidateLimit
-        );
-
-        SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
-        FROM ${tableName}
-        WHERE uid = $uid
-          AND point_id IN $candidates
-        ORDER BY score ${order}
-        LIMIT $safeTop;
-      `;
-            params = {
-                $qbin_bit: typeof TypedValues.bytes === "function"
-                    ? TypedValues.bytes(binaries.bit)
-                    : binaries.bit,
-                $qbinf: typeof TypedValues.bytes === "function"
-                    ? TypedValues.bytes(binaries.float)
-                    : binaries.float,
-                $candidateLimit: TypedValues.uint32(candidateLimit),
-                $safeTop: TypedValues.uint32(safeTop),
-                $uid: TypedValues.utf8(uid),
-            };
-            logger.debug({
-                tableName,
-                distance,
-                top,
-                safeTop,
-                candidateLimit,
-                mode: "one_table_approximate_client_side_serialization",
-                yql,
-                params: {
-                    uid,
-                    safeTop,
-                    candidateLimit,
-                    vectorLength: queryVector.length,
-                    vectorPreview: queryVector.slice(0, 3),
-                },
-            }, "one_table search (approximate): executing YQL with client-side serialization");
-        }
-        else {
-            const qf = buildVectorParam(queryVector);
-            yql = `
-        DECLARE $qf AS List<Float>;
-        DECLARE $candidateLimit AS Uint32;
-        DECLARE $safeTop AS Uint32;
-        DECLARE $uid AS Utf8;
-
-        $qbin_bit = Knn::ToBinaryStringBit($qf);
-        $qbinf = Knn::ToBinaryStringFloat($qf);
-
-        $candidates = (
-          SELECT point_id
-          FROM ${tableName}
-          WHERE uid = $uid AND embedding_quantized IS NOT NULL
-          ORDER BY ${bitFn}(embedding_quantized, $qbin_bit) ${bitOrder}
-          LIMIT $candidateLimit
-        );
-
-        SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
-        FROM ${tableName}
-        WHERE uid = $uid
-          AND point_id IN $candidates
-        ORDER BY score ${order}
-        LIMIT $safeTop;
-      `;
-            params = {
-                $qf: qf,
-                $candidateLimit: TypedValues.uint32(candidateLimit),
-                $safeTop: TypedValues.uint32(safeTop),
-                $uid: TypedValues.utf8(uid),
-            };
-            logger.debug({
-                tableName,
-                distance,
-                top,
-                safeTop,
-                candidateLimit,
-                mode: "one_table_approximate",
-                yql,
-                params: {
-                    uid,
-                    safeTop,
-                    candidateLimit,
-                    vectorLength: queryVector.length,
-                    vectorPreview: queryVector.slice(0, 3),
-                },
-            }, "one_table search (approximate): executing YQL");
-        }
-        const settings = createExecuteQuerySettingsWithTimeout({
-            keepInCache: true,
-            idempotent: true,
-            timeoutMs: SEARCH_OPERATION_TIMEOUT_MS,
-        });
-        const rs = await s.executeQuery(yql, params, undefined, settings);
-        const rowset = rs.resultSets?.[0];
-        const rows = (rowset?.rows ?? []);
-        return rows.map((row) => {
-            const id = row.items?.[0]?.textValue;
-            if (typeof id !== "string") {
-                throw new Error("point_id is missing in YDB search result");
-            }
-            let payload;
-            let scoreIdx = 1;
-            if (withPayload) {
-                const payloadText = row.items?.[1]?.textValue;
-                if (payloadText) {
-                    try {
-                        payload = JSON.parse(payloadText);
-                    }
-                    catch {
-                        payload = undefined;
-                    }
-                }
-                scoreIdx = 2;
-            }
-            const score = Number(row.items?.[scoreIdx]?.floatValue ?? row.items?.[scoreIdx]?.textValue);
-            return { id, score, ...(payload ? { payload } : {}) };
-        });
-    });
-    return results;
-}
-export async function searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid, mode, overfetchMultiplier) {
-    if (mode === SearchMode.Exact) {
-        return await searchPointsOneTableExact(tableName, queryVector, top, withPayload, distance, dimension, uid);
-    }
-    return await searchPointsOneTableApproximate(tableName, queryVector, top, withPayload, distance, dimension, uid, overfetchMultiplier);
-}
-export async function deletePointsOneTable(tableName, ids, uid) {
-    let deleted = 0;
-    await withSession(async (s) => {
-        const settings = createExecuteQuerySettings();
-        for (const id of ids) {
-            const yql = `
-        DECLARE $uid AS Utf8;
-        DECLARE $id AS Utf8;
-        DELETE FROM ${tableName} WHERE uid = $uid AND point_id = $id;
-      `;
-            const params = {
-                $uid: TypedValues.utf8(uid),
-                $id: TypedValues.utf8(String(id)),
-            };
-            await s.executeQuery(yql, params, undefined, settings);
-            deleted += 1;
-        }
-    });
-    return deleted;
-}
+export { searchPointsOneTable } from "./pointsRepo.one-table/Search/index.js";
+export { upsertPointsOneTable } from "./pointsRepo.one-table/Upsert.js";
+export { deletePointsOneTable, deletePointsByPathSegmentsOneTable, } from "./pointsRepo.one-table/Delete.js";

package/dist/routes/collections.js

@@ -3,15 +3,67 @@ import { putCollectionIndex, createCollection, getCollection, deleteCollection,
 import { QdrantServiceError } from "../services/errors.js";
 import { logger } from "../logging/logger.js";
 export const collectionsRouter = Router();
+// Placeholder defaults to satisfy Qdrant `CollectionInfo` shape. These values are
+// not used for execution in ydb-qdrant, only for client compatibility.
+const DEFAULT_HNSW_CONFIG = {
+    m: 16,
+    ef_construct: 100,
+    full_scan_threshold: 10000,
+    max_indexing_threads: 0,
+    on_disk: false,
+};
+const DEFAULT_OPTIMIZERS_CONFIG = {
+    deleted_threshold: 0.2,
+    vacuum_min_vector_number: 1000,
+    default_segment_number: 0,
+    indexing_threshold: 10000,
+    flush_interval_sec: 5,
+};
+function mapVectorDatatype(dataType) {
+    // Our service exposes `float`; Qdrant uses `float32`/`float16`/`uint8`.
+    if (dataType === "float16")
+        return "float16";
+    if (dataType === "uint8")
+        return "uint8";
+    return "float32";
+}
+function toQdrantCollectionInfo(result) {
+    const vectors = result.vectors;
+    const datatype = mapVectorDatatype(vectors?.data_type);
+    const config = {
+        params: {
+            vectors: {
+                size: vectors.size,
+                distance: vectors.distance,
+                datatype,
+                on_disk: false,
+            },
+            shard_number: 1,
+            replication_factor: 1,
+            write_consistency_factor: 1,
+            on_disk_payload: false,
+        },
+        hnsw_config: DEFAULT_HNSW_CONFIG,
+        optimizer_config: DEFAULT_OPTIMIZERS_CONFIG,
+    };
+    return {
+        status: "green",
+        optimizer_status: "ok",
+        segments_count: 1,
+        config,
+        payload_schema: {},
+    };
+}
 collectionsRouter.put("/:collection/index", async (req, res) => {
     try {
-        const result = await putCollectionIndex({
+        await putCollectionIndex({
             tenant: req.header("X-Tenant-Id") ?? undefined,
             collection: String(req.params.collection),
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         });
-        res.json({ status: "ok", result });
+        // Qdrant compatibility: index operations return boolean `result`.
+        res.json({ status: "ok", result: true });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {
@@ -24,13 +76,14 @@ collectionsRouter.put("/:collection/index", async (req, res) => {
 });
 collectionsRouter.put("/:collection", async (req, res) => {
     try {
-        const result = await createCollection({
+        await createCollection({
             tenant: req.header("X-Tenant-Id") ?? undefined,
             collection: String(req.params.collection),
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         }, req.body);
-        res.json({ status: "ok", result });
+        // Qdrant compatibility: create collection returns boolean `result`.
+        res.json({ status: "ok", result: true });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {
@@ -49,7 +102,7 @@ collectionsRouter.get("/:collection", async (req, res) => {
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         });
-        res.json({ status: "ok", result });
+        res.json({ status: "ok", result: toQdrantCollectionInfo(result) });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {
@@ -62,13 +115,14 @@ collectionsRouter.get("/:collection", async (req, res) => {
 });
 collectionsRouter.delete("/:collection", async (req, res) => {
     try {
-        const result = await deleteCollection({
+        await deleteCollection({
             tenant: req.header("X-Tenant-Id") ?? undefined,
             collection: String(req.params.collection),
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         });
-        res.json({ status: "ok", result });
+        // Qdrant compatibility: delete collection returns boolean `result`.
+        res.json({ status: "ok", result: true });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {

package/dist/routes/points.js

@@ -2,9 +2,23 @@ import { Router } from "express";
 import { upsertPoints, searchPoints, queryPoints, deletePoints, } from "../services/PointsService.js";
 import { QdrantServiceError } from "../services/errors.js";
 import { logger } from "../logging/logger.js";
-import { isCompilationTimeoutError } from "../ydb/client.js";
+import { SEARCH_OPERATION_TIMEOUT_MS, UPSERT_OPERATION_TIMEOUT_MS, } from "../config/env.js";
+import { getAbortErrorCause, isCompilationTimeoutError, isTimeoutAbortError, } from "../ydb/client.js";
 import { scheduleExit } from "../utils/exit.js";
 export const pointsRouter = Router();
+function toQdrantScoredPoint(hit) {
+    // Qdrant's ScoredPoint includes a mandatory `version`.
+    // We don't track versions; emit a stable default.
+    return {
+        id: hit.id,
+        version: 0,
+        score: hit.score,
+        payload: hit.payload ?? null,
+        vector: null,
+        shard_key: null,
+        order_value: null,
+    };
+}
 // Qdrant-compatible: PUT /collections/:collection/points (upsert)
 pointsRouter.put("/:collection/points", async (req, res) => {
     try {
@@ -27,6 +41,17 @@ pointsRouter.put("/:collection/points", async (req, res) => {
             scheduleExit(1);
             return;
         }
+        if (isTimeoutAbortError(err)) {
+            logger.error({
+                err,
+                errCause: getAbortErrorCause(err),
+                timeoutMs: UPSERT_OPERATION_TIMEOUT_MS,
+            }, "YDB upsert operation timed out");
+            return res.status(500).json({
+                status: "error",
+                error: `upsert operation timed out after ${UPSERT_OPERATION_TIMEOUT_MS}ms`,
+            });
+        }
         logger.error({ err }, "upsert points (PUT) failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }
@@ -52,6 +77,17 @@ pointsRouter.post("/:collection/points/upsert", async (req, res) => {
             scheduleExit(1);
             return;
         }
+        if (isTimeoutAbortError(err)) {
+            logger.error({
+                err,
+                errCause: getAbortErrorCause(err),
+                timeoutMs: UPSERT_OPERATION_TIMEOUT_MS,
+            }, "YDB upsert operation timed out");
+            return res.status(500).json({
+                status: "error",
+                error: `upsert operation timed out after ${UPSERT_OPERATION_TIMEOUT_MS}ms`,
+            });
+        }
         logger.error({ err }, "upsert points failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }
@@ -64,7 +100,12 @@ pointsRouter.post("/:collection/points/search", async (req, res) => {
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         }, req.body);
-        res.json({ status: "ok", result });
+        // Qdrant compatibility: REST API returns `result` as an array of points.
+        // Keep service return shape internal (`{ points: [...] }`).
+        res.json({
+            status: "ok",
+            result: result.points.map(toQdrantScoredPoint),
+        });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {
@@ -77,6 +118,17 @@ pointsRouter.post("/:collection/points/search", async (req, res) => {
             scheduleExit(1);
             return;
         }
+        if (isTimeoutAbortError(err)) {
+            logger.error({
+                err,
+                errCause: getAbortErrorCause(err),
+                timeoutMs: SEARCH_OPERATION_TIMEOUT_MS,
+            }, "YDB search operation timed out");
+            return res.status(500).json({
+                status: "error",
+                error: `search operation timed out after ${SEARCH_OPERATION_TIMEOUT_MS}ms`,
+            });
+        }
         logger.error({ err }, "search points failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }
@@ -90,7 +142,12 @@ pointsRouter.post("/:collection/points/query", async (req, res) => {
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         }, req.body);
-        res.json({ status: "ok", result });
+        // Qdrant compatibility: /points/query returns `result` as an object.
+        // (Unlike /points/search, where result is a list.)
+        const qdrantResult = {
+            points: result.points.map(toQdrantScoredPoint),
+        };
+        res.json({ status: "ok", result: qdrantResult });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {
@@ -103,6 +160,17 @@ pointsRouter.post("/:collection/points/query", async (req, res) => {
             scheduleExit(1);
             return;
         }
+        if (isTimeoutAbortError(err)) {
+            logger.error({
+                err,
+                errCause: getAbortErrorCause(err),
+                timeoutMs: SEARCH_OPERATION_TIMEOUT_MS,
+            }, "YDB search operation timed out");
+            return res.status(500).json({
+                status: "error",
+                error: `search operation timed out after ${SEARCH_OPERATION_TIMEOUT_MS}ms`,
+            });
+        }
         logger.error({ err }, "search points (query) failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }

package/dist/server.d.ts

@@ -1,3 +1,4 @@
 import type { Request, Response } from "express";
 export declare function healthHandler(_req: Request, res: Response): Promise<void>;
+export declare function rootHandler(_req: Request, res: Response): void;
 export declare function buildServer(): import("express-serve-static-core").Express;