@qvac/sdk 0.20.1 → 0.21.0

package/dist/examples/rpc-inference.js

@@ -0,0 +1,51 @@
+// npx tsx rpc-inference.ts my-private-rpc-group
+import { discoverRpcServers, getRpcDeviceMap, loadModel, completion, unloadModel, close, LLAMA_3_2_1B_INST_Q4_0 } from '@qvac/sdk';
+try {
+    const topic = process.argv[2];
+    if (!topic)
+        throw new Error('Usage: rpc-inference.ts <topic>');
+    // Prefer server RDMA offers before assigning aliases. Transport is negotiated at load time.
+    const selected = (await discoverRpcServers({ topic, timeoutMs: 5000 }))
+        .sort((a, b) => Number(b.rdmaAvailable) - Number(a.rdmaAvailable) || a.url.localeCompare(b.url))
+        .slice(0, 2);
+    if (selected.length !== 2)
+        throw new Error('Two idle RPC servers are required');
+    const devices = getRpcDeviceMap(selected);
+    if (!devices.length)
+        throw new Error('The selected servers expose no devices');
+    console.error(`▸ Using ${devices.length} devices across ${selected.length} servers`);
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelConfig: {
+            device: 'gpu',
+            'rpc-servers': selected.map((server) => server.url).join(','),
+            devices: devices.map((device) => device.alias).join(','),
+            'split-mode': 'layer',
+            'tensor-split': devices.map(() => '1').join(',')
+        },
+        onProgress: (progress) => {
+            process.stderr.write(`\r▸ Downloading ${progress.percentage.toFixed(0)}%`);
+        }
+    });
+    try {
+        process.stderr.write('\n');
+        const run = completion({
+            modelId,
+            history: [{ role: 'user', content: 'Explain distributed inference in one sentence.' }],
+            stream: true
+        });
+        for await (const token of run.tokenStream)
+            process.stdout.write(token);
+        process.stdout.write('\n');
+    }
+    finally {
+        await unloadModel({ modelId });
+    }
+}
+catch (error) {
+    console.error('✖', error);
+    process.exitCode = 1;
+}
+finally {
+    await close();
+}

package/dist/examples/rpc-server.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rpc-server.d.ts.map

package/dist/examples/rpc-server.js

@@ -0,0 +1,32 @@
+// Rebuild the worker with
+// rpcServerProvider: '@qvac/sdk/ggml-rpc-server/provider' in qvac.config.json.
+// npx tsx rpc-server.ts 10.0.0.2 my-private-rpc-group
+import { createInterface } from 'node:readline/promises';
+import { startRpcServer, stopRpcServer, close } from '@qvac/sdk';
+try {
+    const host = process.argv[2];
+    const topic = process.argv[3];
+    if (!host || !topic)
+        throw new Error('Usage: rpc-server.ts <private-ipv4> <topic>');
+    const server = await startRpcServer({
+        host,
+        allowNonLoopbackHost: true,
+        discoveryTopic: topic
+    });
+    const input = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        console.error(`▸ Serving ${server.url}; RDMA capable: ${server.rdmaCapable}`);
+        await input.question('▸ Press Enter to stop after clients unload their models.\n');
+    }
+    finally {
+        input.close();
+        await stopRpcServer({ serverId: server.serverId });
+    }
+}
+catch (error) {
+    console.error('✖', error);
+    process.exitCode = 1;
+}
+finally {
+    await close();
+}

package/dist/examples/tools/llamacpp-deferred-tools.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=llamacpp-deferred-tools.d.ts.map

package/dist/examples/tools/llamacpp-deferred-tools.js

