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

package/dist/{client-C5BkUqB8.d.ts → client-CBOVHdjp.d.ts}

@@ -1,5 +1,5 @@
-import { V as VectorMaintenanceResult, M as MemoryStats, B as BatchResult, L as ListParams, g as ListResult, I as IndexInfo, f as IndexStats, P as PartitionStatsResult, Q as QueryParams, e as QueryResult, h as PreflightResult, i as SuggestParams, j as SuggestResult } from './search-DDHjfXhJ.js';
-import { P as PartitionConfig, A as AnyDocument, b as InsertOptions } from './schema-B7juWg8Q.js';
+import { P as PartitionConfig, A as AnyDocument, b as InsertOptions, W as WriteOptions } from './schema-BqRx9t4E.js';
+import { V as VectorMaintenanceResult, M as MemoryStats, B as BatchResult, L as ListParams, g as ListResult, I as IndexInfo, f as IndexStats, P as PartitionStatsResult, Q as QueryParams, e as QueryResult, h as PreflightResult, i as SuggestParams, j as SuggestResult } from './memory-Bzd5xcEW.js';
 import { e as TaskRecord, b as ImportResult, H as HttpIndexConfig, c as TaskListQuery, T as TaskListPage } from './tasks-Bn4R1NPN.js';
 
 /**
@@ -248,6 +248,8 @@ interface BulkOperations {
      * @param indexName - This names the index holding the documents.
      * @param updates - Each entry names the document to replace and holds its
      * replacement.
+     * @param writeOptions - These per-write settings reach the server, and apply
+     * to the whole batch.
      * @param options - This sets the signal, the deadline, and the headers for
      * this request.
      * @returns The result lists the ids replaced, and each failure with its
@@ -256,17 +258,19 @@ interface BulkOperations {
     updateBatch(indexName: string, updates: Array<{
         docId: string;
         document: AnyDocument;
-    }>, options?: RequestOptions): Promise<BatchResult>;
+    }>, writeOptions?: WriteOptions, options?: RequestOptions): Promise<BatchResult>;
     /**
      * Removes many documents in one request and reports each one's outcome.
      *
      * @param indexName - This names the index holding the documents.
      * @param docIds - These name the documents to remove.
+     * @param writeOptions - These per-write settings reach the server, and apply
+     * to the whole batch.
      * @param options - This sets the signal, the deadline, and the headers for
      * this request.
      * @returns The result lists the ids removed, and each failure with its error.
      */
-    removeBatch(indexName: string, docIds: string[], options?: RequestOptions): Promise<BatchResult>;
+    removeBatch(indexName: string, docIds: string[], writeOptions?: WriteOptions, options?: RequestOptions): Promise<BatchResult>;
     /**
      * Reads many documents by id in one request.
      *
@@ -409,12 +413,14 @@ interface DocumentOperations {
      * @param indexName - This names the index that receives the document.
      * @param docId - This is the id to write at.
      * @param document - Its fields must match the types the schema declares.
+     * @param writeOptions - These per-write settings reach the server, such as
+     * waiting for every worker copy to apply the write.
      * @param options - This sets the signal, the deadline, and the headers for
      * this request.
      * @returns The result names the id, and says whether the write created the
      * document or replaced one.
      */
-    put(indexName: string, docId: string, document: AnyDocument, options?: RequestOptions): Promise<PutResult>;
+    put(indexName: string, docId: string, document: AnyDocument, writeOptions?: WriteOptions, options?: RequestOptions): Promise<PutResult>;
     /**
      * Replaces the stored document at an id.
      *
@@ -422,23 +428,41 @@ interface DocumentOperations {
      * @param docId - This names the document to replace.
      * @param document - This replacement goes through the same schema validation
      * an insert would.
+     * @param writeOptions - These per-write settings reach the server, such as
+     * waiting for every worker copy to apply the write.
      * @param options - This sets the signal, the deadline, and the headers for
      * this request.
      * @throws A `NarsilError` with `DOC_NOT_FOUND` when the index holds no such
      * document.
      */
