@qvac/sdk 0.20.0 → 0.21.0

package/dist/scripts/contract/build-numeric-constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * JSON export of the SDK's numeric public vocabularies (name → number).
+ *
+ * `constants-registry.ts` emits string vocabularies only, through
+ * `enumFromVocabulary`, so numeric ones ride this artifact instead — the same
+ * way `error-codes.json` carries the numeric error registries.
+ * `sdk-python/scripts/generate.py` renders it into `_generated/numeric_constants.py`.
+ *
+ * A separate artifact from schema.json, like models.json / error-codes.json.
+ */
+export interface NumericConstants {
+    ASR_BACKEND_IDS: Record<string, number>;
+}
+export declare function buildNumericConstants(): NumericConstants;
+//# sourceMappingURL=build-numeric-constants.d.ts.map

package/dist/scripts/contract/build-numeric-constants.js

@@ -0,0 +1,13 @@
+import { ASR_BACKEND_IDS } from '@qvac/inference/surface';
+function sortedByValue(record) {
+    const entries = Object.entries(record);
+    entries.sort(function (a, b) {
+        return a[1] - b[1];
+    });
+    return Object.fromEntries(entries);
+}
+export function buildNumericConstants() {
+    return {
+        ASR_BACKEND_IDS: sortedByValue(ASR_BACKEND_IDS)
+    };
+}

package/dist/scripts/contract/method-shapes.d.ts