@@ -0,0 +1,77 @@
+// Deferred tool loading: a large tool set stays out of the prompt until the
+// model asks for it. Only `get_weather` and the built-in `tool_search` (whose
+// description carries a name-and-description catalog of the rest) are in the
+// initial prompt; the deferred schemas arrive in the conversation when the
+// model searches for them.
+import { TOOL_SEARCH_NAME, completion, executeToolSearch, loadModel, unloadModel, QWEN3_1_7B_INST_Q4 } from '@qvac/sdk';
+import { z } from 'zod';
+import { weatherSchema, horoscopeSchema, mockExecute } from './shared.js';
+const tools = [
+    {
+        name: 'get_weather',
+        description: 'Get current weather for a city',
+        parameters: weatherSchema
+    },
+    {
+        name: 'get_horoscope',
+        description: "Get today's horoscope for an astrological sign",
+        parameters: horoscopeSchema,
+        deferLoading: true,
+        group: 'astrology'
+    },
+    {
+        name: 'get_moon_phase',
+        description: 'Get the current phase of the moon',
+        parameters: z.object({ date: z.string().describe('ISO date').optional() }),
+        deferLoading: true,
+        group: 'astrology'
+    }
+];
+try {
+    const modelId = await loadModel({
+        modelSrc: QWEN3_1_7B_INST_Q4,
+        modelConfig: { ctx_size: 4096, tools: true }
+    });
+    console.log(`▸ Model loaded. Model ID: ${modelId}`);
+    const history = [
+        {
+            role: 'system',
+            content: 'You are a helpful assistant. Search for a tool before calling it.'
+        },
+        { role: 'user', content: "What's my horoscope for Aquarius?" }
+    ];
+    console.log('\n▸ Turn 1 — only get_weather and tool_search are in the prompt\n');
+    const first = completion({ modelId, history, stream: true, tools });
+    for await (const token of first.tokenStream)
+        process.stdout.write(token);
+    const calls = await first.toolCalls;
+    const search = calls.find((call) => call.name === TOOL_SEARCH_NAME);
+    if (!search) {
+        console.log('\n\n▸ The model answered without searching; nothing more to show.');
+    }
+    else {
+        console.log(`\n\n▸ The model searched: ${JSON.stringify(search.arguments)}`);
+        // Running the search is the SDK's job, not a tool handler's. The result is
+        // an ordinary tool message: appending it is what makes the definitions
+        // callable on the next turn.
+        history.push({ role: 'assistant', content: await first.text });
+        history.push({
+            role: 'tool',
+            content: executeToolSearch(tools, search.arguments, history)
+        });
+        console.log('▸ Definitions appended. Turn 2 — the model can now call them directly.\n');
+        const second = completion({ modelId, history, stream: true, tools });
+        for await (const token of second.tokenStream)
+            process.stdout.write(token);
+        for (const call of await second.toolCalls) {
+            console.log(`\n\n▸ Tool call: ${call.name}(${JSON.stringify(call.arguments)})`);
+            console.log(`▸ Result: ${mockExecute(call.name, call.arguments)}`);
+        }
+    }
+    console.log('\n\n▸ Completed!');
+    await unloadModel({ modelId, clearStorage: false });
+}
+catch (error) {
+    console.error('✖', error);
+    process.exit(1);
+}

package/dist/examples/tts/audio8.js

@@ -4,6 +4,8 @@ import { createWav, playAudio, int16ArrayToBuffer, createWavHeader } from './uti
 // primary modelSrc is the LM GGUF; the codec decoder loads via modelConfig.
 // For zero-shot voice cloning also pass audio8CodecEncoderModelSrc plus
 // referenceAudioSrc/referenceText (a recording and its exact transcript).
+// On macOS and iOS the decoder downloads with its Core ML bundle, which runs
+// the codec's synthesis stack; `stats.codecOnCoreml` reports whether it did.
 // Only a fallback: the engine reports the rate it actually produced, and
 // `outputSampleRate` (plus the LavaSR enhancer) can move it off this default.
 const AUDIO8_SAMPLE_RATE = 44100;
@@ -35,7 +37,9 @@ try {
     });
     const audioBuffer = await result.buffer;
     const sampleRate = (await result.sampleRate) ?? AUDIO8_SAMPLE_RATE;
