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

package/dist/chunk-CV5H7XL7.mjs

@@ -0,0 +1,876 @@
+import { MAX_SORT_FIELDS } from './chunk-CBLS46IE.mjs';
+import { ServerErrorCodes, NarsilError, ErrorCodes } from './chunk-P4ELXVJQ.mjs';
+
+// 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/concurrency-gate.ts
+var MAIN_THREAD_GATE_SLOT = 0;
+function gateSlotOfWorker(workerId) {
+  return workerId + 1;
+}
+function createSharedGateBuffer(slotCount) {
+  return new SharedArrayBuffer(slotCount * Int32Array.BYTES_PER_ELEMENT);
+}
+function clearGateSlot(buffer, slot) {
+  const counters = new Int32Array(buffer);
+  if (slot >= 0 && slot < counters.length) Atomics.store(counters, slot, 0);
+}
+function createSharedRequestGate(buffer, max, slot) {
+  const counters = new Int32Array(buffer);
+  function inFlight() {
+    let total = 0;
+    for (let at = 0; at < counters.length; at++) total += Atomics.load(counters, at);
+    return total;
+  }
+  return {
+    tryAcquire() {
+      if (max <= 0) return true;
+      if (inFlight() >= max) return false;
+      Atomics.add(counters, slot, 1);
+      if (inFlight() <= max) return true;
+      Atomics.sub(counters, slot, 1);
+      return false;
+    },
+    release() {
+      if (max <= 0) return;
+      if (Atomics.load(counters, slot) > 0) Atomics.sub(counters, slot, 1);
+    }
+  };
+}
+
+// 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/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 MAX_INDEX_TOUCH_INTERVAL_MS = 1e3;
+var INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT = 4;
+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/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, headers) {
+  if (abort.aborted) return;
+  const totalSize = body.byteLength;
+  res.cork(() => {
+    res.writeStatus(statusLine(status));
+    for (const [key, value] of headers) res.writeHeader(key, value);
+    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, [["Content-Type", "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, [["Content-Type", "application/octet-stream"]]);
+}
+function sendRelayed(res, abort, status, headers, body) {
+  if (abort.aborted) return;
+  if (body.byteLength >= RESPONSE_STREAM_THRESHOLD_BYTES) {
+    streamBody(res, abort, body, status, headers);
+    return;
+  }
+  res.cork(() => {
+    res.writeStatus(statusLine(status));
+    for (const [key, value] of headers) res.writeHeader(key, value);
+    res.end(body);
+  });
+}
+
+// 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 }
+    }
+  };
+}
+
+// src/server/handlers/document-reads.ts
+function createDocumentReadHandlers(deps) {
+  const { engine, limits } = deps;
+  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 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;
+    }
+    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));
+    } catch (err) {
+      respondError(ctx, err);
+    }
+  }
+  return { get, exists, count, multiGet, list };
+}
+function indexDocNotFound(docId) {
+  return new NarsilError(ErrorCodes.DOC_NOT_FOUND, `Document "${docId}" not found`, { docId });
+}
+
+// src/server/request.ts
+function initAbortHandler(res) {
+  const listeners = [];
+  let aborted = false;
+  res.onAborted(() => {
+    aborted = true;
+    for (const fn of listeners) fn();
+  });
+  return {
+    get aborted() {
+      return aborted;
+    },
+    onAbort(fn) {
+      if (aborted) fn();
+      else listeners.push(fn);
+    }
+  };
+}
+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 decodePathParameter(raw) {
+  if (!raw.includes("%")) return raw;
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    return null;
+  }
+}
+function isDenial(value) {
+  return typeof value === "object" && value !== null && "status" in value;
+}
+function authorizerFor(hook) {
+  return async (context) => {
+    try {
+      const result = await hook(context);
+      if (isDenial(result)) return { allowed: false, denial: result };
+      return { allowed: true };
+    } catch {
+      return { allowed: false, denial: null };
+    }
+  };
+}
+function sendDenial(res, authorization) {
+  if (authorization.allowed) return;
+  if (authorization.denial === null) {
+    sendError(res, 500, ServerErrorCodes.HOOK_ERROR, "The onRequest hook threw an error");
+    return;
+  }
+  sendError(res, authorization.denial.status, authorization.denial.code, authorization.denial.message);
+}
+function createRouteRunner(deps) {
+  const { authorize, gate, writeCors } = deps;
+  return (handler, opts) => {
+    const paramCount = opts.paramCount ?? 0;
+    const needsBody = opts.needsBody ?? false;
+    const useHook = authorize !== void 0 && !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 hookContext = null;
+      if (useHook) {
+        const headers = {};
+        req.forEach((key, value) => {
+          headers[key] = value;
+        });
+        hookContext = {
+          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 }
+        );
+        return;
+      }
+      const bodyPromise = needsBody ? readBody(res, opts.maxBytes, abort) : Promise.resolve(null);
+      const hookPromise = hookContext !== null && authorize !== void 0 ? authorize(hookContext) : Promise.resolve({ allowed: true });
+      Promise.all([bodyPromise, hookPromise]).then(async ([rawBody, authorization]) => {
+        if (abort.aborted) return;
+        if (!authorization.allowed) {
+          sendDenial(res, authorization);
+          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, hookContext });
+        } catch (err) {
+          if (!abort.aborted) {
+            sendError(res, 500, ServerErrorCodes.INTERNAL_ERROR, "An unexpected error occurred");
+          }
+        } finally {
+          if (gated) gate.release();
+        }
+      }).catch(() => {
+      });
+    };
+  };
+}
+
+// src/server/routes.ts
+function serverRoutes(limits) {
+  const { maxBodyBytes, maxImportBytes } = limits;
+  const probe = { maxBytes: 0, skipHooks: true };
+  const bare = { maxBytes: 0 };
+  const named = { paramCount: 1, maxBytes: 0 };
+  const namedBody = { paramCount: 1, needsBody: true, maxBytes: maxBodyBytes };
+  const document = { paramCount: 2, maxBytes: 0 };
+  const documentBody = { paramCount: 2, needsBody: true, maxBytes: maxBodyBytes };
+  return [
+    { method: "get", path: "/livez", handler: "livez", options: probe },
+    { method: "get", path: "/readyz", handler: "readyz", options: probe },
+    { method: "get", path: "/health", handler: "livez", options: probe },
+    { method: "get", path: "/version", handler: "version", options: probe },
+    { method: "get", path: "/capabilities", handler: "capabilities", options: probe },
+    { method: "get", path: "/cluster", handler: "clusterTopology", options: bare },
+    { method: "get", path: "/stats/memory", handler: "memory", options: bare },
+    { method: "get", path: "/tasks", handler: "listTasks", options: bare },
+    { method: "get", path: "/tasks/:id", handler: "getTask", options: named },
+    { method: "post", path: "/tasks/:id/_cancel", handler: "cancelTask", options: named },
+    { method: "post", path: "/indexes", handler: "createIndex", options: { needsBody: true, maxBytes: maxBodyBytes } },
+    { method: "get", path: "/indexes", handler: "listIndexes", options: bare },
+    { method: "del", path: "/indexes/:name", handler: "dropIndex", options: named },
+    { method: "get", path: "/indexes/:name/stats", handler: "indexStats", options: named },
+    { method: "get", path: "/indexes/:name/partitions", handler: "indexPartitions", options: named },
+    { method: "get", path: "/indexes/:name/cluster", handler: "clusterAllocation", options: named },
+    { method: "post", path: "/indexes/:name/_clear", handler: "clearIndex", options: named },
+    { method: "post", path: "/indexes/:name/_open", handler: "openIndex", options: named },
+    { method: "post", path: "/indexes/:name/_close", handler: "closeIndex", options: named },
+    { method: "get", path: "/indexes/:name/count", handler: "count", options: named },
+    { method: "post", path: "/indexes/:name/documents", handler: "insert", options: namedBody },
+    { method: "post", path: "/indexes/:name/documents/_batch", handler: "batch", options: namedBody },
+    { method: "post", path: "/indexes/:name/documents/_list", handler: "list", options: namedBody },
+    { method: "post", path: "/indexes/:name/documents/_multi-get", handler: "multiGet", options: namedBody },
+    {
+      method: "post",
+      path: "/indexes/:name/documents/_import",
+      handler: "importNdjson",
+      options: { paramCount: 1, needsBody: true, maxBytes: maxImportBytes }
+    },
+    { method: "post", path: "/indexes/:name/_wait-for-writes", handler: "waitForWrites", options: named },
+    { method: "get", path: "/indexes/:name/documents/:id", handler: "get", options: document },
+    { method: "get", path: "/indexes/:name/documents/:id/_exists", handler: "exists", options: document },
+    { method: "put", path: "/indexes/:name/documents/:id", handler: "put", options: documentBody },
+    { method: "patch", path: "/indexes/:name/documents/:id", handler: "patch", options: documentBody },
+    { method: "del", path: "/indexes/:name/documents/:id", handler: "remove", options: document },
+    { method: "post", path: "/indexes/:name/search", handler: "search", options: namedBody },
+    { method: "post", path: "/indexes/:name/search/preflight", handler: "preflight", options: namedBody },
+    { method: "post", path: "/indexes/:name/suggest", handler: "suggest", options: namedBody },
+    { method: "post", path: "/indexes/:name/_checkpoint", handler: "checkpoint", options: named },
+    { method: "post", path: "/indexes/:name/_rebuild-analysis", handler: "rebuildAnalysis", options: named },
+    { method: "get", path: "/indexes/:name/snapshot", handler: "snapshot", options: named },
+    { method: "get", path: "/indexes/:name/vector-maintenance", handler: "vectorMaintenance", options: named },
+    { method: "post", path: "/indexes/:name/vectors/_compact", handler: "compact", options: namedBody },
+    { method: "post", path: "/indexes/:name/vectors/_optimize", handler: "optimize", options: namedBody },
+    { method: "post", path: "/indexes/:name/_rebalance", handler: "rebalance", options: namedBody },
+    { method: "post", path: "/indexes/:name/partition-config", handler: "partitionConfig", options: namedBody },
+    {
+      method: "post",
+      path: "/indexes/:name/restore",
+      handler: "restore",
+      options: { paramCount: 1, needsBody: true, maxBytes: maxImportBytes }
+    }
+  ];
+}
+function registerServerRoutes(app, run, handlers, limits, cors) {
+  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();
+      });
+    });
+  }
+  for (const route of serverRoutes(limits)) {
+    app[route.method](route.path, run(handlers[route.handler], route.options));
+  }
+  app.any("/*", (res) => {
+    sendError(res, 404, ServerErrorCodes.NOT_FOUND, "Route not found");
+  });
+}
+
+// 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");
+    }
+    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/request-threads/acceptor.ts
+function acceptorOf(app) {
+  const candidate = app;
+  if (typeof candidate.addChildAppDescriptor !== "function") return null;
+  if (typeof candidate.removeChildAppDescriptor !== "function") return null;
+  return candidate;
+}
+function childAppOf(app) {
+  const candidate = app;
+  if (typeof candidate.getDescriptor !== "function" || typeof candidate.close !== "function") return null;
+  return candidate;
+}
+
+export { ASYNC_IMPORT_CAPABILITY, DEFAULT_IMPORT_BATCH_SIZE, DEFAULT_MAX_BODY_BYTES, DEFAULT_MAX_CONCURRENT_REQUESTS, DEFAULT_MAX_CONCURRENT_TASKS, DEFAULT_MAX_FETCH_DOCUMENTS, DEFAULT_MAX_IMPORT_BYTES, DEFAULT_MAX_IMPORT_ERRORS, DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_RESULT_WINDOW, DEFAULT_MAX_RETAINED_TASKS, DEFAULT_MAX_TASK_PAGE_SIZE, DEFAULT_TASK_PAGE_SIZE, INDEX_LIFECYCLE_CAPABILITY, INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT, MAIN_THREAD_GATE_SLOT, MAX_INDEX_TOUCH_INTERVAL_MS, REBUILD_ANALYSIS_CAPABILITY, RUNNING_TASK_TTL_MS, SERVER_CAPABILITIES, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, TASK_PROGRESS_WRITE_INTERVAL_MS, TERMINAL_TASK_TTL_MS, acceptorOf, authorizerFor, badRequest, childAppOf, clearGateSlot, corsWriter, createDocumentReadHandlers, createRouteRunner, createSharedGateBuffer, createSharedRequestGate, gateSlotOfWorker, httpStatusForNarsilError, loadUWebSockets, parseJson, parseJsonOptional, parseTaskListQuery, registerServerRoutes, rejectInvalid, resolveCors, respondError, respondJson, sendBinary, sendError, sendRelayed, serializeBatchResult, serializeNarsilError, serverRoutes, validateBatch, validateCreateIndex, validateDocumentBody, validateQuery, validateRebalance, validateSuggest };