@@ -7,6 +7,9 @@
  * export runs under Node, where core's native `bare-*` modules cannot load.
  */
 export declare const methodShapes: {
+    readonly startRpcServer: "reply";
+    readonly stopRpcServer: "reply";
+    readonly discoverRpcServers: "reply";
     readonly assessModelFit: "reply";
     readonly audioEditStream: "stream";
     readonly audioGenStream: "stream";

package/dist/scripts/contract/method-shapes.js

@@ -7,6 +7,9 @@
  * export runs under Node, where core's native `bare-*` modules cannot load.
  */
 export const methodShapes = {
+    startRpcServer: 'reply',
+    stopRpcServer: 'reply',
+    discoverRpcServers: 'reply',
     assessModelFit: 'reply',
     audioEditStream: 'stream',
     audioGenStream: 'stream',

package/dist/scripts/enforce-inference-versions.d.ts

@@ -0,0 +1,18 @@
+type Ranges = Record<string, string>;
+export interface Manifest {
+    version?: string;
+    dependencies?: Ranges;
+    devDependencies?: Ranges;
+    peerDependencies?: Ranges;
+    peerDependenciesMeta?: Record<string, {
+        optional?: boolean;
+    }>;
+    engines?: Ranges;
+}
+export declare function checkAddonRanges(inferencePkg: Manifest, sdkPkg: Manifest): string[];
+export declare function checkSharedMajorMinor(sdkPkg: Manifest): string[];
+export declare function checkBareRuntimeRange(inferencePkg: Manifest, sdkPkg: Manifest): string[];
+export declare function collectVersionFailures(inferencePkg: Manifest, sdkPkg: Manifest): string[];
+export declare function runEnforceInferenceVersionsCli(): void;
+export {};
+//# sourceMappingURL=enforce-inference-versions.d.ts.map

package/dist/scripts/enforce-inference-versions.js

@@ -0,0 +1,158 @@
+// The version rules that tie @qvac/sdk's manifest to @qvac/inference. All are
+// checked here and every failure is reported in one run.
+//
+// 1. Addon ranges. @qvac/inference's peerDependencies is the source of truth for
+//    the inference addons. For every addon p in it, inference's
+//    devDependencies.p and the SDK's dependencies.p must carry the identical
+//    range. Opt-in services may instead use an optional SDK peer plus a dev dependency.
+//
+// 2. Shared major.minor. @qvac/sdk and @qvac/inference expose the same API, so
+//    the major and minor of the SDK's own version must equal the major and minor
+//    of the @qvac/inference range it depends on. Patch numbers are free on both
+//    sides, so @qvac/sdk 0.19.4 may depend on @qvac/inference ^0.19.2. The range
+//    operator must hold the dependency inside that one major.minor: a caret does
+//    below 1.0.0 (^0.19.0 is >=0.19.0 <0.20.0) but not from 1.0.0 up (^1.19.0
+//    also allows 1.20.0), so a tilde is required there.
+//
+// 3. Bare runtime. Every version allowed by the SDK's bare-runtime dependency
+//    must satisfy inference's engines.bare requirement, including versions
+//    retained by a consumer's existing lockfile.
+//
+// The second rule reads @qvac/sdk's manifest alone and never
+// packages/inference's version. The two move independently between releases —
+// the engine is published first and the SDK follows — so comparing them would
+// fail main for as long as that takes.
+//
+// The checks take manifests rather than reading them, so test/enforce-inference-
+// versions.test.ts can drive them over manifest shapes the repo does not hold.
+import { readFileSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { subset, validRange } from 'semver';
+const dependency = '@qvac/inference';
+const sdkManifest = 'packages/sdk/package.json';
+export function checkAddonRanges(inferencePkg, sdkPkg) {
+    const peers = inferencePkg.peerDependencies ?? {};
+    const inferenceDev = inferencePkg.devDependencies ?? {};
+    const sdkDeps = sdkPkg.dependencies ?? {};
+    const drifts = [];
+    for (const [name, peer] of Object.entries(peers)) {
+        const dev = inferenceDev[name];
+        const optionalPeer = sdkPkg.peerDependenciesMeta?.[name]?.optional === true;
+        const dep = sdkDeps[name] ?? (optionalPeer ? sdkPkg.peerDependencies?.[name] : undefined);
+        const mismatches = [];
+        if (dep !== peer)
+            mismatches.push(dep === undefined ? 'SDK is missing it' : `SDK has ${dep}`);
+        if (sdkDeps[name] === undefined && optionalPeer && sdkPkg.devDependencies?.[name] !== peer) {
+            mismatches.push('SDK devDependencies must match its optional peer');
+        }
+        if (dev !== peer) {
+            mismatches.push(dev === undefined
+                ? 'inference devDependencies is missing it'
+                : `inference devDependencies has ${dev}`);
+        }
+        if (mismatches.length > 0) {
+            drifts.push(`${name}: inference has it as ${peer} in peerDependencies, but ${mismatches.join(' and ')}.`);
+        }
+    }
+    if (drifts.length === 0)
+        return [];
+    return [
+        `${drifts.join('\n')}\n\nPlease ensure the SDK dependencies and inference devDependencies use the same addon versions as inference's peerDependencies.`
+    ];
+}
+export function checkSharedMajorMinor(sdkPkg) {
+    const rawVersion = sdkPkg.version;
+    const rawRange = sdkPkg.dependencies?.[dependency];
+    if (rawVersion === undefined)
+        return [`${sdkManifest} declares no version.`];
+    if (rawRange === undefined)
+        return [`${sdkManifest} declares no ${dependency} dependency.`];
+    // Specs that point somewhere other than the published package: the workspace
+    // link used for development and the pod checks (`sdk-source:workspace` writes
+    // `file:../inference`), and the npm alias the GPR dev build pins. They carry no
+    // major.minor to compare, so there is nothing to check.
+    const localPrefixes = ['file:', 'link:', 'npm:'];
+    const localSpec = localPrefixes.find(function (prefix) {
+        return rawRange.startsWith(prefix);
+    });
+    if (localSpec !== undefined) {
+        console.log(`${dependency} points at "${rawRange}", not a published version; skipping the major.minor check.`);
+        return [];
+    }
+    const versionMatch = /^(\d+)\.(\d+)\.\d+$/.exec(rawVersion);
+    if (versionMatch === null) {
+        return [`@qvac/sdk version "${rawVersion}" is not a plain x.y.z version.`];
+    }
+    const sdkMajorMinor = `${versionMatch[1]}.${versionMatch[2]}`;
+    const rangeMatch = /^([\^~])(\d+)\.(\d+)\.\d+$/.exec(rawRange);
+    if (rangeMatch === null) {
+        return [
+            `${dependency} is declared as "${rawRange}", which this check cannot read.\n` +
+                `Write it as one caret or tilde range over an exact version, e.g. "^${sdkMajorMinor}.0".`
+        ];
+    }
+    const operator = rangeMatch[1];
+    const rangeMajorMinor = `${rangeMatch[2]}.${rangeMatch[3]}`;
+    if (sdkMajorMinor !== rangeMajorMinor) {
+        return [
+            `Version mismatch: @qvac/sdk is ${rawVersion} (major.minor ${sdkMajorMinor}) but depends ` +
+                `on ${dependency} "${rawRange}" (major.minor ${rangeMajorMinor}).\n\n` +
+                `The two ship the same API and must share a major.minor. Either set the range to ` +
+                `${sdkMajorMinor}, or move @qvac/sdk to ${rangeMajorMinor}.0 — publishing ` +
+                `@qvac/inference ${rangeMajorMinor}.0 first, so the range resolves from npm.`
+        ];
+    }
+    if (Number(rangeMatch[2]) >= 1 && operator !== '~') {
+        return [
+            `${dependency} is declared as "${rawRange}". From 1.0.0 up, a caret range also allows the ` +
+                `next minor, which is a different API. Use "~${rawRange.slice(1)}".`
+        ];
+    }
+    return [];
+}
+export function checkBareRuntimeRange(inferencePkg, sdkPkg) {
+    const required = inferencePkg.engines?.['bare'];
+    if (required === undefined)
+        return [];
+    if (validRange(required) === null) {
+        return [`@qvac/inference engines.bare "${required}" is not a valid semver range.`];
+    }
+    const runtime = sdkPkg.dependencies?.['bare-runtime'];
+    if (runtime === undefined || validRange(runtime) === null) {
+        return [`${sdkManifest} must declare a valid bare-runtime dependency range.`];
+    }
+    if (!subset(runtime, required)) {
+        return [
+            `SDK bare-runtime "${runtime}" permits versions outside inference's engines.bare "${required}". ` +
+                'Align the runtime dependency so an existing consumer lockfile cannot retain an unsupported worker.'
+        ];
+    }
+    return [];
+}
+export function collectVersionFailures(inferencePkg, sdkPkg) {
+    return [
+        ...checkAddonRanges(inferencePkg, sdkPkg),
+        ...checkSharedMajorMinor(sdkPkg),
+        ...checkBareRuntimeRange(inferencePkg, sdkPkg)
+    ];
+}
+function readManifest(dir) {
+    return JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+}
+export function runEnforceInferenceVersionsCli() {
+    const sdkDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+    const inferenceDir = resolve(sdkDir, '..', 'inference');
+    const failures = collectVersionFailures(readManifest(inferenceDir), readManifest(sdkDir));
+    if (failures.length > 0) {
+        console.error(failures.join('\n\n'));
+        process.exit(1);
+    }
+}
+function isMainModule() {
+    const entryPath = process.argv[1];
+    return entryPath !== undefined && resolve(entryPath) === fileURLToPath(import.meta.url);
+}
+if (isMainModule()) {
+    runEnforceInferenceVersionsCli();
+}

package/dist/scripts/generate-bare-kit-runtimes.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-bare-kit-runtimes.d.ts.map

package/dist/scripts/generate-bare-kit-runtimes.js

@@ -0,0 +1,106 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import semver from 'semver';
+import { fetchBareKitVersionFromGitHub, fetchBareVersionFromGitHub, fetchText, REACT_NATIVE_BARE_KIT } from '../src/commands/verify/bare-kit-runtime.js';
+import { BARE_KIT_BARE_VERSIONS, REACT_NATIVE_BARE_KIT_RUNTIMES } from '../src/commands/verify/bare-kit-runtimes.js';
+const CONCURRENCY = 8;
+const OUTPUT_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'src', 'commands', 'verify', 'bare-kit-runtimes.ts');
+async function listPublishedVersions() {
+    const metadata = JSON.parse(await fetchText(`https://registry.npmjs.org/${REACT_NATIVE_BARE_KIT}`));
+    return Object.keys(metadata.versions);
+}
+async function listBareKitTags() {
+    const tags = JSON.parse(await fetchText('https://api.github.com/repos/holepunchto/bare-kit/tags?per_page=100'));
+    return tags.map((tag) => tag.name.replace(/^v/, ''));
+}
+function latest(versions) {
+    const valid = versions.filter((version) => semver.valid(version) !== null);
+    return valid.length === 0 ? null : valid.sort(semver.rcompare)[0];
+}
+/**
+ * Releases newer than the newest one already in the table, oldest first.
+ * Everything at or below it was probed on an earlier run, including the old
+ * react-native-bare-kit releases that have no CMakeLists.txt to parse.
+ */
+function newerThan(versions, lastKnown) {
+    return versions
+        .filter((version) => semver.valid(version) !== null)
+        .filter((version) => lastKnown === null || semver.gt(version, lastKnown))
+        .sort(semver.compare);
+}
+async function mapConcurrent(items, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    async function worker() {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await fn(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: CONCURRENCY }, worker));
+    return results;
+}
+async function tryFetch(fn) {
+    try {
+        return await fn();
+    }
+    catch {
+        return null;
+    }
+}
+function sortedEntries(record) {
+    return Object.entries(record).sort(([a], [b]) => semver.compare(a, b));
+}
+function render(runtimes, bareByBareKit) {
+    const lines = [
+        '// Generated by scripts/generate-bare-kit-runtimes.ts. Do not edit by hand.',
+        '',
+        'export interface BareKitRuntime {',
+        '  bareKit: string',
+        '  bare: string',
+        '}',
+        '',
+        '/**',
+        ' * react-native-bare-kit releases whose CMakeLists.txt names the bare-kit',
+        ' * prebuilds it ships. Older releases carry no such reference.',
+        ' */',
+        'export const REACT_NATIVE_BARE_KIT_RUNTIMES: Record<string, BareKitRuntime> = {'
+    ];
+    lines.push(...entryLines(sortedEntries(runtimes).map(([version, runtime]) => `'${version}': { bareKit: '${runtime.bareKit}', bare: '${runtime.bare}' }`)));
+    lines.push('}', '', '/** Bare version each bare-kit release is built against. */');
+    lines.push('export const BARE_KIT_BARE_VERSIONS: Record<string, string> = {');
+    lines.push(...entryLines(sortedEntries(bareByBareKit).map(([bareKit, bare]) => `'${bareKit}': '${bare}'`)));
+    lines.push('}', '');
+    return lines.join('\n');
+}
+/** Object entries in the repo's Prettier style: no trailing comma. */
+function entryLines(entries) {
+    return entries.map((entry, index) => `  ${entry}${index === entries.length - 1 ? '' : ','}`);
+}
+async function main() {
+    const full = process.argv.includes('--full');
+    const bareByBareKit = full ? {} : { ...BARE_KIT_BARE_VERSIONS };
+    const runtimes = full ? {} : { ...REACT_NATIVE_BARE_KIT_RUNTIMES };
+    const bareKitTags = newerThan(await listBareKitTags(), latest(Object.keys(bareByBareKit)));
+    console.log(`Resolving ${bareKitTags.length} new bare-kit releases...`);
+    const bareVersions = await mapConcurrent(bareKitTags, (bareKit) => tryFetch(() => fetchBareVersionFromGitHub(bareKit)));
+    bareKitTags.forEach((bareKit, index) => {
+        const bare = bareVersions[index];
+        if (bare)
+            bareByBareKit[bareKit] = bare;
+    });
+    const versions = newerThan(await listPublishedVersions(), latest(Object.keys(runtimes)));
+    console.log(`Resolving ${versions.length} new ${REACT_NATIVE_BARE_KIT} releases...`);
+    const bareKitByVersion = await mapConcurrent(versions, (version) => tryFetch(() => fetchBareKitVersionFromGitHub(version)));
+    versions.forEach((version, index) => {
+        const bareKit = bareKitByVersion[index];
+        const bare = bareKit ? bareByBareKit[bareKit] : undefined;
+        if (bareKit && bare)
+            runtimes[version] = { bareKit, bare };
+    });
+    await fsp.writeFile(OUTPUT_PATH, render(runtimes, bareByBareKit));
+    console.log(`Wrote ${Object.keys(runtimes).length} ${REACT_NATIVE_BARE_KIT} and ` +
+        `${Object.keys(bareByBareKit).length} bare-kit entries to ${OUTPUT_PATH}`);
+}
+await main();

package/dist/src/client/api/assess-model-fit.d.ts

@@ -3,12 +3,18 @@ import { type AssessModelFitInput, type AssessModelFitResult } from '@qvac/infer
  * Assesses, before anything is downloaded, whether the given models are likely
  * to fit in this device's memory.
  *
- * Advisory only: it does not download weights, run a native fit probe, block
- * `loadModel`, reserve memory, or make a performance claim. `unknown` is a real
- * answer — it means the available evidence does not support a verdict either
- * way, and callers should treat it as "cannot say", not "no".
+ * Advisory only: it does not download weights, block `loadModel`, reserve
+ * memory, or make a performance claim. `unknown` is a real answer — it means
+ * the available evidence does not support a verdict either way, and callers
+ * should treat it as "cannot say", not "no".
  *
- * @param input - Candidates with their intended workloads, the declared
+ * For a single candidate it fetches the registry's weightless description of
+ * every source that load names — tens of KB each, never the weights — and runs
+ * the engine's own fitter against them, reported as `native-fit` evidence.
+ * Where that is unavailable, and for a set of candidates, the calibrated
+ * estimate stands.
+ *
+ * @param input - Loads to assess in `loadModel`'s own parameters, the declared
  *   execution mode, and the headroom policy.
  * @returns Per-model and combined verdicts, with the budget and bounds they came
  *   from, plus every assumption that was made.

package/dist/src/client/api/assess-model-fit.js

@@ -1,22 +1,44 @@
-import { assessModelFitInputSchema } from '@qvac/inference/surface';
+import { assessModelFitInputSchema, inferModelTypeFromModelSrc } from '@qvac/inference/surface';
 import { send } from '../rpc/rpc-client.js';
-import { InvalidResponseError } from '../../utils/errors-client.js';
+import { InvalidResponseError, ModelTypeRequiredError } from '../../utils/errors-client.js';
+/**
+ * Names the engine a candidate omitted, from the source it carries.
+ *
+ * @throws {ModelTypeRequiredError} When the source names no engine either.
+ */
+function withModelType(candidate) {
+    if (candidate.modelType !== undefined)
+        return candidate;
+    const inferred = inferModelTypeFromModelSrc(candidate.modelSrc);
+    if (inferred === undefined)
+        throw new ModelTypeRequiredError();
+    return { ...candidate, modelType: inferred };
+}
 /**
  * Assesses, before anything is downloaded, whether the given models are likely
  * to fit in this device's memory.
  *
- * Advisory only: it does not download weights, run a native fit probe, block
- * `loadModel`, reserve memory, or make a performance claim. `unknown` is a real
- * answer — it means the available evidence does not support a verdict either
- * way, and callers should treat it as "cannot say", not "no".
+ * Advisory only: it does not download weights, block `loadModel`, reserve
+ * memory, or make a performance claim. `unknown` is a real answer — it means
+ * the available evidence does not support a verdict either way, and callers
+ * should treat it as "cannot say", not "no".
+ *
+ * For a single candidate it fetches the registry's weightless description of
+ * every source that load names — tens of KB each, never the weights — and runs
+ * the engine's own fitter against them, reported as `native-fit` evidence.
+ * Where that is unavailable, and for a set of candidates, the calibrated
+ * estimate stands.
  *
- * @param input - Candidates with their intended workloads, the declared
+ * @param input - Loads to assess in `loadModel`'s own parameters, the declared
  *   execution mode, and the headroom policy.
  * @returns Per-model and combined verdicts, with the budget and bounds they came
  *   from, plus every assumption that was made.
  */
 export async function assessModelFit(input) {
-    const parsed = assessModelFitInputSchema.parse(input);
+    const parsed = assessModelFitInputSchema.parse({
+        ...input,
+        models: input.models.map(withModelType)
+    });
     const request = { type: 'assessModelFit', ...parsed };
     const response = await send(request);
     if (response.type !== 'assessModelFit') {

package/dist/src/client/api/bci-transcribe.d.ts

@@ -37,7 +37,10 @@ export declare function bciTranscribe(params: BciTranscribeClientParams, options
  * @param params.modelId - The loaded BCI model to use.
  * @param params.metadata - When true, the session yields transcript segment
  *                          objects (`{ text, startMs, endMs, append, id }`)
- *                          instead of plain text.
+ *                          instead of plain text. With `emit: 'delta'`, each
+ *                          segment also carries `windowStartTimestep`: its
+ *                          timestamps are window-local, and this maps them
+ *                          onto the stream timeline.
  * @param params.windowTimesteps - Decode window size in timesteps.
  * @param params.hopTimesteps - How far the window advances between decodes.
  * @param params.emit - `'delta'` (default) yields only the newly-discovered

package/dist/src/client/api/get-system-resources.d.ts

@@ -1,3 +1,11 @@
 import { type GetSystemResourcesInput, type SystemResources } from '@qvac/inference/surface';
+/**
+ * Read the worker's system capabilities and optional resource sample.
+ *
+ * @param input - Optional settings; set `sample` to request a current resource sample.
+ * @returns System capabilities with availability information and a sample when provided by the worker.
+ * @throws {InvalidResponseError} If the worker returns a different response type.
+ * @throws {Error} If the RPC request fails.
+ */
 export declare function getSystemResources(input?: GetSystemResourcesInput): Promise<SystemResources>;
 //# sourceMappingURL=get-system-resources.d.ts.map

package/dist/src/client/api/get-system-resources.js

@@ -1,6 +1,14 @@
 import {} from '@qvac/inference/surface';
 import { send } from '../rpc/rpc-client.js';
 import { InvalidResponseError } from '../../utils/errors-client.js';
+/**
+ * Read the worker's system capabilities and optional resource sample.
+ *
+ * @param input - Optional settings; set `sample` to request a current resource sample.
+ * @returns System capabilities with availability information and a sample when provided by the worker.
+ * @throws {InvalidResponseError} If the worker returns a different response type.
+ * @throws {Error} If the RPC request fails.
+ */
 export async function getSystemResources(input) {
     const request = {
         type: 'getSystemResources',

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

@@ -37,4 +37,5 @@ export { vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE } from './vla-h
 export { audioGen } from './audio-gen.js';
 export { audioEdit } from './audio-edit.js';
 export { audioUnderstand } from './audio-understand.js';
+export { startRpcServer, stopRpcServer, discoverRpcServers } from './rpc-server.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -37,3 +37,4 @@ export { vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE } from './vla-h
 export { audioGen } from './audio-gen.js';
 export { audioEdit } from './audio-edit.js';
 export { audioUnderstand } from './audio-understand.js';
+export { startRpcServer, stopRpcServer, discoverRpcServers } from './rpc-server.js';

package/dist/src/client/api/rpc-server.d.ts

@@ -0,0 +1,20 @@
+import { type StartRpcServerOptions, type StopRpcServerOptions, type DiscoverRpcServersOptions, type RpcServerInfo, type RpcServerCandidate } from '@qvac/inference/surface';
+/**
+ * Start a worker-owned native RPC server. Non-loopback binding and advertising require explicit opt-in.
+ * Cancel a pending start with its promise.requestId.
+ */
+export declare function startRpcServer(options?: StartRpcServerOptions): Promise<RpcServerInfo> & {
+    requestId: string;
+};
+/** Withdraw the announcement and await native stop. Bare stop has no deadline. */
+export declare function stopRpcServer(options: StopRpcServerOptions): Promise<void>;
+/**
+ * Find private-network candidates with device inventories and server RDMA availability.
+ * RDMA availability is a server-side offer, not a guarantee of the negotiated transport.
+ * Use getRpcDeviceMap with the chosen endpoint registration order before loadModel.
+ * Cancel a pending search with its promise.requestId.
+ */
+export declare function discoverRpcServers(options: DiscoverRpcServersOptions): Promise<RpcServerCandidate[]> & {
+    requestId: string;
+};
+//# sourceMappingURL=rpc-server.d.ts.map

package/dist/src/client/api/rpc-server.js

@@ -0,0 +1,45 @@
+import {} from '@qvac/inference/surface';
+import { send } from '../rpc/rpc-client.js';
+import { InvalidResponseError } from '../../utils/errors-client.js';
+import { decoratePromise } from '../../utils/decorate-promise.js';
+import { generateClientRequestId } from './client-request-id.js';
+/**
+ * Start a worker-owned native RPC server. Non-loopback binding and advertising require explicit opt-in.
+ * Cancel a pending start with its promise.requestId.
+ */
+export function startRpcServer(options = {}) {
+    const requestId = generateClientRequestId();
+    return decoratePromise(runStartRpcServer(options, requestId), { requestId });
+}
+async function runStartRpcServer(options, requestId) {
+    const response = await send({ ...options, type: 'startRpcServer', requestId });
+    if (response.type !== 'startRpcServer')
+        throw new InvalidResponseError('startRpcServer');
+    return {
+        serverId: response.serverId,
+        url: response.url,
+        rdmaCapable: response.rdmaCapable
+    };
+}
+/** Withdraw the announcement and await native stop. Bare stop has no deadline. */
+export async function stopRpcServer(options) {
+    const response = await send({ ...options, type: 'stopRpcServer' });
+    if (response.type !== 'stopRpcServer')
+        throw new InvalidResponseError('stopRpcServer');
+}
+/**
+ * Find private-network candidates with device inventories and server RDMA availability.
+ * RDMA availability is a server-side offer, not a guarantee of the negotiated transport.
+ * Use getRpcDeviceMap with the chosen endpoint registration order before loadModel.
+ * Cancel a pending search with its promise.requestId.
+ */
+export function discoverRpcServers(options) {
+    const requestId = generateClientRequestId();
+    return decoratePromise(runDiscoverRpcServers(options, requestId), { requestId });
+}
+async function runDiscoverRpcServers(options, requestId) {
+    const response = await send({ ...options, type: 'discoverRpcServers', requestId });
+    if (response.type !== 'discoverRpcServers')
+        throw new InvalidResponseError('discoverRpcServers');
+    return response.servers;
+}

package/dist/src/client/api/text-to-speech.d.ts

@@ -43,6 +43,15 @@ export declare class TtsMulticast {
  *   metadata with the audio. Multiple consumers can iterate the response
  *   independently via the underlying `TtsMulticast`.
  *
+ * MOSS models stream natively rather than by sentence: under `stream: true`
+ * the whole text is one synthesis whose audio arrives every
+ * `streamChunkTokens` codec frames (in one piece when that is unset), so
+ * `durationTokens` and a MOSS-TTSD dialogue's reference transcripts apply to
+ * the text as a whole. `sentenceStream: true` still splits a single-speaker
+ * text; a dialogue rejects it. `sentenceStreamLocale` and
+ * `sentenceStreamMaxChunkScalars` configure that splitting, so a MOSS request
+ * rejects them unless it sets `sentenceStream: true`.
+ *
  * `result.done` resolves to `true` when synthesis completes cleanly, `false`
  * 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.

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

@@ -202,6 +202,15 @@ function buildTextToSpeechStreamRequest(params, requestId) {
  *   metadata with the audio. Multiple consumers can iterate the response
  *   independently via the underlying `TtsMulticast`.
  *
+ * MOSS models stream natively rather than by sentence: under `stream: true`
+ * the whole text is one synthesis whose audio arrives every
+ * `streamChunkTokens` codec frames (in one piece when that is unset), so
+ * `durationTokens` and a MOSS-TTSD dialogue's reference transcripts apply to
+ * the text as a whole. `sentenceStream: true` still splits a single-speaker
+ * text; a dialogue rejects it. `sentenceStreamLocale` and
+ * `sentenceStreamMaxChunkScalars` configure that splitting, so a MOSS request
+ * rejects them unless it sets `sentenceStream: true`.
+ *
  * `result.done` resolves to `true` when synthesis completes cleanly, `false`
  * 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.