+    const stats = await result.stats;
     console.log(`▸ TTS complete. Total samples: ${audioBuffer.length}`);
+    console.log(`▸ Codec ran on ${stats?.codecOnCoreml === 1 ? 'Core ML' : 'ggml'}`);
     console.log('▸ Saving audio to file...');
     createWav(audioBuffer, sampleRate, 'audio8-output.wav');
     console.log('▸ Audio saved to audio8-output.wav');

package/dist/examples/tts/moss-dialogue.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=moss-dialogue.d.ts.map

package/dist/examples/tts/moss-dialogue.js

@@ -0,0 +1,63 @@
+import { loadModel, textToSpeech, unloadModel, TTS_CODEC_DECODER_MOSS_TTS_F16, TTS_CODEC_ENCODER_MOSS_TTS_F16 } from '@qvac/sdk';
+import { createWav, playAudio, int16ArrayToBuffer, createWavHeader } from './utils.js';
+// MOSS-TTSD (GGML): multi-speaker dialogue in one pass, each voice cloned from
+// a 24 kHz reference recording. The model continues the references, so the
+// text opens with what each recording says under its speaker tag, followed by
+// the lines to generate; only the new lines come out as audio. A dialogue is
+// never split into sentences, so `stream: true` delivers the native chunks of
+// the whole conversation (set `streamChunkTokens` to get them while it is
+// still being generated).
+//
+// The MOSS-TTSD backbone is not in the QVAC Registry yet, so it is a local
+// file; the codec halves it shares with MOSS-TTS download from the registry.
+// Usage: node moss-dialogue.ts <moss-ttsd.gguf> <s1.wav> "<s1 transcript>" <s2.wav> "<s2 transcript>"
+const [backbone, s1Audio, s1Text, s2Audio, s2Text] = process.argv.slice(2);
+if (!backbone || !s1Audio || !s1Text || !s2Audio || !s2Text) {
+    console.error('Usage: node moss-dialogue.ts <moss-ttsd.gguf> <s1.wav> "<s1 transcript>" <s2.wav> "<s2 transcript>"');
+    process.exit(1);
+}
+// Only a fallback: the engine reports the rate it actually produced.
+const MOSS_SAMPLE_RATE = 24000;
+try {
+    const modelId = await loadModel({
+        modelSrc: backbone,
+        modelType: 'tts-ggml',
+        modelConfig: {
+            ttsEngine: 'moss',
+            language: 'en',
+            mossCodecDecoderModelSrc: TTS_CODEC_DECODER_MOSS_TTS_F16,
+            mossCodecEncoderModelSrc: TTS_CODEC_ENCODER_MOSS_TTS_F16,
+            // One recording per speaker, in the order the text tags them.
+            dialogueReferenceSrcs: [s1Audio, s2Audio],
+            streamChunkTokens: 25,
+            useGPU: true
+        }
+    });
+    console.log(`▸ Model loaded: ${modelId}`);
+    console.log('▸ Synthesizing the dialogue...');
+    const result = textToSpeech({
+        modelId,
+        text: `[S1] ${s1Text} [S2] ${s2Text} ` +
+            '[S1] Did the build finish? [S2] Yes, every test passed. [S1] Great, ship it.',
+        stream: true
+    });
+    const samples = [];
+    for await (const sample of result.bufferStream)
+        samples.push(sample);
+    const sampleRate = (await result.sampleRate) ?? MOSS_SAMPLE_RATE;
+    console.log(`▸ Dialogue complete: ${samples.length} samples`);
+    createWav(samples, sampleRate, 'moss-dialogue-output.wav');
+    console.log('▸ Audio saved to moss-dialogue-output.wav');
+    console.log('▸ Playing audio...');
+    const audioData = int16ArrayToBuffer(samples);
+    const wavBuffer = Buffer.concat([createWavHeader(audioData.length, sampleRate), audioData]);
+    playAudio(wavBuffer);
+    console.log('▸ Audio playback complete');
+    await unloadModel({ modelId });
+    console.log('▸ Model unloaded');
+    process.exit(0);
+}
+catch (error) {
+    console.error('✖', error);
+    process.exit(1);
+}

