@delali/narsil 0.2.4-next.49 → 0.2.4-next.50

package/dist/server.mjs

@@ -1,494 +1,14 @@
-import { validateIndexName } from './chunk-KGRYQVZ5.mjs';
-import './chunk-OWCFK42Q.mjs';
-import { MAX_SORT_FIELDS } from './chunk-CBLS46IE.mjs';
-import { ServerErrorCodes, NarsilError, ErrorCodes } from './chunk-P4ELXVJQ.mjs';
+import { DEFAULT_MAX_RETAINED_TASKS, loadUWebSockets, resolveCors, authorizerFor, createSharedGateBuffer, gateSlotOfWorker, createRouteRunner, corsWriter, createSharedRequestGate, MAIN_THREAD_GATE_SLOT, registerServerRoutes, DEFAULT_MAX_CONCURRENT_TASKS, DEFAULT_MAX_TASK_PAGE_SIZE, DEFAULT_MAX_IMPORT_ERRORS, DEFAULT_MAX_FETCH_DOCUMENTS, DEFAULT_MAX_RESULT_WINDOW, DEFAULT_MAX_CONCURRENT_REQUESTS, DEFAULT_IMPORT_BATCH_SIZE, DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_IMPORT_BYTES, DEFAULT_MAX_BODY_BYTES, RUNNING_TASK_TTL_MS, DEFAULT_TASK_PAGE_SIZE, TERMINAL_TASK_TTL_MS, TASK_PROGRESS_WRITE_INTERVAL_MS, serializeNarsilError, acceptorOf, createDocumentReadHandlers, sendError, respondError, respondJson, MAX_INDEX_TOUCH_INTERVAL_MS, INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT, clearGateSlot, parseJson, validateCreateIndex, rejectInvalid, validateBatch, serializeBatchResult, validateDocumentBody, validateSuggest, validateQuery, parseTaskListQuery, parseJsonOptional, validateRebalance, sendBinary, badRequest, SERVER_CAPABILITIES } from './chunk-CV5H7XL7.mjs';
+export { ASYNC_IMPORT_CAPABILITY, INDEX_LIFECYCLE_CAPABILITY, REBUILD_ANALYSIS_CAPABILITY, SERVER_CAPABILITIES, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, httpStatusForNarsilError } from './chunk-CV5H7XL7.mjs';
+import { validateIndexName } from './chunk-MHE7YWAU.mjs';
+import { engineCoreOf, resolveVectorText } from './chunk-PIWKZPP7.mjs';
+import './chunk-XE6XR2OE.mjs';
+import { detectRuntime } from './chunk-AV4IJKD2.mjs';
+import './chunk-CBLS46IE.mjs';
+import { NarsilError, ServerErrorCodes, ErrorCodes } from './chunk-P4ELXVJQ.mjs';
 export { ServerErrorCodes } from './chunk-P4ELXVJQ.mjs';
 import { randomUUID } from 'crypto';
