@qvac/sdk 0.19.0 → 0.20.0

package/dist/src/client/api/text-to-speech.js

@@ -3,6 +3,7 @@ import { stream as streamRpc, duplex } from '../rpc/rpc-client.js';
 import { getClientLogger } from '../../logging/index.js';
 import { TextToSpeechStreamFailedError } from '../../utils/errors-client.js';
 import { parseClientInput } from '../parse-input.js';
+import { generateClientRequestId } from './client-request-id.js';
 const logger = getClientLogger();
 /**
  * Fan-out queue that lets multiple consumers iterate the same TTS response
@@ -129,10 +130,11 @@ export class TtsMulticast {
         }
     }
 }
-function buildTtsRequest(params) {
+function buildTtsRequest(params, requestId) {
     return {
         type: 'textToSpeech',
         modelId: params.modelId,
+        requestId,
         inputType: params.inputType,
         text: params.text,
         stream: params.stream,
@@ -155,10 +157,11 @@ function buildTtsRequest(params) {
         ...(params.quality !== undefined && { quality: params.quality })
     };
 }
-function buildTextToSpeechStreamRequest(params) {
+function buildTextToSpeechStreamRequest(params, requestId) {
     return {
         type: 'textToSpeechStream',
         modelId: params.modelId,
+        requestId,
         inputType: params.inputType ?? 'text',
         ...(params.accumulateSentences !== undefined && {
             accumulateSentences: params.accumulateSentences
@@ -189,9 +192,9 @@ function buildTextToSpeechStreamRequest(params) {
  *
  * Three modes selected by `params.stream` and `params.sentenceStream`:
  *
- * - `stream: false` (default) — collect all PCM samples and resolve once via
+ * - `stream: false` — collect all PCM samples and resolve once via
  *   `result.buffer` (`Promise<number[]>`). `bufferStream` is empty.
- * - `stream: true` — yield PCM samples through `result.bufferStream`
+ * - `stream: true` (default) — yield PCM samples through `result.bufferStream`
  *   (`AsyncGenerator<number>`) as they arrive. `buffer` resolves to an empty
  *   array.
  * - `stream: true, sentenceStream: true` — also exposes `result.chunkUpdates`
@@ -203,10 +206,21 @@ function buildTextToSpeechStreamRequest(params) {
  * if the consumer breaks out before the terminal frame, or rejects on a
  * pipeline error. Awaiting `done` is safe even when no stream is iterated.
  *
+ * `result.sampleRate` resolves from the first audio frame (so it can be awaited
+ * before draining the audio); `result.stats` and `result.stopReason` resolve
+ * from the terminal frame. All three resolve — with `undefined` when the run
+ * produced none — rather than reject. In `stream: true` mode (the default) the
+ * run starts lazily: nothing is sent until `bufferStream` is first iterated, so
+ * `done`, `sampleRate`, `stats` and `stopReason` stay pending until then. In
+ * `stream: false` and `sentenceStream: true` modes the run starts immediately.
+ * Read `sampleRate` rather than assuming the engine default: `outputSampleRate`
+ * and the LavaSR enhancer both change it.
+ *
  * @param params - TTS request parameters (see `TtsClientParamsInput`).
  * @param options - Optional RPC options (timeout, profiling, force new connection).
  * @returns A `TextToSpeechStreamResult` with `bufferStream`, `buffer`, `done`,
- *          and (when `sentenceStream: true`) `chunkUpdates`.
+ *          `sampleRate`, `stats`, and (when `sentenceStream: true`)
+ *          `chunkUpdates`.
  * @throws {TextToSpeechStreamFailedError} When `sentenceStream: true` is paired
  *         with `stream: false`, or when the underlying RPC stream errors.
  */