package/dist/examples/tts/moss.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=moss.d.ts.map

package/dist/examples/tts/moss.js

@@ -0,0 +1,71 @@
+import { loadModel, textToSpeech, unloadModel, TTS_DELAY_LLM_MOSS_TTS_F16, TTS_CODEC_DECODER_MOSS_TTS_F16, TTS_CODEC_ENCODER_MOSS_TTS_F16 } from '@qvac/sdk';
+import { createWav, playAudio, int16ArrayToBuffer, createWavHeader } from './utils.js';
+// MOSS (GGML): OpenMOSS MOSS-TTS v1.5 Delay, an 8B backbone (about 17 GB)
+// plus a codec, so desktop only. The primary modelSrc is the backbone; the
+// codec decoder loads via modelConfig, and the codec encoder is only needed to
+// clone a voice from a 24 kHz reference recording (no transcript needed).
+//
+// MOSS streams natively: with `streamChunkTokens` set, `stream: true` emits a
+// chunk every that-many codec frames (12.5 per second) while the backbone is
+// still generating, and the text is synthesized as one utterance, so the
+// `[pause 1.0s]` marker below and `durationTokens` apply to all of it.
+//
+// Uses registry model constants — downloads automatically from QVAC Registry.
+// Usage: node moss.ts [referenceAudio.wav]
+const [referenceAudioSrc] = process.argv.slice(2);
+// Only a fallback: the engine reports the rate it actually produced.
+const MOSS_SAMPLE_RATE = 24000;
+try {
+    const modelId = await loadModel({
+        modelSrc: TTS_DELAY_LLM_MOSS_TTS_F16,
+        modelConfig: {
+            ttsEngine: 'moss',
+            language: 'en',
+            mossCodecDecoderModelSrc: TTS_CODEC_DECODER_MOSS_TTS_F16,
+            ...(referenceAudioSrc
+                ? { mossCodecEncoderModelSrc: TTS_CODEC_ENCODER_MOSS_TTS_F16, referenceAudioSrc }
+                : {}),
+            streamChunkTokens: 25,
+            useGPU: true,
+            seed: 7
+        },
+        onProgress: (p) => {
+            const mb = (n) => (n / 1e6).toFixed(1);
+            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
+            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
+            if (p.percentage >= 100)
+                process.stderr.write('\n');
+        }
+    });
+    console.log(`▸ Model loaded: ${modelId}`);
+    console.log('▸ Streaming MOSS Text-to-Speech...');
+    const started = Date.now();
+    const result = textToSpeech({
+        modelId,
+        text: 'Hold on [pause 1.0s] here it comes: speech that starts playing while the rest is still being generated.',
+        stream: true
+    });
+    const samples = [];
+    for await (const sample of result.bufferStream) {
+        if (samples.length === 0)
+            console.log(`▸ First audio after ${Date.now() - started} ms`);
+        samples.push(sample);
+    }
+    const sampleRate = (await result.sampleRate) ?? MOSS_SAMPLE_RATE;
+    const stats = await result.stats;
+    console.log(`▸ TTS complete: ${samples.length} samples, ${stats?.generatedFrames ?? '?'} codec frames, RTF ${stats?.realTimeFactor?.toFixed(2) ?? '?'}`);
+    createWav(samples, sampleRate, 'moss-output.wav');
+    console.log('▸ Audio saved to moss-output.wav');
+    console.log('▸ Playing audio...');
+    const audioData = int16ArrayToBuffer(samples);
+    const wavBuffer = Buffer.concat([createWavHeader(audioData.length, sampleRate), audioData]);
+    playAudio(wavBuffer);
+    console.log('▸ Audio playback complete');
+    await unloadModel({ modelId });
+    console.log('▸ Model unloaded');
+    process.exit(0);
+}
+catch (error) {
+    console.error('✖', error);
+    process.exit(1);
+}

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