-
-// src/server/capabilities.ts
-var ASYNC_IMPORT_CAPABILITY = "documents.import.async";
-var TASK_CANCEL_CAPABILITY = "tasks.cancel";
-var TASK_FILTER_CAPABILITY = "tasks.filter";
-var REBUILD_ANALYSIS_CAPABILITY = "indexes.rebuildAnalysis";
-var INDEX_LIFECYCLE_CAPABILITY = "indexes.lifecycle";
-var SERVER_CAPABILITIES = [
-  ASYNC_IMPORT_CAPABILITY,
-  TASK_CANCEL_CAPABILITY,
-  TASK_FILTER_CAPABILITY,
-  REBUILD_ANALYSIS_CAPABILITY,
-  INDEX_LIFECYCLE_CAPABILITY
-];
-
-// src/server/constants.ts
-var BYTES_PER_MB = 1024 * 1024;
-var DEFAULT_MAX_BODY_BYTES = 16 * BYTES_PER_MB;
-var DEFAULT_MAX_IMPORT_BYTES = 100 * BYTES_PER_MB;
-var DEFAULT_MAX_LINE_BYTES = 4 * BYTES_PER_MB;
-var DEFAULT_IMPORT_BATCH_SIZE = 1e3;
-var DEFAULT_MAX_CONCURRENT_REQUESTS = 0;
-var DEFAULT_MAX_RESULT_WINDOW = 1e4;
-var DEFAULT_MAX_FETCH_DOCUMENTS = 1e4;
-var DEFAULT_MAX_IMPORT_ERRORS = 100;
-var DEFAULT_MAX_TASK_PAGE_SIZE = 1e3;
-var DEFAULT_MAX_CONCURRENT_TASKS = 4;
-var RESPONSE_STREAM_THRESHOLD_BYTES = 64 * 1024;
-var DEFAULT_MAX_RETAINED_TASKS = 1e3;
-var DEFAULT_TASK_PAGE_SIZE = 20;
-var TASK_PROGRESS_WRITE_INTERVAL_MS = 250;
-var RUNNING_TASK_TTL_MS = 24 * 60 * 60 * 1e3;
-var TERMINAL_TASK_TTL_MS = 60 * 60 * 1e3;
-
-// src/server/cors.ts
-function resolveCors(cors) {
-  if (!cors) return null;
-  if (cors === true) {
-    return { origin: "*", methods: "GET, POST, PUT, PATCH, DELETE, OPTIONS", headers: "Content-Type, Authorization" };
-  }
-  return {
-    origin: cors.origin ?? "*",
-    methods: cors.methods?.join(", ") ?? "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-    headers: cors.headers?.join(", ") ?? "Content-Type, Authorization"
-  };
-}
-function matchOrigin(cors, requestOrigin) {
-  if (cors.origin === "*") return "*";
-  if (typeof cors.origin === "string") return cors.origin;
-  return cors.origin.includes(requestOrigin) ? requestOrigin : null;
-}
-function writeCorsOrigin(res, cors, requestOrigin) {
-  const allowed = matchOrigin(cors, requestOrigin);
-  if (!allowed) return;
-  res.writeHeader("Access-Control-Allow-Origin", allowed);
-  if (allowed !== "*") res.writeHeader("Vary", "Origin");
-}
-function corsWriter(cors) {
-  return (res, req) => writeCorsOrigin(res, cors, req.getHeader("origin"));
-}
-
-// src/server/errors.ts
-var STATUS_BY_CODE = {
-  INVALID_REQUEST: 400,
-  INVALID_JSON: 400,
-  EMPTY_BODY: 400,
-  PAYLOAD_TOO_LARGE: 413,
-  NOT_FOUND: 404,
-  TASK_NOT_FOUND: 404,
-  TASK_NOT_CANCELLABLE: 409,
-  TASK_OWNED_BY_ANOTHER_INSTANCE: 409,
-  TASK_INTERRUPTED: 503,
-  TOO_MANY_REQUESTS: 429,
-  HOOK_ERROR: 500,
-  INTERNAL_ERROR: 500,
-  ENVELOPE_INVALID_MAGIC: 400,
-  ENVELOPE_VERSION_MISMATCH: 400,
-  SCHEMA_INVALID_TYPE: 400,
-  SCHEMA_DEPTH_EXCEEDED: 400,
-  SCHEMA_INVALID_VECTOR_DIMENSION: 400,
-  SCHEMA_INVALID_GEOPOINT: 400,
-  DOC_VALIDATION_FAILED: 400,
-  DOC_MISSING_REQUIRED_FIELD: 400,
-  SEARCH_INVALID_FIELD: 400,
-  VECTOR_DIMENSION_MISMATCH: 400,
-  SEARCH_INVALID_FILTER: 400,
-  SEARCH_INVALID_MODE: 400,
-  SEARCH_INVALID_CURSOR: 400,
-  SEARCH_RESULT_WINDOW_EXCEEDED: 400,
-  LANGUAGE_NOT_SUPPORTED: 400,
-  CONFIG_INVALID: 400,
-  EMBEDDING_DIMENSION_MISMATCH: 400,
-  EMBEDDING_NO_SOURCE: 400,
-  EMBEDDING_CONFIG_INVALID: 400,
-  INDEX_NOT_FOUND: 404,
-  DOC_NOT_FOUND: 404,
-  INDEX_ALREADY_EXISTS: 409,
-  INDEX_ORPHANED: 409,
-  INDEX_REOPEN_CAPACITY_EXHAUSTED: 503,
-  DOC_ALREADY_EXISTS: 409,
-  PARTITION_REBALANCING_BACKPRESSURE: 409,
-  PARTITION_CAPACITY_EXCEEDED: 409,
-  WORKER_BUSY: 429,
-  PARTITION_CORRUPTED: 503,
-  WORKER_CRASHED: 503,
-  WORKER_TIMEOUT: 503,
-  PERSISTENCE_SAVE_FAILED: 503,
-  PERSISTENCE_LOAD_FAILED: 503,
-  PERSISTENCE_DELETE_FAILED: 503,
-  PERSISTENCE_CRC_MISMATCH: 503,
-  PERSISTENCE_WAL_CORRUPT: 503,
-  PERSISTENCE_FSYNC_FAILED: 503,
-  EMBEDDING_FAILED: 503,
-  QUERY_ROUTING_FAILED: 503,
-  QUERY_PARTIAL_FAILURE: 503,
-  QUERY_NODE_TIMEOUT: 503,
-  QUERY_NO_ACTIVE_REPLICA: 503,
-  CLUSTER_OPERATION_UNSUPPORTED: 501,
-  REPLICATION_ENTRY_INVALID: 503,
-  REPLICATION_INSYNC_REMOVAL_FAILED: 503,
-  REPLICATION_ROLLBACK_FAILED: 503,
-  REPLICATION_LOG_FULL: 503,
-  REPLICATION_ENTRY_CORRUPT: 503,
-  REPLICATION_SNAPSHOT_CORRUPT: 503,
-  REPLICATION_TERM_MISMATCH: 503,
-  REPLICATION_SYNC_FAILED: 503,
-  PARTITION_NOT_PRIMARY: 503,
-  PARTITION_UNASSIGNED: 503,
-  INSUFFICIENT_REPLICAS: 503,
-  TRANSPORT_DEPENDENCY_MISSING: 500,
-  ALLOCATION_INVALID_CONFIG: 400,
-  ALLOCATION_NO_DATA_NODES: 503,
-  ALLOCATION_FAILED: 503,
-  NODE_ALREADY_JOINED: 409,
-  NODE_NOT_JOINED: 503,
-  NODE_NOT_READY: 503,
-  NODE_NOT_CONTROLLER: 503,
-  NODE_BOOTSTRAP_FAILED: 503,
-  COORDINATOR_DEPENDENCY_MISSING: 500,
-  SNAPSHOT_SYNC_UNAUTHORIZED: 403,
-  SNAPSHOT_SYNC_REQUEST_INVALID: 400,
-  SNAPSHOT_SYNC_HEADER_INVALID: 400,
-  SNAPSHOT_SYNC_FRAME_INVALID: 400,
-  SNAPSHOT_SYNC_INDEX_NOT_FOUND: 404,
-  SNAPSHOT_SYNC_TOO_LARGE: 413,
-  SNAPSHOT_SYNC_CHUNK_SIZE_EXCEEDED: 413,
-  SNAPSHOT_SYNC_ABORTED: 409,
-  SNAPSHOT_SYNC_CAPACITY_EXHAUSTED: 503,
-  SNAPSHOT_SYNC_SNAPSHOT_FAILED: 503,
-  SNAPSHOT_SYNC_DECODE_FAILED: 503,
-  SNAPSHOT_SYNC_HEADER_MISMATCH: 503,
-  SNAPSHOT_SYNC_CHUNK_OUT_OF_ORDER: 503,
-  SNAPSHOT_SYNC_CHUNK_OVERFLOW: 503,
-  SNAPSHOT_SYNC_CHUNK_MISSING: 503,
-  SNAPSHOT_SYNC_END_MISSING: 503,
-  SNAPSHOT_SYNC_CHECKSUM_MISMATCH: 503,
-  SNAPSHOT_SYNC_PRIMARY_ERROR: 503,
-  SNAPSHOT_SYNC_NO_TARGETS: 503,
-  SNAPSHOT_SYNC_TRANSPORT_FAILED: 503,
-  SNAPSHOT_SYNC_SCHEMA_UNAVAILABLE: 503,
-  SNAPSHOT_SYNC_RESTORE_FAILED: 503,
-  SNAPSHOT_SYNC_RESTORE_CLEANUP_FAILED: 503,
-  SNAPSHOT_SYNC_TIMEOUT: 503,
-  SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE: 503,
-  SNAPSHOT_SYNC_NOT_ASSIGNED: 503,
-  CONTROLLER_METADATA_INVALID: 500
-};
-function httpStatusForNarsilError(code) {
-  return STATUS_BY_CODE[code] ?? 500;
-}
-function serializeNarsilError(err) {
-  const hasDetails = err.details && Object.keys(err.details).length > 0;
-  return hasDetails ? { code: err.code, message: err.message, details: err.details } : { code: err.code, message: err.message };
-}
-function toHttpError(err) {
-  if (err instanceof NarsilError) {
-    return { status: httpStatusForNarsilError(err.code), body: serializeNarsilError(err) };
-  }
-  return {
-    status: 500,
-    body: { code: ServerErrorCodes.INTERNAL_ERROR, message: "An unexpected error occurred" }
-  };
-}
-
-// src/json-encoding.ts
-function toPlainNumbers(key, value) {
-  if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
-    return Array.from(value);
-  }
-  return value;
-}
-function encodeJson(value) {
-  return JSON.stringify(value, toPlainNumbers);
-}
-
-// src/server/response.ts
-var STATUS_TEXT = {
-  200: "200 OK",
-  201: "201 Created",
-  202: "202 Accepted",
-  204: "204 No Content",
-  400: "400 Bad Request",
-  401: "401 Unauthorized",
-  403: "403 Forbidden",
-  404: "404 Not Found",
-  405: "405 Method Not Allowed",
-  409: "409 Conflict",
-  413: "413 Payload Too Large",
-  415: "415 Unsupported Media Type",
-  429: "429 Too Many Requests",
-  500: "500 Internal Server Error",
-  503: "503 Service Unavailable"
-};
-function statusLine(status) {
-  return STATUS_TEXT[status] ?? `${status}`;
-}
-function streamBody(res, abort, body, status, contentType) {
-  if (abort.aborted) return;
-  const totalSize = body.byteLength;
-  res.cork(() => {
-    res.writeStatus(statusLine(status)).writeHeader("Content-Type", contentType);
-    const startOffset = res.getWriteOffset();
-    const [, done] = res.tryEnd(body, totalSize);
-    if (done) return;
-    res.onWritable((offset) => {
-      if (abort.aborted) return true;
-      const [retryOk] = res.tryEnd(body.subarray(offset - startOffset), totalSize);
-      return retryOk;
-    });
-  });
-}
-function sendJson(res, data, status = 200, abort) {
-  const payload = encodeJson(data);
-  if (abort && payload !== void 0 && Buffer.byteLength(payload) >= RESPONSE_STREAM_THRESHOLD_BYTES) {
-    streamBody(res, abort, Buffer.from(payload, "utf8"), status, "application/json");
-    return;
-  }
-  res.cork(() => {
-    res.writeStatus(statusLine(status)).writeHeader("Content-Type", "application/json").end(payload);
-  });
-}
-function sendError(res, status, code, message, details) {
-  const body = { error: details ? { code, message, details } : { code, message } };
-  const payload = encodeJson(body);
-  res.cork(() => {
-    res.writeStatus(statusLine(status)).writeHeader("Content-Type", "application/json").end(payload);
-  });
-}
-function sendBinary(res, data, abort, status = 200) {
-  streamBody(res, abort, data, status, "application/octet-stream");
-}
-
-// src/server/handler-utils.ts
-function parseJson(ctx) {
-  const raw = ctx.rawBody;
-  if (!raw || raw.length === 0) {
-    sendError(ctx.res, 400, ServerErrorCodes.EMPTY_BODY, "Request body is empty");
-    return void 0;
-  }
-  try {
-    return JSON.parse(raw.toString("utf8"));
-  } catch {
-    sendError(ctx.res, 400, ServerErrorCodes.INVALID_JSON, "Request body is not valid JSON");
-    return void 0;
-  }
-}
-function parseJsonOptional(ctx) {
-  const raw = ctx.rawBody;
-  if (!raw || raw.length === 0) return {};
-  try {
-    return JSON.parse(raw.toString("utf8"));
-  } catch {
-    sendError(ctx.res, 400, ServerErrorCodes.INVALID_JSON, "Request body is not valid JSON");
-    return void 0;
-  }
-}
-function respondError(ctx, err) {
-  if (ctx.abort.aborted) return;
-  const { status, body } = toHttpError(err);
-  sendError(ctx.res, status, body.code, body.message, body.details);
-}
-function respondJson(ctx, data, status = 200) {
-  if (ctx.abort.aborted) return;
-  sendJson(ctx.res, data, status, ctx.abort);
-}
-function badRequest(res, message, details) {
-  sendError(res, 400, ServerErrorCodes.INVALID_REQUEST, message, details);
-}
-function rejectInvalid(ctx, failure) {
-  if (ctx.abort.aborted) return;
-  badRequest(ctx.res, failure.message, failure.details);
-}
-function serializeBatchResult(result) {
-  return {
-    succeeded: result.succeeded,
-    failed: result.failed.map((f) => ({
-      docId: f.docId,
-      error: f.error instanceof NarsilError ? serializeNarsilError(f.error) : { code: "INTERNAL_ERROR", message: String(f.error) }
-    }))
-  };
-}
-
-// src/server/validation.ts
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function overWindow(field, value, maxWindow) {
-  if (typeof value === "number" && value > maxWindow) {
-    return {
-      message: `Field "${field}" exceeds the maximum result window of ${maxWindow}`,
-      details: { value, limit: maxWindow }
-    };
-  }
-  return null;
-}
-function validateQuery(params, maxWindow) {
-  if (params.group && typeof params.group === "object" && "reduce" in params.group) {
-    return {
-      message: 'Custom group reducers are not available over HTTP; use "group.fields" and "group.maxPerGroup" only'
-    };
-  }
-  const rowBound = overWindow("limit", params.limit, maxWindow) ?? overWindow("offset", params.offset, maxWindow);
-  if (rowBound) return rowBound;
-  if (params.group && typeof params.group === "object") {
-    const grouped = overWindow("group.maxPerGroup", params.group.maxPerGroup, maxWindow) ?? overWindow("group.limit", params.group.limit, maxWindow);
-    if (grouped) return grouped;
-  }
-  if (params.facets && typeof params.facets === "object") {
-    for (const [field, facet] of Object.entries(params.facets)) {
-      if (facet && typeof facet === "object") {
-        const faceted = overWindow(`facets.${field}.limit`, facet.limit, maxWindow);
-        if (faceted) return faceted;
-      }
-    }
-  }
-  return null;
-}
-function validateSuggest(params) {
-  if (typeof params.prefix !== "string") {
-    return { message: 'Field "prefix" is required and must be a string' };
-  }
-  return null;
-}
-function validateDocumentBody(body) {
-  if (!isPlainObject(body.document)) {
-    return { message: 'Field "document" is required and must be an object' };
-  }
-  return null;
-}
-function validateMultiGet(body, maxFetch) {
-  if (!Array.isArray(body.docIds)) {
-    return { message: 'Field "docIds" is required and must be an array of strings' };
-  }
-  if (body.docIds.length > maxFetch) {
-    return {
-      message: `Field "docIds" exceeds the maximum of ${maxFetch} ids per request`,
-      details: { count: body.docIds.length, limit: maxFetch }
-    };
-  }
-  return null;
-}
-function validateList(params, maxFetch) {
-  if (params.cursor !== void 0 && typeof params.cursor !== "string") {
-    return { message: 'Field "cursor" must be a string' };
-  }
-  if (params.limit !== void 0 && typeof params.limit !== "number") {
-    return { message: 'Field "limit" must be a number' };
-  }
-  if (typeof params.limit === "number" && params.limit > maxFetch) {
-    return {
-      message: `Field "limit" exceeds the maximum of ${maxFetch} documents per request`,
-      details: { value: params.limit, limit: maxFetch }
-    };
-  }
-  return validateListSort(params.sort);
-}
-function validateListSort(sort) {
-  if (sort === void 0) return null;
-  if (typeof sort !== "object" || sort === null) {
-    return { message: 'Field "sort" must be an object keyed by field name, or a list of fields' };
-  }
-  const entries = Array.isArray(sort) ? sort.map(
-    (entry) => typeof entry === "object" && entry !== null ? [entry.field, entry.direction] : [entry, void 0]
-  ) : Object.entries(sort);
-  if (entries.length > MAX_SORT_FIELDS) {
-    return {
-      message: `Field "sort" exceeds the maximum of ${MAX_SORT_FIELDS} fields`,
-      details: { count: entries.length, limit: MAX_SORT_FIELDS }
-    };
-  }
-  for (const [field, direction] of entries) {
-    if (typeof field !== "string" || field.length === 0) {
-      return { message: 'Every entry of "sort" must name a field', details: { value: field } };
-    }
-    if (direction !== "asc" && direction !== "desc") {
-      return { message: `Field "sort.${field}" must be "asc" or "desc"`, details: { value: direction } };
-    }
-  }
-  return null;
-}
-function validateBatch(body) {
-  const action = body.action ?? "insert";
-  if (action === "insert") {
-    if (!Array.isArray(body.documents)) return { message: 'Batch insert requires a "documents" array' };
-    return null;
-  }
-  if (action === "update") {
-    if (!Array.isArray(body.updates)) return { message: 'Batch update requires an "updates" array' };
-    return null;
-  }
-  if (action === "delete") {
-    if (!Array.isArray(body.docIds)) return { message: 'Batch delete requires a "docIds" array' };
-    return null;
-  }
-  return { message: 'Field "action" must be one of "insert", "update", or "delete"' };
-}
-function validateCreateIndex(body) {
-  if (typeof body.name !== "string" || body.name.length === 0) {
-    return { message: 'Field "name" is required and must be a non-empty string' };
-  }
-  if (!isPlainObject(body.config)) {
-    return { message: 'Field "config" is required and must be an object' };
-  }
-  return null;
-}
-function validateRebalance(body) {
-  const target = body.targetPartitionCount;
-  if (typeof target !== "number" || !Number.isInteger(target) || target <= 0) {
-    return { message: 'Field "targetPartitionCount" is required and must be a positive integer' };
-  }
-  return null;
-}
-var TASK_TYPES = ["optimizeVectors", "rebalance", "restore", "import", "rebuildAnalysis"];
-var TASK_STATUSES = ["queued", "running", "succeeded", "failed", "cancelled"];
-function parseCountParam(raw, field, minimum) {
-  if (raw === null) return minimum;
-  const value = Number(raw);
-  if (!Number.isInteger(value) || value < minimum) {
-    return { message: `Query parameter "${field}" must be an integer of ${minimum} or more`, details: { value: raw } };
-  }
-  return value;
-}
-function parseEnumParam(raw, field, allowed) {
-  if (raw === null) return void 0;
-  const requested = raw.split(",").map((entry) => entry.trim());
-  const unknown = requested.filter((entry) => !allowed.includes(entry));
-  if (requested.length === 0 || unknown.length > 0) {
-    return {
-      message: `Query parameter "${field}" accepts only ${allowed.join(", ")}`,
-      details: { unknown }
-    };
-  }
-  return requested;
-}
-function isFailure(value) {
-  return isPlainObject(value) && typeof value.message === "string";
-}
-function parseTaskListQuery(params, maxPageSize) {
-  const type = parseEnumParam(params.get("type"), "type", TASK_TYPES);
-  if (isFailure(type)) return { failure: type };
-  const status = parseEnumParam(params.get("status"), "status", TASK_STATUSES);
-  if (isFailure(status)) return { failure: status };
-  const from = parseCountParam(params.get("from"), "from", 0);
-  if (isFailure(from)) return { failure: from };
-  const limit = parseCountParam(params.get("limit"), "limit", 1);
-  if (isFailure(limit)) return { failure: limit };
-  if (params.get("limit") !== null && limit > maxPageSize) {
-    return {
-      failure: {
-        message: `Query parameter "limit" exceeds the maximum page size of ${maxPageSize}`,
-        details: { value: limit, limit: maxPageSize }
-      }
-    };
-  }
-  const indexName = params.get("indexName");
-  return {
-    query: {
-      ...indexName === null ? {} : { indexName },
-      ...type === void 0 ? {} : { type },
-      ...status === void 0 ? {} : { status },
-      from,
-      ...params.get("limit") === null ? {} : { limit }
-    }
-  };
-}
+import { MessageChannel } from 'worker_threads';
 
 // src/server/handlers/admin.ts
 function createAdminHandlers(deps) {
@@ -746,7 +266,8 @@ function createClusterHandlers(deps) {
 
 // src/server/handlers/documents.ts
 function createDocumentHandlers(deps) {
-  const { engine, limits } = deps;
+  const { engine } = deps;
+  const reads = createDocumentReadHandlers(deps);
   async function insert(ctx) {
     const body = parseJson(ctx);
     if (!body) return;
@@ -762,25 +283,6 @@ function createDocumentHandlers(deps) {
       respondError(ctx, err);
     }
   }
-  async function get(ctx) {
-    try {
-      const document = await engine.get(ctx.params[0], ctx.params[1]);
-      if (document === void 0) {
-        respondError(ctx, indexDocNotFound(ctx.params[1]));
-        return;
-      }
-      respondJson(ctx, { document });
-    } catch (err) {
-      respondError(ctx, err);
-    }
-  }
-  async function exists(ctx) {
-    try {
-      respondJson(ctx, { exists: await engine.has(ctx.params[0], ctx.params[1]) });
-    } catch (err) {
-      respondError(ctx, err);
-    }
-  }
   async function put(ctx) {
     const body = parseJson(ctx);
     if (!body) return;
@@ -792,10 +294,10 @@ function createDocumentHandlers(deps) {
     const [name, id] = ctx.params;
     try {
       if (await engine.has(name, id)) {
-        await engine.update(name, id, body.document);
+        await engine.update(name, id, body.document, body.options);
         respondJson(ctx, { id, created: false });
       } else {
-        const created = await engine.insert(name, body.document, id);
+        const created = await engine.insert(name, body.document, id, body.options);
         respondJson(ctx, { id: created, created: true }, 201);
       }
     } catch (err) {
@@ -811,7 +313,7 @@ function createDocumentHandlers(deps) {
       return;
     }
     try {
-      await engine.update(ctx.params[0], ctx.params[1], body.document);
+      await engine.update(ctx.params[0], ctx.params[1], body.document, body.options);
       respondJson(ctx, { id: ctx.params[1] });
     } catch (err) {
       respondError(ctx, err);
@@ -819,46 +321,16 @@ function createDocumentHandlers(deps) {
   }
   async function remove(ctx) {
     try {
-      await engine.remove(ctx.params[0], ctx.params[1]);
+      await engine.remove(ctx.params[0], ctx.params[1], { wait: ctx.query.get("wait") === "true" });
       respondJson(ctx, { id: ctx.params[1], removed: true });
     } catch (err) {
       respondError(ctx, err);
     }
   }
-  async function count(ctx) {
-    try {
-      respondJson(ctx, { count: await engine.countDocuments(ctx.params[0]) });
-    } catch (err) {
-      respondError(ctx, err);
-    }
-  }
-  async function multiGet(ctx) {
-    const body = parseJson(ctx);
-    if (!body) return;
-    const failure = validateMultiGet(body, limits.maxFetchDocuments);
-    if (failure) {
-      rejectInvalid(ctx, failure);
-      return;
-    }
+  async function waitForWrites(ctx) {
     try {
-      const found = await engine.getMultiple(ctx.params[0], body.docIds);
-      const documents = {};
-      for (const [id, doc] of found) documents[id] = doc;
-      respondJson(ctx, { documents });
-    } catch (err) {
-      respondError(ctx, err);
-    }
-  }
-  async function list(ctx) {
-    const params = parseJson(ctx);
-    if (!params) return;
-    const failure = validateList(params, limits.maxFetchDocuments);
-    if (failure) {
-      rejectInvalid(ctx, failure);
-      return;
-    }
-    try {
-      respondJson(ctx, await engine.listDocuments(ctx.params[0], params));
+      await engine.waitForWrites(ctx.params[0]);
+      respondJson(ctx, { ok: true });
     } catch (err) {
       respondError(ctx, err);
     }
@@ -874,9 +346,12 @@ function createDocumentHandlers(deps) {
     const action = body.action ?? "insert";
     try {
       if (action === "update") {
-        respondJson(ctx, serializeBatchResult(await engine.updateBatch(ctx.params[0], body.updates ?? [])));
+        respondJson(
+          ctx,
+          serializeBatchResult(await engine.updateBatch(ctx.params[0], body.updates ?? [], body.options))
+        );
       } else if (action === "delete") {
-        respondJson(ctx, serializeBatchResult(await engine.removeBatch(ctx.params[0], body.docIds ?? [])));
+        respondJson(ctx, serializeBatchResult(await engine.removeBatch(ctx.params[0], body.docIds ?? [], body.options)));
       } else {
         respondJson(
           ctx,
@@ -887,10 +362,7 @@ function createDocumentHandlers(deps) {
       respondError(ctx, err);
     }
   }
-  return { insert, get, exists, put, patch, remove, count, list, multiGet, batch };
-}
-function indexDocNotFound(docId) {
-  return new NarsilError(ErrorCodes.DOC_NOT_FOUND, `Document "${docId}" not found`, { docId });
+  return { ...reads, insert, put, patch, remove, batch, waitForWrites };
 }
 
 // src/server/handlers/health.ts
@@ -955,7 +427,7 @@ function* iterateNdjson(buffer, maxLineBytes) {
 function yieldToEventLoop() {
   return new Promise((resolve) => setImmediate(resolve));
 }
-function isPlainObject2(value) {
+function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function runImport(engine, options) {
@@ -993,7 +465,7 @@ async function runImport(engine, options) {
       recordFailure({ line: line.lineNumber, code: ServerErrorCodes.INVALID_JSON, message: "Line is not valid JSON" });
       continue;
     }
-    if (!isPlainObject2(parsed)) {
+    if (!isPlainObject(parsed)) {
       recordFailure({
         line: line.lineNumber,
         code: ServerErrorCodes.INVALID_REQUEST,
@@ -1245,185 +717,237 @@ function createVersionHandler(deps) {
   return { report };
 }
 
-// src/server/request.ts
-function initAbortHandler(res) {
-  const listeners = [];
-  let aborted = false;
-  res.onAborted(() => {
-    aborted = true;
-    for (const fn of listeners) fn();
+// src/server/request-threads/captured-response.ts
+var DEFAULT_STATUS = 200;
+var NO_RESPONSE_STATUS = 500;
+function statusOf(line) {
+  const parsed = Number.parseInt(line, 10);
+  return Number.isFinite(parsed) ? parsed : DEFAULT_STATUS;
+}
+function bodyBytes(body) {
+  if (body === void 0) return new Uint8Array(0);
+  if (typeof body === "string") return Buffer.from(body, "utf8");
+  return body;
+}
+function createCapturingResponse(remoteAddress) {
+  let status = DEFAULT_STATUS;
+  const headers = [];
+  let finished = false;
+  let resolveDone = () => void 0;
+  const done = new Promise((resolve) => {
+    resolveDone = resolve;
   });
-  return {
-    get aborted() {
-      return aborted;
+  function finish(body) {
+    if (finished) return;
+    finished = true;
+    resolveDone({ status, headers, body });
+  }
+  const sink = {
+    cork(callback) {
+      callback();
+      return sink;
+    },
+    writeStatus(line) {
+      if (!finished) status = statusOf(line);
+      return sink;
+    },
+    writeHeader(key, value) {
+      if (!finished) headers.push([key, value]);
+      return sink;
     },
-    onAbort(fn) {
-      if (aborted) fn();
-      else listeners.push(fn);
+    end(body) {
+      finish(bodyBytes(body));
+      return sink;
+    },
+    endWithoutBody() {
+      finish(new Uint8Array(0));
+      return sink;
+    },
+    tryEnd(body) {
+      finish(body);
+      return [true, true];
+    },
+    getWriteOffset: () => 0,
+    onWritable: () => sink,
+    onAborted: () => sink,
+    onData: () => sink,
+    getRemoteAddressAsText: () => new TextEncoder().encode(remoteAddress).buffer
+  };
+  return {
+    sink,
+    done,
+    finishUnanswered() {
+      if (finished) return;
+      status = NO_RESPONSE_STATUS;
+      finish(new Uint8Array(0));
     }
   };
 }
-function readBody(res, maxBytes, abort) {
-  return new Promise((resolve, reject) => {
-    if (abort.aborted) {
-      reject(new Error("aborted"));
-      return;
-    }
-    let done = false;
-    let total = 0;
-    const chunks = [];
-    abort.onAbort(() => {
-      if (done) return;
-      done = true;
-      reject(new Error("aborted"));
-    });
-    res.onData((chunk, isLast) => {
-      if (done || abort.aborted) return;
-      total += chunk.byteLength;
-      if (total > maxBytes) {
-        done = true;
-        if (!abort.aborted) {
-          sendError(res, 413, ServerErrorCodes.PAYLOAD_TOO_LARGE, "Request body exceeds the configured size limit");
-        }
-        reject(new Error("payload too large"));
-        return;
-      }
-      chunks.push(Buffer.from(new Uint8Array(chunk)));
-      if (isLast) {
-        done = true;
-        resolve(Buffer.concat(chunks));
-      }
-    });
-  });
+function toRelayedResponse(requestId, captured) {
+  return { type: "response", requestId, status: captured.status, headers: captured.headers, body: captured.body };
 }
-var ConcurrencyGate = class {
-  constructor(max) {
-    this.max = max;
-  }
-  inFlight = 0;
-  tryAcquire() {
-    if (this.max <= 0) return true;
-    if (this.inFlight >= this.max) return false;
-    this.inFlight++;
-    return true;
-  }
-  release() {
-    if (this.max <= 0) return;
-    if (this.inFlight > 0) this.inFlight--;
-  }
-};
-function decodePathParameter(raw) {
-  if (!raw.includes("%")) return raw;
+
+// src/server/request-threads/host.ts
+var NO_ABORT = { aborted: false, onAbort: () => void 0 };
+function isRelayRequest(message) {
+  if (typeof message !== "object" || message === null) return false;
+  const { type, requestId } = message;
+  if (type === "touch") return true;
+  return typeof requestId === "number" && (type === "request" || type === "authorize" || type === "embed");
+}
+async function answerRequest(handlers, request) {
+  const captured = createCapturingResponse(request.hookContext?.remoteAddress ?? "");
+  const ctx = {
+    res: captured.sink,
+    params: request.params,
+    query: new URLSearchParams(request.query),
+    contentType: request.contentType,
+    rawBody: request.rawBody === null ? null : Buffer.from(request.rawBody),
+    abort: NO_ABORT,
+    hookContext: request.hookContext
+  };
   try {
-    return decodeURIComponent(raw);
+    await handlers[request.route](ctx);
   } catch {
-    return null;
+    sendError(ctx.res, 500, ServerErrorCodes.INTERNAL_ERROR, "An unexpected error occurred");
   }
+  captured.finishUnanswered();
+  return toRelayedResponse(request.requestId, await captured.done);
 }
-function isDenial(value) {
-  return typeof value === "object" && value !== null && "status" in value;
+async function answerAuthorize(authorize, request) {
+  if (authorize === void 0) {
+    return { type: "authorized", requestId: request.requestId, denial: null, hookError: false };
+  }
+  const authorization = await authorize(request.context);
+  if (authorization.allowed) {
+    return { type: "authorized", requestId: request.requestId, denial: null, hookError: false };
+  }
+  return {
+    type: "authorized",
+    requestId: request.requestId,
+    denial: authorization.denial,
+    hookError: authorization.denial === null
+  };
 }
-async function runHook(res, ctx, hook) {
+async function answerEmbed(core, request) {
   try {
-    const result = await hook(ctx);
-    if (isDenial(result)) {
-      sendError(res, result.status, result.code, result.message);
-      return false;
+    const entry = core.requireIndex(request.indexName);
+    const resolved = await resolveVectorText(
+      { vector: request.vector },
+      entry.embeddingAdapter,
+      core.abortController.signal,
+      entry.embeddingAdapterName
+    );
+    const value = resolved.vector?.value;
+    return {
+      type: "embedded",
+      requestId: request.requestId,
+      value: value === void 0 ? null : Array.from(value),
+      error: null
+    };
+  } catch (err) {
+    const error = err instanceof NarsilError ? serializeNarsilError(err) : { code: "INTERNAL_ERROR", message: err instanceof Error ? err.message : String(err) };
+    return { type: "embedded", requestId: request.requestId, value: null, error };
+  }
+}
+function touchIntervalFor(copyIdleTimeoutMs) {
+  return Math.min(MAX_INDEX_TOUCH_INTERVAL_MS, Math.floor(copyIdleTimeoutMs / INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT));
+}
+async function startRequestThreads(options) {
+  const found = acceptorOf(options.app);
+  if (found === null) return null;
+  const acceptor = found;
+  const { core, handlers, authorize } = options;
+  const searchHooks = core.pluginRegistry.hasHooks("beforeSearch") || core.pluginRegistry.hasHooks("afterSearch");
+  const touchIntervalMs = touchIntervalFor(core.orchestrator.copyIdleTimeoutMs());
+  const threads = /* @__PURE__ */ new Map();
+  let stopped = false;
+  function relayFrom(port) {
+    port.on("message", (message) => {
+      if (!isRelayRequest(message)) return;
+      if (message.type === "touch") {
+        core.orchestrator.noteAccess(message.indexName);
+        return;
+      }
+      const reply = message.type === "request" ? answerRequest(handlers, message) : message.type === "authorize" ? answerAuthorize(authorize, message) : answerEmbed(core, message);
+      void reply.then((answer) => port.postMessage(answer));
+    });
+  }
+  async function stopThread(workerId, thread) {
+    try {
+      acceptor.removeChildAppDescriptor(thread.descriptor);
+    } catch {
     }
-    return true;
-  } catch {
-    sendError(res, 500, ServerErrorCodes.HOOK_ERROR, "The onRequest hook threw an error");
-    return false;
+    thread.port.close();
+    clearGateSlot(options.gate, gateSlotOfWorker(workerId));
+    await thread.executor.execute({ type: "stopServing", requestId: `stop-serving-${workerId}` }).catch(() => void 0);
   }
-}
-function createRouteRunner(deps) {
-  const gate = new ConcurrencyGate(deps.maxConcurrentRequests);
-  const { onRequest, writeCors } = deps;
-  return (handler, opts) => {
-    const paramCount = opts.paramCount ?? 0;
-    const needsBody = opts.needsBody ?? false;
-    const useHook = Boolean(onRequest) && !opts.skipHooks;
-    const gated = !opts.skipHooks;
-    return (res, req) => {
-      const params = [];
-      let malformed = null;
-      for (let i = 0; i < paramCount; i++) {
-        const decoded = decodePathParameter(req.getParameter(i) ?? "");
-        if (decoded === null) {
-          malformed = req.getParameter(i) ?? "";
-          break;
-        }
-        params.push(decoded);
-      }
-      const query = new URLSearchParams(req.getQuery() ?? "");
-      const contentType = req.getHeader("content-type");
-      let hookCtx = null;
-      if (useHook) {
-        const headers = {};
-        req.forEach((key, value) => {
-          headers[key] = value;
-        });
-        hookCtx = {
-          method: req.getMethod(),
-          path: req.getUrl(),
-          headers,
-          remoteAddress: Buffer.from(res.getRemoteAddressAsText()).toString()
-        };
-      }
-      if (writeCors) writeCors(res, req);
-      const abort = initAbortHandler(res);
-      if (malformed !== null) {
-        sendError(
-          res,
-          400,
-          ServerErrorCodes.INVALID_REQUEST,
-          "A path segment holds a percent-escape the server cannot decode",
-          { segment: malformed }
+  const listener = {
+    async onWorkerReady(workerId, executor) {
+      if (stopped) return;
+      const channel = new MessageChannel();
+      relayFrom(channel.port2);
+      let result;
+      try {
+        result = await executor.execute(
+          {
+            type: "serveRequests",
+            requestId: `serve-${workerId}`,
+            settings: {
+              port: channel.port1,
+              gate: options.gate,
+              gateSlot: gateSlotOfWorker(workerId),
+              maxConcurrentRequests: options.limits.maxConcurrentRequests,
+              touchIntervalMs,
+              cors: options.cors,
+              limits: options.limits,
+              build: options.build,
+              authorizes: authorize !== void 0,
+              searchHooks
+            }
+          },
+          [channel.port1]
         );
+      } catch (err) {
+        channel.port2.close();
+        console.warn(`Worker ${workerId} could not start taking requests:`, err);
         return;
       }
-      const bodyPromise = needsBody ? readBody(res, opts.maxBytes, abort) : Promise.resolve(null);
-      const hookPromise = hookCtx && onRequest ? runHook(res, hookCtx, onRequest) : Promise.resolve(true);
-      Promise.all([bodyPromise, hookPromise]).then(async ([rawBody, allowed]) => {
-        if (abort.aborted || !allowed) return;
-        if (gated && !gate.tryAcquire()) {
-          sendError(res, 429, ServerErrorCodes.TOO_MANY_REQUESTS, "The server is at capacity; retry shortly");
-          return;
-        }
-        try {
-          await handler({ res, params, query, contentType, rawBody, abort });
-        } catch (err) {
-          if (!abort.aborted) {
-            sendError(res, 500, ServerErrorCodes.INTERNAL_ERROR, "An unexpected error occurred");
-          }
-        } finally {
-          if (gated) gate.release();
-        }
-      }).catch(() => {
-      });
-    };
+      const thread = { descriptor: result.descriptor, port: channel.port2, executor };
+      if (stopped) {
+        await stopThread(workerId, thread);
+        return;
+      }
+      acceptor.addChildAppDescriptor(result.descriptor);
+      threads.set(workerId, thread);
+    },
+    onWorkerGone(workerId) {
+      const thread = threads.get(workerId);
+      if (thread === void 0) return;
+      threads.delete(workerId);
+      try {
+        acceptor.removeChildAppDescriptor(thread.descriptor);
+      } catch {
+      }
+      thread.port.close();
+      clearGateSlot(options.gate, gateSlotOfWorker(workerId));
+    }
   };
-}
-
-// src/server/runtime.ts
-var cached = null;
-async function loadUWebSockets() {
-  if (cached) return cached;
-  try {
-    const mod = await import('uWebSockets.js');
-    const resolved = typeof mod.App === "function" ? mod : mod.default;
-    if (!resolved || typeof resolved.App !== "function") {
-      throw new Error("uWebSockets.js did not expose an App factory");
+  await core.orchestrator.serveRequestsOnWorkers(listener);
+  return {
+    get threadCount() {
+      return threads.size;
+    },
+    async stop() {
+      stopped = true;
+      core.orchestrator.stopRequestThreads();
+      const stopping = [...threads.entries()].map(([workerId, thread]) => {
+        threads.delete(workerId);
+        return stopThread(workerId, thread);
+      });
+      await Promise.all(stopping);
     }
-    cached = resolved;
-    return resolved;
-  } catch (err) {
-    throw new NarsilError(
-      ErrorCodes.CONFIG_INVALID,
-      "The `uWebSockets.js` package is required to run the Narsil HTTP server. Install it with `pnpm add github:uNetworking/uWebSockets.js#v20.58.0` (or the npm or yarn equivalent).",
-      { cause: err instanceof Error ? err.message : String(err) }
-    );
-  }
+  };
 }
 
 // src/server/task-store.ts
@@ -1672,21 +1196,79 @@ function assertSecureBinding(host, options) {
     { host }
   );
 }
+function mainThreadHandlers(deps) {
+  const idx = createIndexHandlers(deps);
+  const doc = createDocumentHandlers(deps);
+  const search = createSearchHandlers(deps);
+  const admin = createAdminHandlers(deps);
+  const health = createHealthHandlers(deps);
+  const cluster = createClusterHandlers(deps);
+  const version = createVersionHandler(deps);
+  const capabilities = createCapabilitiesHandler();
+  return {
+    livez: health.livez,
+    readyz: health.readyz,
+    version: version.report,
+    capabilities: capabilities.report,
+    clusterTopology: cluster.topology,
+    clusterAllocation: cluster.allocation,
+    memory: admin.memory,
+    listTasks: admin.listTasks,
+    getTask: admin.getTask,
+    cancelTask: admin.cancelTask,
+    createIndex: idx.create,
+    listIndexes: idx.list,
+    dropIndex: idx.drop,
+    indexStats: idx.stats,
+    indexPartitions: idx.partitions,
+    clearIndex: idx.clear,
+    openIndex: idx.open,
+    closeIndex: idx.close,
+    insert: doc.insert,
+    batch: doc.batch,
+    importNdjson: createImportHandler(deps),
+    put: doc.put,
+    patch: doc.patch,
+    remove: doc.remove,
+    waitForWrites: doc.waitForWrites,
+    search: search.search,
+    preflight: search.preflight,
+    suggest: search.suggest,
+    get: doc.get,
+    exists: doc.exists,
+    count: doc.count,
+    list: doc.list,
+    multiGet: doc.multiGet,
+    checkpoint: admin.checkpoint,
+    rebuildAnalysis: admin.rebuildAnalysis,
+    snapshot: admin.snapshot,
+    vectorMaintenance: admin.vectorMaintenance,
+    compact: admin.compact,
+    optimize: admin.optimize,
+    rebalance: admin.rebalance,
+    partitionConfig: admin.partitionConfig,
+    restore: admin.restore
+  };
+}
 var NarsilHttpServer = class {
   host;
   port;
   options;
+  engine;
   deps;
   uws = null;
   listenSocket = null;
   ready = false;
+  threads = null;
   constructor(engine, options = {}) {
     this.host = options.host ?? "127.0.0.1";
     this.port = options.port ?? 9876;
     this.options = options;
+    this.engine = engine;
     for (const [name, adapter] of Object.entries(options.embeddingAdapters ?? {})) {
       engine.registerEmbeddingAdapter(name, adapter);
     }
+    engineCoreOf(engine)?.orchestrator.shareMainThread();
     const taskStore = options.taskStore ?? new InMemoryTaskStore();
     const instanceId = options.instanceId ?? randomUUID();
     const limits = resolveLimits(options.limits);
@@ -1704,7 +1286,7 @@ var NarsilHttpServer = class {
     const uws = await loadUWebSockets();
     this.uws = uws;
     const app = uws.App();
-    this.registerRoutes(app);
+    await this.registerRoutes(app);
     await new Promise((resolve, reject) => {
       app.listen(this.host, this.port, (socket) => {
         if (socket) {
@@ -1724,121 +1306,43 @@ var NarsilHttpServer = class {
       this.uws.us_listen_socket_close(this.listenSocket);
       this.listenSocket = null;
     }
+    if (this.threads !== null) {
+      const threads = this.threads;
+      this.threads = null;
+      await threads.stop();
+    }
   }
   get listeningPort() {
     if (!this.listenSocket || !this.uws) return -1;
     return this.uws.us_socket_local_port(this.listenSocket);
   }
-  registerRoutes(app) {
+  get requestThreadCount() {
+    return this.threads?.threadCount ?? 0;
+  }
+  async registerRoutes(app) {
     const cors = resolveCors(this.options.cors);
+    const authorize = this.options.onRequest ? authorizerFor(this.options.onRequest) : void 0;
+    const core = engineCoreOf(this.engine);
+    const threadCount = core === void 0 ? 0 : core.orchestrator.requestThreadCount();
+    const gate = createSharedGateBuffer(gateSlotOfWorker(threadCount));
+    const { limits, build } = this.deps;
+    const handlers = mainThreadHandlers(this.deps);
     const run = createRouteRunner({
-      onRequest: this.options.onRequest,
-      maxConcurrentRequests: this.deps.limits.maxConcurrentRequests,
+      authorize,
+      gate: createSharedRequestGate(gate, limits.maxConcurrentRequests, MAIN_THREAD_GATE_SLOT),
       writeCors: cors ? corsWriter(cors) : void 0
     });
-    const { maxBodyBytes, maxImportBytes } = this.deps.limits;
-    const idx = createIndexHandlers(this.deps);
-    const doc = createDocumentHandlers(this.deps);
-    const search = createSearchHandlers(this.deps);
-    const admin = createAdminHandlers(this.deps);
-    const health = createHealthHandlers(this.deps);
-    const cluster = createClusterHandlers(this.deps);
-    const version = createVersionHandler(this.deps);
-    const capabilities = createCapabilitiesHandler();
-    const importNdjson = createImportHandler(this.deps);
-    const json = (handler, opts) => run(handler, opts);
-    if (cors) {
-      app.options("/*", (res, req) => {
-        const origin = req.getHeader("origin");
-        res.cork(() => {
-          res.writeStatus("204 No Content");
-          writeCorsOrigin(res, cors, origin);
-          res.writeHeader("Access-Control-Allow-Methods", cors.methods).writeHeader("Access-Control-Allow-Headers", cors.headers).writeHeader("Access-Control-Max-Age", "86400").endWithoutBody();
-        });
-      });
+    registerServerRoutes(app, run, handlers, limits, cors);
+    if (core === void 0 || !detectRuntime().supportsWorkerThreads) return;
+    try {
+      this.threads = await startRequestThreads({ core, app, handlers, authorize, gate, limits, build, cors });
+    } catch (err) {
+      console.warn("The server could not start request threads, so the main thread answers every request:", err);
     }
-    app.get("/livez", json(health.livez, { maxBytes: 0, skipHooks: true }));
-    app.get("/readyz", json(health.readyz, { maxBytes: 0, skipHooks: true }));
-    app.get("/health", json(health.livez, { maxBytes: 0, skipHooks: true }));
-    app.get("/version", json(version.report, { maxBytes: 0, skipHooks: true }));
-    app.get("/capabilities", json(capabilities.report, { maxBytes: 0, skipHooks: true }));
-    app.get("/cluster", json(cluster.topology, { maxBytes: 0 }));
-    app.get("/stats/memory", json(admin.memory, { maxBytes: 0 }));
-    app.get("/tasks", json(admin.listTasks, { maxBytes: 0 }));
-    app.get("/tasks/:id", json(admin.getTask, { paramCount: 1, maxBytes: 0 }));
-    app.post("/tasks/:id/_cancel", json(admin.cancelTask, { paramCount: 1, maxBytes: 0 }));
-    app.post("/indexes", json(idx.create, { needsBody: true, maxBytes: maxBodyBytes }));
-    app.get("/indexes", json(idx.list, { maxBytes: 0 }));
-    app.del("/indexes/:name", json(idx.drop, { paramCount: 1, maxBytes: 0 }));
-    app.get("/indexes/:name/stats", json(idx.stats, { paramCount: 1, maxBytes: 0 }));
-    app.get("/indexes/:name/partitions", json(idx.partitions, { paramCount: 1, maxBytes: 0 }));
-    app.get("/indexes/:name/cluster", json(cluster.allocation, { paramCount: 1, maxBytes: 0 }));
-    app.post("/indexes/:name/_clear", json(idx.clear, { paramCount: 1, maxBytes: 0 }));
-    app.post("/indexes/:name/_open", json(idx.open, { paramCount: 1, maxBytes: 0 }));
-    app.post("/indexes/:name/_close", json(idx.close, { paramCount: 1, maxBytes: 0 }));
-    app.get("/indexes/:name/count", json(doc.count, { paramCount: 1, maxBytes: 0 }));
-    app.post("/indexes/:name/documents", json(doc.insert, { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes }));
-    app.post(
-      "/indexes/:name/documents/_batch",
-      json(doc.batch, { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes })
-    );
-    app.post(
-      "/indexes/:name/documents/_list",
-      json(doc.list, { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes })
-    );
-    app.post(
-      "/indexes/:name/documents/_multi-get",
-      json(doc.multiGet, { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes })
-    );
-    app.post(
-      "/indexes/:name/documents/_import",
-      json(importNdjson, { paramCount: 1, needsBody: true, maxBytes: maxImportBytes })
-    );
-    app.get("/indexes/:name/documents/:id", json(doc.get, { paramCount: 2, maxBytes: 0 }));
-    app.get("/indexes/:name/documents/:id/_exists", json(doc.exists, { paramCount: 2, maxBytes: 0 }));
-    app.put("/indexes/:name/documents/:id", json(doc.put, { paramCount: 2, needsBody: true, maxBytes: maxBodyBytes }));
-    app.patch(
-      "/indexes/:name/documents/:id",
-      json(doc.patch, { paramCount: 2, needsBody: true, maxBytes: maxBodyBytes })
-    );
-    app.del("/indexes/:name/documents/:id", json(doc.remove, { paramCount: 2, maxBytes: 0 }));
-    app.post("/indexes/:name/search", json(search.search, { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes }));
-    app.post(
-      "/indexes/:name/search/preflight",
-      json(search.preflight, { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes })
-    );
-    app.post("/indexes/:name/suggest", json(search.suggest, { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes }));
-    app.post("/indexes/:name/_checkpoint", json(admin.checkpoint, { paramCount: 1, maxBytes: 0 }));
-    app.post("/indexes/:name/_rebuild-analysis", json(admin.rebuildAnalysis, { paramCount: 1, maxBytes: 0 }));
-    app.get("/indexes/:name/snapshot", json(admin.snapshot, { paramCount: 1, maxBytes: 0 }));
-    app.get("/indexes/:name/vector-maintenance", json(admin.vectorMaintenance, { paramCount: 1, maxBytes: 0 }));
-    app.post(
-      "/indexes/:name/vectors/_compact",
-      json(admin.compact, { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes })
-    );
-    app.post(
-      "/indexes/:name/vectors/_optimize",
-      json(admin.optimize, { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes })
-    );
-    app.post(
-      "/indexes/:name/_rebalance",
-      json(admin.rebalance, { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes })
-    );
-    app.post(
-      "/indexes/:name/partition-config",
-      json(admin.partitionConfig, { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes })
-    );
-    app.post(
-      "/indexes/:name/restore",
-      json(admin.restore, { paramCount: 1, needsBody: true, maxBytes: maxImportBytes })
-    );
-    app.any("/*", (res) => {
-      sendError(res, 404, ServerErrorCodes.NOT_FOUND, "Route not found");
-    });
   }
 };
 function createServer(engine, options) {
   return new NarsilHttpServer(engine, options);
 }
 
-export { ASYNC_IMPORT_CAPABILITY, INDEX_LIFECYCLE_CAPABILITY, InMemoryTaskStore, REBUILD_ANALYSIS_CAPABILITY, SERVER_CAPABILITIES, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, createServer, httpStatusForNarsilError };
+export { InMemoryTaskStore, createServer };