@@ -215,7 +229,11 @@ export function textToSpeech(params, options) {
     if (parsed.sentenceStream && !parsed.stream) {
         throw new TextToSpeechStreamFailedError('textToSpeech: `sentenceStream: true` requires `stream: true`');
     }
-    const request = buildTtsRequest(parsed);
+    // Minted client-side and surfaced synchronously on the result, the same way
+    // `transcribe()` / `completion()` do, so a caller can cancel a run it has
+    // only just started.
+    const requestId = parsed.requestId ?? generateClientRequestId();
+    const request = buildTtsRequest(parsed, requestId);
     if (parsed.stream && parsed.sentenceStream) {
         return sentenceStreamTts(request, options);
     }
@@ -227,15 +245,70 @@ export function textToSpeech(params, options) {
 // Adapts the raw RPC stream into the filtered `TtsResponse` source the
 // multicast expects. Kept here (not inlined) so the multicast can be
 // constructed in tests with a hand-rolled source instead.
-async function* ttsResponseSource(request, options) {
-    for await (const response of streamRpc(request, options)) {
-        if (response.type !== 'textToSpeech')
-            continue;
-        yield response;
+async function* ttsResponseSource(request, options, side) {
+    try {
+        for await (const response of streamRpc(request, options)) {
+            if (response.type !== 'textToSpeech')
+                continue;
+            side.observe(response);
+            yield response;
+        }
     }
+    finally {
+        // Reached on normal end, on error, and when the multicast's pump breaks
+        // out on the terminal frame.
+        side.settle();
+    }
+}
+/** Exported for test use; not part of the public SDK surface. */
+export function createTtsSideChannel() {
+    let resolveSampleRate;
+    let resolveStats;
+    let resolveStopReason;
+    const sampleRate = new Promise((resolve) => {
+        resolveSampleRate = resolve;
+    });
+    const stats = new Promise((resolve) => {
+        resolveStats = resolve;
+    });
+    const stopReason = new Promise((resolve) => {
+        resolveStopReason = resolve;
+    });
+    let seenSampleRate;
+    let latestStats;
+    let seenStopReason;
+    let settled = false;
+    return {
+        sampleRate,
+        stats,
+        stopReason,
+        observe(response) {
+            // Resolve on the FIRST frame that carries a rate, not at end of stream:
+            // a caller opening an audio device wants it before draining the audio.
+            // Promise resolution is idempotent, so settle() can still resolve the
+            // undefined fallback for a run that never reported one.
+            if (seenSampleRate === undefined && response.sampleRate !== undefined) {
+                seenSampleRate = response.sampleRate;
+                resolveSampleRate(seenSampleRate);
+            }
+            if (response.stats !== undefined)
+                latestStats = response.stats;
+            if (response.stopReason !== undefined)
+                seenStopReason = response.stopReason;
+        },
+        settle() {
+            if (settled)
+                return;
+            settled = true;
+            resolveSampleRate(seenSampleRate);
+            resolveStats(latestStats);
+            resolveStopReason(seenStopReason);
+        }
+    };
 }
 function sentenceStreamTts(request, options) {
-    const multicast = new TtsMulticast(ttsResponseSource(request, options));
+    const side = createTtsSideChannel();
+    const multicast = new TtsMulticast(ttsResponseSource(request, options, side));
     // Subscribe eagerly, synchronously — before pump() can push its first
     // item — so both subscribers see the full queue from index 0. If we
     // deferred subscribing until the generators were iterated, the first
@@ -247,7 +320,11 @@ function sentenceStreamTts(request, options) {
         bufferStream: sentenceBufferStream(bufferSubscription),
         chunkUpdates: sentenceChunkUpdates(chunkSubscription),
         buffer: Promise.resolve([]),
-        done: multicast.done
+        done: multicast.done,
+        requestId: request.requestId,
+        sampleRate: side.sampleRate,
+        stats: side.stats,
+        stopReason: side.stopReason
     };
 }
 async function* sentenceBufferStream(source) {
@@ -267,10 +344,12 @@ async function* sentenceChunkUpdates(source) {
         if (hasAudio || hasMeta) {
             yield {
                 buffer: hasAudio ? [...m.buffer] : [],
+                ...(m.sampleRate !== undefined ? { sampleRate: m.sampleRate } : {}),
                 ...(m.chunkIndex !== undefined ? { chunkIndex: m.chunkIndex } : {}),
                 ...(typeof m.sentenceChunk === 'string' && m.sentenceChunk.length > 0
                     ? { sentenceChunk: m.sentenceChunk }
-                    : {})
+                    : {}),
+                ...(m.isLast !== undefined ? { isLast: m.isLast } : {})
             };
         }
         if (m.done)
@@ -285,13 +364,18 @@ function plainStreamTts(request, options) {
         rejectDone = reject;
     });
     done.catch(() => { });
+    const side = createTtsSideChannel();
     return {
-        bufferStream: plainTtsBufferStream(request, options, resolveDone, rejectDone),
+        bufferStream: plainTtsBufferStream(request, options, resolveDone, rejectDone, side),
         buffer: Promise.resolve([]),
-        done
+        done,
+        requestId: request.requestId,
+        sampleRate: side.sampleRate,
+        stats: side.stats,
+        stopReason: side.stopReason
     };
 }
-async function* plainTtsBufferStream(request, options, resolveDone, rejectDone) {
+async function* plainTtsBufferStream(request, options, resolveDone, rejectDone, side) {
     let settled = false;
     try {
         for await (const response of streamRpc(request, options)) {
@@ -299,6 +383,7 @@ async function* plainTtsBufferStream(request, options, resolveDone, rejectDone)
                 continue;
             // See TtsMulticast.pump — skip per-frame Zod validation; the server is
             // the source of truth for this wire shape.
+            side.observe(response);
             if (response.buffer.length > 0) {
                 yield* response.buffer;
             }
@@ -320,6 +405,7 @@ async function* plainTtsBufferStream(request, options, resolveDone, rejectDone)
         // with `false` so `await result.done` never hangs.
         if (!settled)
             resolveDone(false);
+        side.settle();
     }
 }
 function collectTts(request, options) {
@@ -330,21 +416,27 @@ function collectTts(request, options) {
         rejectDone = reject;
     });
     done.catch(() => { });
+    const side = createTtsSideChannel();
     return {
         bufferStream: emptyBufferStream(),
-        buffer: collectTtsBuffer(request, options, resolveDone, rejectDone),
-        done
+        buffer: collectTtsBuffer(request, options, resolveDone, rejectDone, side),
+        done,
+        requestId: request.requestId,
+        sampleRate: side.sampleRate,
+        stats: side.stats,
+        stopReason: side.stopReason
     };
 }
 async function* emptyBufferStream() {
     // Non-streaming mode exposes no incremental buffer stream.
 }
-async function collectTtsBuffer(request, options, resolveDone, rejectDone) {
+async function collectTtsBuffer(request, options, resolveDone, rejectDone, side) {
     let buffer = [];
     try {
         for await (const response of streamRpc(request, options)) {
             if (response.type !== 'textToSpeech')
                 continue;
+            side.observe(response);
             buffer = buffer.concat(response.buffer);
             if (response.done) {
                 resolveDone(true);
@@ -356,6 +448,9 @@ async function collectTtsBuffer(request, options, resolveDone, rejectDone) {
         rejectDone(e);
         throw e;
     }
+    finally {
+        side.settle();
+    }
 }
 export function encodeTextToSpeechFragment(textFragment) {
     return typeof textFragment === 'string' ? new TextEncoder().encode(textFragment) : textFragment;
@@ -375,7 +470,8 @@ export function encodeTextToSpeechFragment(textFragment) {
  *   than once, receives a server error, or is written after closing.
  */
 export async function textToSpeechStream(params, options) {
-    const request = parseClientInput(textToSpeechStreamRequestSchema, buildTextToSpeechStreamRequest(params));
+    const requestId = params.requestId ?? generateClientRequestId();
+    const request = parseClientInput(textToSpeechStreamRequestSchema, buildTextToSpeechStreamRequest(params, requestId));
     const { requestStream, responseStream } = await duplex(request, options);
     const responses = parseTextToSpeechStreamLines(responseStream);
     let consumed = false;
@@ -385,6 +481,7 @@ export async function textToSpeechStream(params, options) {
     // surface predictable.
     let closed = false;
     return {
+        requestId,
         write(textFragment) {
             if (closed) {
                 throw new TextToSpeechStreamFailedError('TextToSpeechStreamSession.write() called after end()/destroy()');

package/dist/src/client/api/vector-index.d.ts

@@ -0,0 +1,143 @@
+import { send } from '../rpc/rpc-client.js';
+import { type CreateVectorIndexParams, type LoadVectorIndexParams, type RPCOptions, type VectorIndexAddParams, type VectorIndexHit, type VectorIndexIdsParams, type VectorIndexStorage, type VectorIndexWriteParams } from '@qvac/inference/surface';
+/**
+ * A handle to a vector index that lives in worker memory.
+ *
+ * Vectors are indexed under stable unsigned 64-bit ids and searched by
+ * dot-product similarity, so L2-normalize vectors before adding and queries
+ * before searching when cosine similarity is wanted. The index holds vectors
+ * only; keep the documents they describe wherever suits the app and map
+ * result ids back to them.
+ *
+ * The index is released by `dispose()` (or `await using`) and on worker
+ * shutdown. After a worker crash or restart every method rejects with
+ * `VECTOR_INDEX_NOT_FOUND`; recover by creating a new index or loading a
+ * snapshot written earlier with `write()`.
+ */
+export interface VectorIndex {
+    /** Opaque id of the worker-side index; useful in logs, not needed for any call. */
+    readonly indexId: string;
+    /** Vector dimensionality every added vector and query must match. */
+    readonly dim: number;
+    /**
+     * Storage mode. Known after `createVectorIndex`. After `loadVectorIndex` it
+     * is derived from the snapshot's bit width, so 4-bit snapshots (`q4` or
+     * `turbovec-q4`) report `undefined`.
+     */
+    readonly storage: VectorIndexStorage | undefined;
+    /** Number of live entries as of the last call that changed or reported it. */
+    readonly length: number;
+    /**
+     * Adds vectors under the given ids in one atomic batch. Rejects duplicate
+     * ids, ids equal to 2^64 - 1, and rows whose length differs from `dim`.
+     * @returns The number of live entries after the add.
+     */
+    add(params: VectorIndexAddParams, options?: RPCOptions): Promise<{
+        length: number;
+    }>;
+    /**
+     * Finds the `k` nearest entries to one query. Hits are ordered by
+     * descending score, then ascending id, and fewer than `k` are returned
+     * when the index holds fewer entries.
+     * @overloadLabel "Single query"
+     */
+    search(params: {
+        query: number[];
+        k: number;
+    }, options?: RPCOptions): Promise<VectorIndexHit[]>;
+    /**
+     * Finds the `k` nearest entries to each query row; one hit list per row.
+     * @overloadLabel "Multiple queries"
+     */
+    search(params: {
+        queries: number[][];
+        k: number;
+    }, options?: RPCOptions): Promise<VectorIndexHit[][]>;
+    /**
+     * Removes ids; each boolean tells whether that id was present. Ids are
+     * applied in order, so a rejection leaves the ids before the failure
+     * removed and `length` reporting the last successful call.
+     */
+    remove(params: VectorIndexIdsParams, options?: RPCOptions): Promise<boolean[]>;
+    /** Reports, per id, whether the index holds it. */
+    contains(params: VectorIndexIdsParams, options?: RPCOptions): Promise<boolean[]>;
+    /**
+     * Writes a checksummed snapshot to `path`, replacing any existing file.
+     * An absolute path is used as given; a relative path resolves under the
+     * QVAC data directory. Load it later with `loadVectorIndex`.
+     * @returns The resolved absolute path.
+     */
+    write(params: VectorIndexWriteParams, options?: RPCOptions): Promise<{
+        path: string;
+    }>;
+    /** Releases worker memory. Safe to call more than once. */
+    dispose(options?: RPCOptions): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+/**
+ * Builds the two public functions over a transport. The default export pair
+ * below binds them to the RPC client; tests bind a fake instead.
+ */
+export declare function createVectorIndexClient(transport: typeof send): {
+    createVectorIndex(params: CreateVectorIndexParams, options?: RPCOptions): Promise<VectorIndex>;
+    loadVectorIndex(params: LoadVectorIndexParams, options?: RPCOptions): Promise<VectorIndex>;
+};
+/**
+ * Creates an empty vector index in worker memory and returns a handle to it.
+ *
+ * The index is backed by the native TurboVec engine of the registered
+ * embedding plugin (the built-in llama.cpp embedding plugin provides it).
+ * Pair it with `embed()` to build retrieval over documents kept in any store:
+ * add each document's embedding under an id of your choosing, then search
+ * with the embedding of a query and map the returned ids back to your
+ * documents.
+ *
+ * @param params - Index parameters
+ * @param params.dim - Vector dimensionality, for example 1024 for GTE Large. TurboVec storage needs a multiple of 8 no greater than 1024.
+ * @param params.storage - Storage mode from `VectorIndexStorage`; defaults to `TURBOVEC_Q4`. `TURBOVEC_Q2` halves memory again at lower recall; `F32`, `Q8`, and `Q4` are exact or generically quantised stores for dimensions TurboVec cannot hold.
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @returns A handle whose methods add, search, remove, snapshot, and dispose the index.
+ * @throws {VectorIndexProviderUnavailableError} When no registered plugin exposes a vector index provider
+ * @throws {VectorIndexFailedError} When the native index rejects the dimension or storage mode
+ *
+ * @example
+ * ```typescript
+ * const documents = new Map([
+ *   ['1', 'Saturn moon Titan has lakes of liquid methane.'],
+ *   ['2', 'Solar panels turn sunlight into electricity.']
+ * ])
+ * const { embedding } = await embed({ modelId, text: [...documents.values()] })
+ *
+ * await using index = await createVectorIndex({ dim: embedding[0].length })
+ * await index.add({ ids: [...documents.keys()], vectors: embedding })
+ *
+ * const { embedding: query } = await embed({ modelId, text: 'Which moon has methane lakes?' })
+ * const hits = await index.search({ query, k: 1 })
+ * console.log(documents.get(hits[0].id))
+ * ```
+ */
+export declare function createVectorIndex(params: CreateVectorIndexParams, options?: RPCOptions): Promise<VectorIndex>;
+/**
+ * Loads a vector index snapshot written by `VectorIndex.write()` into worker
+ * memory and returns a handle to it.
+ *
+ * The snapshot records its dimension, storage mode, and entries, so nothing
+ * else needs to be supplied. Loading copies the file into memory; later
+ * changes are not written back until `write()` is called again.
+ *
+ * @param params - Load parameters
+ * @param params.path - Snapshot path. An absolute path is used as given; a relative path resolves under the QVAC data directory, the same rule `write()` applies.
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @returns A handle to the loaded index.
+ * @throws {VectorIndexProviderUnavailableError} When no registered plugin exposes a vector index provider
+ * @throws {VectorIndexFailedError} When the file is missing, corrupt, or not a vector index snapshot
+ *
+ * @example
+ * ```typescript
+ * const index = await loadVectorIndex({ path: 'indexes/articles.qvi' })
+ * const hits = await index.search({ query, k: 5 })
+ * await index.dispose()
+ * ```
+ */
+export declare function loadVectorIndex(params: LoadVectorIndexParams, options?: RPCOptions): Promise<VectorIndex>;
+//# sourceMappingURL=vector-index.d.ts.map

package/dist/src/client/api/vector-index.js

@@ -0,0 +1,168 @@
+import { send } from '../rpc/rpc-client.js';
+import { DEFAULT_VECTOR_INDEX_STORAGE, findVectorRowLengthMismatch, toWireVectorIds } from '@qvac/inference/surface';
+import { InvalidOperationError, InvalidResponseError, RequestValidationFailedError } from '../../utils/errors-client.js';
+/**
+ * Builds the two public functions over a transport. The default export pair
+ * below binds them to the RPC client; tests bind a fake instead.
+ */
+export function createVectorIndexClient(transport) {
+    async function call(request, options) {
+        const response = await transport(request, options);
+        if (response.type !== 'vectorIndex') {
+            throw new InvalidResponseError('vectorIndex');
+        }
+        if (response.operation !== request.operation) {
+            throw new InvalidOperationError();
+        }
+        return response;
+    }
+    function createHandle(opened) {
+        const { indexId, dim, storage } = opened;
+        let length = opened.length;
+        let disposed = false;
+        // Row lengths are checked here so a mismatch fails before any request is
+        // sent and before the worker touches native memory.
+        function assertRows(rows, label) {
+            const mismatch = findVectorRowLengthMismatch(rows, dim);
+            if (mismatch === -1)
+                return;
+            throw new RequestValidationFailedError(`${label}[${mismatch}] has ${rows[mismatch]?.length ?? 0} components, expected ${dim}`);
+        }
+        // The flag is set only after the worker confirms, so a failed dispose
+        // can be retried instead of leaking the index until worker shutdown.
+        async function dispose(options) {
+            if (disposed)
+                return;
+            await call({ type: 'vectorIndex', operation: 'dispose', indexId }, options);
+            disposed = true;
+        }
+        async function search(params, options) {
+            const queries = 'queries' in params ? params.queries : [params.query];
+            assertRows(queries, 'queries');
+            const response = await call({ type: 'vectorIndex', operation: 'search', indexId, queries, k: params.k }, options);
+            return 'queries' in params ? response.results : (response.results[0] ?? []);
+        }
+        const handle = {
+            indexId,
+            dim,
+            storage,
+            get length() {
+                return length;
+            },
+            async add(params, options) {
+                assertRows(params.vectors, 'vectors');
+                const response = await call({
+                    type: 'vectorIndex',
+                    operation: 'add',
+                    indexId,
+                    ids: toWireVectorIds(params.ids),
+                    vectors: params.vectors
+                }, options);
+                length = response.length;
+                return { length };
+            },
+            search,
+            async remove(params, options) {
+                const response = await call({ type: 'vectorIndex', operation: 'remove', indexId, ids: toWireVectorIds(params.ids) }, options);
+                length = response.length;
+                return response.removed;
+            },
+            async contains(params, options) {
+                const response = await call({ type: 'vectorIndex', operation: 'contains', indexId, ids: toWireVectorIds(params.ids) }, options);
+                return response.present;
+            },
+            async write(params, options) {
+                const response = await call({ type: 'vectorIndex', operation: 'write', indexId, path: params.path }, options);
+                return { path: response.path };
+            },
+            dispose
+        };
+        // Older runtimes without explicit resource management have no symbol to
+        // key the method on; `dispose()` remains available there.
+        if (typeof Symbol.asyncDispose === 'symbol') {
+            Object.defineProperty(handle, Symbol.asyncDispose, {
+                value: () => dispose(),
+                enumerable: false
+            });
+        }
+        return handle;
+    }
+    return {
+        async createVectorIndex(params, options) {
+            const response = await call({
+                type: 'vectorIndex',
+                operation: 'create',
+                dim: params.dim,
+                storage: params.storage ?? DEFAULT_VECTOR_INDEX_STORAGE
+            }, options);
+            return createHandle(response);
+        },
+        async loadVectorIndex(params, options) {
+            const response = await call({ type: 'vectorIndex', operation: 'load', path: params.path }, options);
+            return createHandle(response);
+        }
+    };
+}
+const client = createVectorIndexClient(send);
+/**
+ * Creates an empty vector index in worker memory and returns a handle to it.
+ *
+ * The index is backed by the native TurboVec engine of the registered
+ * embedding plugin (the built-in llama.cpp embedding plugin provides it).
+ * Pair it with `embed()` to build retrieval over documents kept in any store:
+ * add each document's embedding under an id of your choosing, then search
+ * with the embedding of a query and map the returned ids back to your
+ * documents.
+ *
+ * @param params - Index parameters
+ * @param params.dim - Vector dimensionality, for example 1024 for GTE Large. TurboVec storage needs a multiple of 8 no greater than 1024.
+ * @param params.storage - Storage mode from `VectorIndexStorage`; defaults to `TURBOVEC_Q4`. `TURBOVEC_Q2` halves memory again at lower recall; `F32`, `Q8`, and `Q4` are exact or generically quantised stores for dimensions TurboVec cannot hold.
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @returns A handle whose methods add, search, remove, snapshot, and dispose the index.
+ * @throws {VectorIndexProviderUnavailableError} When no registered plugin exposes a vector index provider
+ * @throws {VectorIndexFailedError} When the native index rejects the dimension or storage mode
+ *
+ * @example
+ * ```typescript
+ * const documents = new Map([
+ *   ['1', 'Saturn moon Titan has lakes of liquid methane.'],
+ *   ['2', 'Solar panels turn sunlight into electricity.']
+ * ])
+ * const { embedding } = await embed({ modelId, text: [...documents.values()] })
+ *
+ * await using index = await createVectorIndex({ dim: embedding[0].length })
+ * await index.add({ ids: [...documents.keys()], vectors: embedding })
+ *
+ * const { embedding: query } = await embed({ modelId, text: 'Which moon has methane lakes?' })
+ * const hits = await index.search({ query, k: 1 })
+ * console.log(documents.get(hits[0].id))
+ * ```
+ */
+export function createVectorIndex(params, options) {
+    return client.createVectorIndex(params, options);
+}
+/**
+ * Loads a vector index snapshot written by `VectorIndex.write()` into worker
+ * memory and returns a handle to it.
+ *
+ * The snapshot records its dimension, storage mode, and entries, so nothing
+ * else needs to be supplied. Loading copies the file into memory; later
+ * changes are not written back until `write()` is called again.
+ *
+ * @param params - Load parameters
+ * @param params.path - Snapshot path. An absolute path is used as given; a relative path resolves under the QVAC data directory, the same rule `write()` applies.
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @returns A handle to the loaded index.
+ * @throws {VectorIndexProviderUnavailableError} When no registered plugin exposes a vector index provider
+ * @throws {VectorIndexFailedError} When the file is missing, corrupt, or not a vector index snapshot
+ *
+ * @example
+ * ```typescript
+ * const index = await loadVectorIndex({ path: 'indexes/articles.qvi' })
+ * const hits = await index.search({ query, k: 5 })
+ * await index.dispose()
+ * ```
+ */
+export function loadVectorIndex(params, options) {
+    return client.loadVectorIndex(params, options);
+}

package/dist/src/client/api/world.d.ts

@@ -45,9 +45,9 @@ import { type WorldSceneResult, type WorldSceneResultWithPack, type WorldStepRes
  *   modelSrc: ABOT_WORLD_0_5B_Q8_0,
  *   modelConfig: {
  *     mode: "world",
- *     taehvModelSrc: ABOT_WORLD_0_5B_LF_VAE,
+ *     taehvModelSrc: ABOT_WORLD_0_5B_LF_TAEHV_VAE,
  *     t5XxlModelSrc: UMT5_XXL_ENC_Q8_0,
- *     vaeModelSrc: ABOT_WORLD_0_5B_LF_VAE_F16,
+ *     vaeModelSrc: ABOT_WORLD_0_5B_LF_WAN_VAE,
  *     world: { seed: 42, kvCache: true },
  *   },
  * });

package/dist/src/commands/bundle/manifest.d.ts

@@ -1,6 +1,8 @@
 import type { Logger } from '../../logging/types.js';
 interface BarePackHeader {
     id?: string;
+    main?: string;
+    imports?: Record<string, unknown>;
     resolutions?: Record<string, unknown>;
 }
 interface GenerateAddonsManifestOptions {

package/dist/src/commands/verify/addon-source.d.ts

@@ -5,6 +5,12 @@ export interface NativeAddon {
     packageJsonPath: string;
     packageRoot: string;
     enginesBare?: string;
+    /**
+     * Hosts whose bundle graph links this addon, and so the only ones needing a
+     * prebuild; empty means the bundle links it nowhere. Absent when the source
+     * carries no link information, in which case every host is checked.
+     */
+    linkedHosts?: string[];
 }
 export interface AddonPackageJson {
     name?: string;

package/dist/src/commands/verify/bundle-source.d.ts

@@ -6,6 +6,8 @@ export declare class InvalidBundleSourceError extends Error {
 export interface CollectAddonsFromBundleOptions {
     bundlePath: string;
     projectRoot: string;
+    /** Omitting these leaves `linkedHosts` unset, so every host stays checked. */
+    hosts?: string[];
     diagnostics?: CollectDiagnostics;
 }
 export declare function collectAddonsFromBundle(options: CollectAddonsFromBundleOptions): Promise<NativeAddon[]>;