@@ -20,7 +20,7 @@ export declare function buildContract(): {
                 condition: string;
                 responseSchema: string;
             };
-            name: "audioGenStream" | "audioEditStream" | "audioUnderstand" | "heartbeat" | "loadModel" | "downloadAsset" | "completionStream" | "completionOrchestrate" | "batchCompletionStream" | "unloadModel" | "transcribe" | "transcribeStream" | "bciTranscribe" | "bciTranscribeStream" | "loggingStream" | "embed" | "translate" | "textToSpeech" | "textToSpeechStream" | "cancel" | "finetune" | "rag" | "vectorIndex" | "deleteCache" | "getModelInfo" | "getLoadedModelInfo" | "getSystemResources" | "assessModelFit" | "ocrStream" | "diffusionStream" | "videoStream" | "upscaleStream" | "worldSceneStream" | "worldStepStream" | "resume" | "pluginInvoke" | "pluginInvokeStream" | "modelRegistryList" | "modelRegistrySearch" | "modelRegistryGetModel" | "suspend" | "state" | "classify";
+            name: "audioGenStream" | "audioEditStream" | "audioUnderstand" | "startRpcServer" | "stopRpcServer" | "discoverRpcServers" | "heartbeat" | "loadModel" | "downloadAsset" | "completionStream" | "completionOrchestrate" | "batchCompletionStream" | "unloadModel" | "transcribe" | "transcribeStream" | "bciTranscribe" | "bciTranscribeStream" | "loggingStream" | "embed" | "translate" | "textToSpeech" | "textToSpeechStream" | "cancel" | "finetune" | "rag" | "vectorIndex" | "deleteCache" | "getModelInfo" | "getLoadedModelInfo" | "getSystemResources" | "assessModelFit" | "ocrStream" | "diffusionStream" | "videoStream" | "upscaleStream" | "worldSceneStream" | "worldStepStream" | "resume" | "pluginInvoke" | "pluginInvokeStream" | "modelRegistryList" | "modelRegistrySearch" | "modelRegistryGetModel" | "suspend" | "state" | "classify";
             callShape: "duplex" | "request-reply" | "server-stream";
             requestSchema: string;
             responseSchema: string;
@@ -33,6 +33,7 @@ export declare function renderContractFiles(): Promise<{
     'models.json': string;
     'model-type-maps.json': string;
     'error-codes.json': string;
+    'numeric-constants.json': string;
 }>;
 export {};
 //# sourceMappingURL=build-contract.d.ts.map

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

@@ -7,6 +7,7 @@ import { constantsRegistry } from './constants-registry.js';
 import { buildModelsRegistry } from './build-models-registry.js';
 import { buildModelTypeMaps } from './build-model-type-maps.js';
 import { buildErrorCodes } from './build-error-codes.js';
+import { buildNumericConstants } from './build-numeric-constants.js';
 export const contractDir = new URL('../../contract/', import.meta.url);
 export const callShapeByHandlerType = {
     reply: 'request-reply',
@@ -610,11 +611,13 @@ export async function renderContractFiles() {
     const modelsRegistry = buildModelsRegistry();
     const modelTypeMaps = buildModelTypeMaps();
     const errorCodes = buildErrorCodes();
+    const numericConstants = buildNumericConstants();
     return {
         'schema.json': await formatJson(schemaDocument, 'schema.json'),
         'manifest.json': await formatJson(manifest, 'manifest.json'),
         'models.json': await formatJson(modelsRegistry, 'models.json'),
         'model-type-maps.json': await formatJson(modelTypeMaps, 'model-type-maps.json'),
-        'error-codes.json': await formatJson(errorCodes, 'error-codes.json')
+        'error-codes.json': await formatJson(errorCodes, 'error-codes.json'),
+        'numeric-constants.json': await formatJson(numericConstants, 'numeric-constants.json')
     };
 }

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