-    update(indexName: string, docId: string, document: AnyDocument, options?: RequestOptions): Promise<void>;
+    update(indexName: string, docId: string, document: AnyDocument, writeOptions?: WriteOptions, options?: RequestOptions): Promise<void>;
     /**
      * Removes one document.
      *
      * @param indexName - This names the index holding the document.
      * @param docId - This names the document to remove.
+     * @param writeOptions - These per-write settings reach the server, such as
+     * waiting for every worker copy to apply the removal.
      * @param options - This sets the signal, the deadline, and the headers for
      * this request.
      * @throws A `NarsilError` with `DOC_NOT_FOUND` when the index holds no such
      * document.
      */
-    remove(indexName: string, docId: string, options?: RequestOptions): Promise<void>;
+    remove(indexName: string, docId: string, writeOptions?: WriteOptions, options?: RequestOptions): Promise<void>;
+    /**
+     * Resolves once every worker copy of an index on the server has applied
+     * every write that returned before the call.
+     *
+     * A write returns once the server's main copy holds it, and the copies
+     * apply it afterwards, so a query can come back without a write that
+     * returned before it. Call this after a run of writes, or pass `wait: true`
+     * on one write, before a query that has to see them.
+     *
+     * @param indexName - This names the index whose copies have to catch up.
+     * @param options - This sets the signal, the deadline, and the headers for
+     * this request.
+     */
+    waitForWrites(indexName: string, options?: RequestOptions): Promise<void>;
     /**
      * Counts the documents in an index.
      *

package/dist/client.d.ts

@@ -1,10 +1,10 @@
-export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes } from './search-DDHjfXhJ.js';
-export { A as ASYNC_IMPORT_CAPABILITY, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, R as REBUILD_ANALYSIS_CAPABILITY, S as SERVER_CAPABILITIES, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './options-BC68VPoE.js';
+export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes } from './memory-Bzd5xcEW.js';
+export { A as ASYNC_IMPORT_CAPABILITY, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, R as REBUILD_ANALYSIS_CAPABILITY, S as SERVER_CAPABILITIES, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './capabilities-JrVQOwi4.js';
 export { C as CapabilitiesResponse, a as CreateIndexEmbedding, H as HttpIndexConfig, I as ImportError, b as ImportResult, T as TaskListPage, c as TaskListQuery, d as TaskProgress, e as TaskRecord, f as TaskStatus, g as TaskType } from './tasks-Bn4R1NPN.js';
-export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-C5BkUqB8.js';
-import './schema-B7juWg8Q.js';
+export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-CBOVHdjp.js';
+import './schema-BqRx9t4E.js';
 import './adapters-79OIa4xm.js';
-import './config-B-ZI-ft5.js';
-import './config-BZRExglL.js';
-import './types-DsSSjY4d.js';
+import './config-Czh2YNDi.js';
+import './config-OON7IJ_B.js';
+import './types-DXPxaXPO.js';
 import './types-D5OwhtsQ.js';

package/dist/client.mjs

@@ -166,220 +166,10 @@ function encodeJson(value) {
   return JSON.stringify(value, toPlainNumbers);
 }
 
-// src/client/http.ts
-var DEFAULT_TIMEOUT_MS = 3e4;
+// src/client/constants.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
 var NO_TIMEOUT = 0;
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function unrefTimer(timer) {
-  const unrefable = timer;
-  unrefable.unref?.();
-}
-function startDeadline(timeoutMs, caller) {
-  const controller = new AbortController();
-  let expired = false;
-  const abortWithCaller = () => controller.abort();
-  if (caller?.aborted) controller.abort();
-  else caller?.addEventListener("abort", abortWithCaller);
-  let timer;
-  if (timeoutMs > 0 && !controller.signal.aborted) {
-    timer = setTimeout(() => {
-      expired = true;
-      controller.abort();
-    }, timeoutMs);
-    unrefTimer(timer);
-  }
-  return {
-    signal: controller.signal,
-    expired: () => expired,
-    release: () => {
-      if (timer !== void 0) clearTimeout(timer);
-      caller?.removeEventListener("abort", abortWithCaller);
-    }
-  };
-}
-var ResponseTooLargeError = class extends Error {
-  constructor(limitBytes) {
-    super(`The answer passed the ${limitBytes} byte ceiling this client reads`);
-    this.limitBytes = limitBytes;
-  }
-};
-async function readStreamCapped(stream, limitBytes) {
-  const reader = stream.getReader();
-  const chunks = [];
-  let total = 0;
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      total += value.byteLength;
-      if (total > limitBytes) throw new ResponseTooLargeError(limitBytes);
-      chunks.push(value);
-    }
-  } finally {
-    reader.releaseLock();
-    if (total > limitBytes) await stream.cancel().catch(() => void 0);
-  }
-  const body = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return body;
-}
-async function readAnswer(response, limitBytes, wantsBytes) {
-  const stream = response.body;
-  if (limitBytes > 0 && stream !== null && stream !== void 0) {
-    const body = await readStreamCapped(stream, limitBytes);
-    return wantsBytes ? { text: "", bytes: body } : { text: new TextDecoder().decode(body), bytes: null };
-  }
-  if (wantsBytes) {
-    const bytes = new Uint8Array(await response.arrayBuffer());
-    if (limitBytes > 0 && bytes.byteLength > limitBytes) throw new ResponseTooLargeError(limitBytes);
-    return { text: "", bytes };
-  }
-  const text = await response.text();
-  if (limitBytes > 0 && text.length > limitBytes) throw new ResponseTooLargeError(limitBytes);
-  return { text, bytes: null };
-}
-function invalidResponse(message, details) {
-  return new NarsilError(ClientErrorCodes.CLIENT_INVALID_RESPONSE, message, details);
-}
-function errorFromBody(status, payload, url) {
-  const envelope = isRecord(payload) && isRecord(payload.error) ? payload.error : void 0;
-  if (envelope === void 0 || typeof envelope.code !== "string" || typeof envelope.message !== "string") {
-    return invalidResponse(`The server answered HTTP ${status} without a Narsil error envelope`, { url, status });
-  }
-  const details = isRecord(envelope.details) ? envelope.details : {};
-  return new NarsilError(envelope.code, envelope.message, { ...details, status });
-}
-function isAbsoluteUrl(value) {
-  try {
-    new URL(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function normaliseBase(url) {
-  const trimmed = url.trim();
-  if (trimmed.length === 0) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, 'The client needs a server address, and "url" is empty');
-  }
-  if (!trimmed.startsWith("/") && !isAbsoluteUrl(trimmed)) {
-    throw new NarsilError(
-      ErrorCodes.CONFIG_INVALID,
-      `The client cannot read "${trimmed}" as a server address; pass an absolute URL or a path starting with "/"`,
-      { url: trimmed }
-    );
-  }
-  return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
-}
-function withQuery(path, query) {
-  if (query === void 0) return path;
-  const params = new URLSearchParams();
-  for (const [key, value] of Object.entries(query)) {
-    if (value !== void 0) params.set(key, value);
-  }
-  const encoded = params.toString();
-  return encoded.length === 0 ? path : `${path}?${encoded}`;
-}
-function createTransport(options) {
-  const base = normaliseBase(options.url);
-  const send = options.fetch ?? ((input, init) => fetch(input, init));
-  const baseHeaders = { ...options.headers };
-  if (options.apiKey !== void 0 && options.apiKey.length > 0) {
-    baseHeaders.authorization = `Bearer ${options.apiKey}`;
-  }
-  function resolveTimeout(spec) {
-    const perCall = spec.options?.timeoutMs;
-    if (perCall !== void 0) return perCall;
-    if (options.timeoutMs !== void 0) return options.timeoutMs;
-    return spec.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
-  }
-  function resolveResponseCeiling(spec) {
-    const perCall = spec.options?.maxResponseBytes;
-    if (perCall !== void 0) return perCall;
-    return options.maxResponseBytes ?? 0;
-  }
-  async function exchange(spec) {
-    const url = `${base}${withQuery(spec.path, spec.query)}`;
-    const headers = { ...baseHeaders, ...spec.options?.headers };
-    if (spec.contentType !== void 0) headers["content-type"] = spec.contentType;
-    const timeoutMs = resolveTimeout(spec);
-    const deadline = startDeadline(timeoutMs, spec.options?.signal);
-    try {
-      const init = { method: spec.method, headers, signal: deadline.signal };
-      if (spec.body !== void 0) init.body = spec.body;
-      const response = await send(url, init);
-      const wantsBytes = spec.binaryAnswer === true && response.ok;
-      const answer = await readAnswer(response, resolveResponseCeiling(spec), wantsBytes);
-      return { status: response.status, ...answer };
-    } catch (err) {
-      if (err instanceof ResponseTooLargeError) {
-        throw invalidResponse(`The server at ${url} answered more than this client reads: ${err.message}`, {
-          url,
-          maxResponseBytes: err.limitBytes
-        });
-      }
-      if (deadline.expired()) {
-        throw new NarsilError(
-          ClientErrorCodes.CLIENT_REQUEST_TIMEOUT,
-          `The server at ${url} did not answer within ${timeoutMs} ms`,
-          { url, timeoutMs }
-        );
-      }
-      if (spec.options?.signal?.aborted === true) {
-        throw new NarsilError(ClientErrorCodes.CLIENT_REQUEST_ABORTED, `The caller cancelled the request to ${url}`, {
-          url
-        });
-      }
-      throw new NarsilError(
-        ClientErrorCodes.CLIENT_CONNECTION_FAILED,
-        `The client could not reach ${url}: ${describeError(err)}`,
-        { url }
-      );
-    } finally {
-      deadline.release();
-    }
-  }
-  function parse(status, text, path) {
-    if (text.length === 0) return void 0;
-    try {
-      return JSON.parse(text);
-    } catch {
-      throw invalidResponse(`The server answered HTTP ${status} with a body that is not JSON`, { url: path, status });
-    }
-  }
-  async function json(spec) {
-    const { status, text } = await exchange(spec);
-    const payload = parse(status, text, spec.path);
-    if (status >= 200 && status < 300) return payload;
-    throw errorFromBody(status, payload, spec.path);
-  }
-  return {
-    json,
-    async jsonOrNull(spec, absentCode) {
-      try {
-        return await json(spec);
-      } catch (err) {
-        if (err instanceof NarsilError && err.code === absentCode) return null;
-        throw err;
-      }
-    },
-    async binary(spec) {
-      const { status, text, bytes } = await exchange(spec);
-      if (bytes !== null) return bytes;
-      throw errorFromBody(status, parse(status, text, spec.path), spec.path);
-    },
-    async probe(spec) {
-      const { status } = await exchange(spec);
-      return status;
-    }
-  };
-}
+var DEFAULT_TASK_POLL_INTERVAL_MS = 250;
 
 // src/client/paths.ts
 function indexPath(indexName) {
@@ -393,7 +183,7 @@ function taskPath(taskId) {
 }
 
 // src/client/response-shape.ts
-function isRecord2(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function malformed(path, expected) {
@@ -402,27 +192,27 @@ function malformed(path, expected) {
   });
 }
 function readArray(payload, key, path) {
-  if (!isRecord2(payload) || !Array.isArray(payload[key])) throw malformed(path, `"${key}" array`);
+  if (!isRecord(payload) || !Array.isArray(payload[key])) throw malformed(path, `"${key}" array`);
   return payload[key];
 }
 function readNumber(payload, key, path) {
-  if (!isRecord2(payload) || typeof payload[key] !== "number") throw malformed(path, `"${key}" number`);
+  if (!isRecord(payload) || typeof payload[key] !== "number") throw malformed(path, `"${key}" number`);
   return payload[key];
 }
 function readBoolean(payload, key, path) {
-  if (!isRecord2(payload) || typeof payload[key] !== "boolean") throw malformed(path, `"${key}" flag`);
+  if (!isRecord(payload) || typeof payload[key] !== "boolean") throw malformed(path, `"${key}" flag`);
   return payload[key];
 }
 function readString(payload, key, path) {
-  if (!isRecord2(payload) || typeof payload[key] !== "string") throw malformed(path, `"${key}" string`);
+  if (!isRecord(payload) || typeof payload[key] !== "string") throw malformed(path, `"${key}" string`);
   return payload[key];
 }
 function readObject(payload, key, path) {
-  if (!isRecord2(payload) || !isRecord2(payload[key])) throw malformed(path, `"${key}" object`);
+  if (!isRecord(payload) || !isRecord(payload[key])) throw malformed(path, `"${key}" object`);
   return payload[key];
 }
 function readBody(payload, path) {
-  if (!isRecord2(payload)) throw malformed(path, "JSON object");
+  if (!isRecord(payload)) throw malformed(path, "JSON object");
   return payload;
 }
 
@@ -544,11 +334,19 @@ function createBulkOperations(transport) {
         options
       );
     },
-    updateBatch(indexName, updates, options) {
-      return batch(indexName, { action: "update", updates }, options);
+    updateBatch(indexName, updates, writeOptions, options) {
+      return batch(
+        indexName,
+        { action: "update", updates, ...writeOptions === void 0 ? {} : { options: writeOptions } },
+        options
+      );
     },
-    removeBatch(indexName, docIds, options) {
-      return batch(indexName, { action: "delete", docIds }, options);
+    removeBatch(indexName, docIds, writeOptions, options) {
+      return batch(
+        indexName,
+        { action: "delete", docIds, ...writeOptions === void 0 ? {} : { options: writeOptions } },
+        options
+      );
     },
     async getMultiple(indexName, docIds, options) {
       const path = `${indexPath(indexName)}/documents/_multi-get`;
@@ -612,28 +410,36 @@ function createDocumentOperations(transport) {
       const path = `${documentPath(indexName, docId)}/_exists`;
       return readBoolean(await transport.json({ method: "GET", path, options }), "exists", path);
     },
-    async put(indexName, docId, document, options) {
+    async put(indexName, docId, document, writeOptions, options) {
       const path = documentPath(indexName, docId);
       const payload = await transport.json({
         method: "PUT",
         path,
-        body: encodeJson({ document }),
+        body: encodeJson({ document, ...writeOptions === void 0 ? {} : { options: writeOptions } }),
         contentType: "application/json",
         options
       });
       return { id: readString(payload, "id", path), created: readBoolean(payload, "created", path) };
     },
-    async update(indexName, docId, document, options) {
+    async update(indexName, docId, document, writeOptions, options) {
       await transport.json({
         method: "PATCH",
         path: documentPath(indexName, docId),
-        body: encodeJson({ document }),
+        body: encodeJson({ document, ...writeOptions === void 0 ? {} : { options: writeOptions } }),
         contentType: "application/json",
         options
       });
     },
-    async remove(indexName, docId, options) {
-      await transport.json({ method: "DELETE", path: documentPath(indexName, docId), options });
+    async remove(indexName, docId, writeOptions, options) {
+      await transport.json({
+        method: "DELETE",
+        path: documentPath(indexName, docId),
+        ...writeOptions?.wait === true ? { query: { wait: "true" } } : {},
+        options
+      });
+    },
+    async waitForWrites(indexName, options) {
+      await transport.json({ method: "POST", path: `${indexPath(indexName)}/_wait-for-writes`, options });
     },
     async countDocuments(indexName, options) {
       const path = `${indexPath(indexName)}/count`;
@@ -642,6 +448,219 @@ function createDocumentOperations(transport) {
   };
 }
 
+// src/client/http.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unrefTimer(timer) {
+  const unrefable = timer;
+  unrefable.unref?.();
+}
+function startDeadline(timeoutMs, caller) {
+  const controller = new AbortController();
+  let expired = false;
+  const abortWithCaller = () => controller.abort();
+  if (caller?.aborted) controller.abort();
+  else caller?.addEventListener("abort", abortWithCaller);
+  let timer;
+  if (timeoutMs > 0 && !controller.signal.aborted) {
+    timer = setTimeout(() => {
+      expired = true;
+      controller.abort();
+    }, timeoutMs);
+    unrefTimer(timer);
+  }
+  return {
+    signal: controller.signal,
+    expired: () => expired,
+    release: () => {
+      if (timer !== void 0) clearTimeout(timer);
+      caller?.removeEventListener("abort", abortWithCaller);
+    }
+  };
+}
+var ResponseTooLargeError = class extends Error {
+  constructor(limitBytes) {
+    super(`The answer passed the ${limitBytes} byte ceiling this client reads`);
+    this.limitBytes = limitBytes;
+  }
+};
+async function readStreamCapped(stream, limitBytes) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > limitBytes) throw new ResponseTooLargeError(limitBytes);
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+    if (total > limitBytes) await stream.cancel().catch(() => void 0);
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+async function readAnswer(response, limitBytes, wantsBytes) {
+  const stream = response.body;
+  if (limitBytes > 0 && stream !== null && stream !== void 0) {
+    const body = await readStreamCapped(stream, limitBytes);
+    return wantsBytes ? { text: "", bytes: body } : { text: new TextDecoder().decode(body), bytes: null };
+  }
+  if (wantsBytes) {
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (limitBytes > 0 && bytes.byteLength > limitBytes) throw new ResponseTooLargeError(limitBytes);
+    return { text: "", bytes };
+  }
+  const text = await response.text();
+  if (limitBytes > 0 && text.length > limitBytes) throw new ResponseTooLargeError(limitBytes);
+  return { text, bytes: null };
+}
+function invalidResponse(message, details) {
+  return new NarsilError(ClientErrorCodes.CLIENT_INVALID_RESPONSE, message, details);
+}
+function errorFromBody(status, payload, url) {
+  const envelope = isRecord2(payload) && isRecord2(payload.error) ? payload.error : void 0;
+  if (envelope === void 0 || typeof envelope.code !== "string" || typeof envelope.message !== "string") {
+    return invalidResponse(`The server answered HTTP ${status} without a Narsil error envelope`, { url, status });
+  }
+  const details = isRecord2(envelope.details) ? envelope.details : {};
+  return new NarsilError(envelope.code, envelope.message, { ...details, status });
+}
+function isAbsoluteUrl(value) {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normaliseBase(url) {
+  const trimmed = url.trim();
+  if (trimmed.length === 0) {
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, 'The client needs a server address, and "url" is empty');
+  }
+  if (!trimmed.startsWith("/") && !isAbsoluteUrl(trimmed)) {
+    throw new NarsilError(
+      ErrorCodes.CONFIG_INVALID,
+      `The client cannot read "${trimmed}" as a server address; pass an absolute URL or a path starting with "/"`,
+      { url: trimmed }
+    );
+  }
+  return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+}
+function withQuery(path, query) {
+  if (query === void 0) return path;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) params.set(key, value);
+  }
+  const encoded = params.toString();
+  return encoded.length === 0 ? path : `${path}?${encoded}`;
+}
+function createTransport(options) {
+  const base = normaliseBase(options.url);
+  const send = options.fetch ?? ((input, init) => fetch(input, init));
+  const baseHeaders = { ...options.headers };
+  if (options.apiKey !== void 0 && options.apiKey.length > 0) {
+    baseHeaders.authorization = `Bearer ${options.apiKey}`;
+  }
+  function resolveTimeout(spec) {
+    const perCall = spec.options?.timeoutMs;
+    if (perCall !== void 0) return perCall;
+    if (options.timeoutMs !== void 0) return options.timeoutMs;
+    return spec.defaultTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  }
+  function resolveResponseCeiling(spec) {
+    const perCall = spec.options?.maxResponseBytes;
+    if (perCall !== void 0) return perCall;
+    return options.maxResponseBytes ?? 0;
+  }
+  async function exchange(spec) {
+    const url = `${base}${withQuery(spec.path, spec.query)}`;
+    const headers = { ...baseHeaders, ...spec.options?.headers };
+    if (spec.contentType !== void 0) headers["content-type"] = spec.contentType;
+    const timeoutMs = resolveTimeout(spec);
+    const deadline = startDeadline(timeoutMs, spec.options?.signal);
+    try {
+      const init = { method: spec.method, headers, signal: deadline.signal };
+      if (spec.body !== void 0) init.body = spec.body;
+      const response = await send(url, init);
+      const wantsBytes = spec.binaryAnswer === true && response.ok;
+      const answer = await readAnswer(response, resolveResponseCeiling(spec), wantsBytes);
+      return { status: response.status, ...answer };
+    } catch (err) {
+      if (err instanceof ResponseTooLargeError) {
+        throw invalidResponse(`The server at ${url} answered more than this client reads: ${err.message}`, {
+          url,
+          maxResponseBytes: err.limitBytes
+        });
+      }
+      if (deadline.expired()) {
+        throw new NarsilError(
+          ClientErrorCodes.CLIENT_REQUEST_TIMEOUT,
+          `The server at ${url} did not answer within ${timeoutMs} ms`,
+          { url, timeoutMs }
+        );
+      }
+      if (spec.options?.signal?.aborted === true) {
+        throw new NarsilError(ClientErrorCodes.CLIENT_REQUEST_ABORTED, `The caller cancelled the request to ${url}`, {
+          url
+        });
+      }
+      throw new NarsilError(
+        ClientErrorCodes.CLIENT_CONNECTION_FAILED,
+        `The client could not reach ${url}: ${describeError(err)}`,
+        { url }
+      );
+    } finally {
+      deadline.release();
+    }
+  }
+  function parse(status, text, path) {
+    if (text.length === 0) return void 0;
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw invalidResponse(`The server answered HTTP ${status} with a body that is not JSON`, { url: path, status });
+    }
+  }
+  async function json(spec) {
+    const { status, text } = await exchange(spec);
+    const payload = parse(status, text, spec.path);
+    if (status >= 200 && status < 300) return payload;
+    throw errorFromBody(status, payload, spec.path);
+  }
+  return {
+    json,
+    async jsonOrNull(spec, absentCode) {
+      try {
+        return await json(spec);
+      } catch (err) {
+        if (err instanceof NarsilError && err.code === absentCode) return null;
+        throw err;
+      }
+    },
+    async binary(spec) {
+      const { status, text, bytes } = await exchange(spec);
+      if (bytes !== null) return bytes;
+      throw errorFromBody(status, parse(status, text, spec.path), spec.path);
+    },
+    async probe(spec) {
+      const { status } = await exchange(spec);
+      return status;
+    }
+  };
+}
+
 // src/client/indexes.ts
 function createIndexOperations(transport) {
   return {
@@ -746,7 +765,6 @@ function createServerOperations(transport) {
 }
 
 // src/client/tasks.ts
-var DEFAULT_POLL_INTERVAL_MS = 250;
 function isTerminal(record) {
   return record.status === "succeeded" || record.status === "failed" || record.status === "cancelled";
 }
@@ -794,7 +812,7 @@ function createTaskOperations(transport) {
       return readBody(await transport.json({ method: "POST", path, options }), path);
     },
     async waitForTask(taskId, options) {
-      const interval = options?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+      const interval = options?.pollIntervalMs ?? DEFAULT_TASK_POLL_INTERVAL_MS;
       const waitTimeoutMs = options?.waitTimeoutMs ?? 0;
       const startedAt = Date.now();
       let reported = null;