@qvac/sdk 0.14.1 → 0.16.0

package/dist/scripts/contract/build-model-type-maps.js

@@ -0,0 +1,16 @@
+import { ModelTypeAliases } from '../../schemas/model-types.js';
+import { ENGINE_TO_ADDON, LEGACY_ENGINE_TO_CANONICAL } from '../../schemas/engine-addon-map.js';
+function sortedEntries(record) {
+    const entries = Object.entries(record);
+    entries.sort(function (a, b) {
+        return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
+    });
+    return Object.fromEntries(entries);
+}
+export function buildModelTypeMaps() {
+    return {
+        aliasToCanonical: sortedEntries(ModelTypeAliases),
+        engineToAddon: sortedEntries(ENGINE_TO_ADDON),
+        legacyEngineToCanonical: sortedEntries(LEGACY_ENGINE_TO_CANONICAL)
+    };
+}

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

@@ -0,0 +1,17 @@
+import type { ModelConstant } from '../../models/registry/index';
+/**
+ * JSON export of every named model constant in `@/models/registry`
+ * (`QWEN3_600M_INST_Q4`, `BCI_EMBEDDER`, ...) — the same constants JS
+ * consumers import directly and pass as `modelSrc`
+ * (`loadModel({ modelSrc: QWEN3_600M_INST_Q4, ... })`). Only the ~440
+ * promoted-to-a-named-export entries are included, not the full ~780-entry
+ * `models` array — entries without a name aren't meant for direct import in
+ * JS either.
+ *
+ * This is a separate artifact from schema.json/manifest.json: it's a static
+ * data catalog, not part of the RPC wire contract, but it lives alongside
+ * them in contract/ for the same reason — a language-neutral build artifact
+ * downstream client generators (starting with Python) consume.
+ */
+export declare function buildModelsRegistry(): Record<string, ModelConstant>;
+//# sourceMappingURL=build-models-registry.d.ts.map

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

@@ -0,0 +1,31 @@
+import * as registry from '../../models/registry/index.js';
+function isModelConstant(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        typeof value.src === 'string');
+}
+/**
+ * JSON export of every named model constant in `@/models/registry`
+ * (`QWEN3_600M_INST_Q4`, `BCI_EMBEDDER`, ...) — the same constants JS
+ * consumers import directly and pass as `modelSrc`
+ * (`loadModel({ modelSrc: QWEN3_600M_INST_Q4, ... })`). Only the ~440
+ * promoted-to-a-named-export entries are included, not the full ~780-entry
+ * `models` array — entries without a name aren't meant for direct import in
+ * JS either.
+ *
+ * This is a separate artifact from schema.json/manifest.json: it's a static
+ * data catalog, not part of the RPC wire contract, but it lives alongside
+ * them in contract/ for the same reason — a language-neutral build artifact
+ * downstream client generators (starting with Python) consume.
+ */
+export function buildModelsRegistry() {
+    const namespace = registry;
+    const entries = Object.entries(namespace).filter(function (entry) {
+        return isModelConstant(entry[1]);
+    });
+    entries.sort(function (a, b) {
+        return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
+    });
+    return Object.fromEntries(entries);
+}

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

@@ -0,0 +1,23 @@
+import type { QvacPlugin } from '../../schemas/index';
+export interface PluginHandlerContract {
+    name: string;
+    streaming: boolean;
+    requestSchema: unknown;
+    responseSchema: unknown;
+}
+export interface PluginContract {
+    modelType: string;
+    displayName?: string;
+    handlers: PluginHandlerContract[];
+}
+/**
+ * Wire contract of one registered plugin: JSON Schema per handler, in the
+ * same wire shape the built-in contract export uses (requests as input
+ * shape, responses as output shape). Custom plugins register at runtime, so
+ * unlike the built-in contract this isn't emitted by `contract:export` —
+ * plugin authors (or app builds) run `scripts/export-plugin-contract.ts` on
+ * their plugin module and feed the result to the Python generator's
+ * `--plugin` input to get typed clients for their handlers.
+ */
+export declare function buildPluginContract(plugin: QvacPlugin): PluginContract;
+//# sourceMappingURL=plugin-contract.d.ts.map

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

@@ -0,0 +1,28 @@
+import { toWireJsonSchema } from './build-contract.js';
+/**
+ * Wire contract of one registered plugin: JSON Schema per handler, in the
+ * same wire shape the built-in contract export uses (requests as input
+ * shape, responses as output shape). Custom plugins register at runtime, so
+ * unlike the built-in contract this isn't emitted by `contract:export` —
+ * plugin authors (or app builds) run `scripts/export-plugin-contract.ts` on
+ * their plugin module and feed the result to the Python generator's
+ * `--plugin` input to get typed clients for their handlers.
+ */
+export function buildPluginContract(plugin) {
+    const handlers = Object.entries(plugin.handlers).map(function ([name, handler]) {
+        return {
+            name,
+            streaming: handler.streaming === true,
+            requestSchema: toWireJsonSchema(handler.requestSchema, 'input', `${plugin.modelType}.${name}.request`),
+            responseSchema: toWireJsonSchema(handler.responseSchema, 'output', `${plugin.modelType}.${name}.response`)
+        };
+    });
+    handlers.sort(function (a, b) {
+        return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+    });
+    return {
+        modelType: plugin.modelType,
+        ...(plugin.displayName && { displayName: plugin.displayName }),
+        handlers
+    };
+}

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

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

package/dist/scripts/export-contract.js

@@ -0,0 +1,27 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { contractDir, renderContractFiles } from './contract/build-contract.js';
+const checkOnly = process.argv.includes('--check');
+const files = await renderContractFiles();
+await mkdir(contractDir, { recursive: true });
+let stale = false;
+for (const [name, content] of Object.entries(files)) {
+    const filePath = fileURLToPath(new URL(name, contractDir));
+    if (checkOnly) {
+        const existing = await readFile(filePath, 'utf8').catch(function () {
+            return null;
+        });
+        if (existing !== content) {
+            console.error(`contract/${name} is ${existing === null ? 'missing' : 'out of date'}`);
+            stale = true;
+        }
+    }
+    else {
+        await writeFile(filePath, content);
+        console.log(`wrote contract/${name}`);
+    }
+}
+if (stale) {
+    console.error("Contract artifacts are stale. Run 'bun run contract:export' and commit the result.");
+    process.exit(1);
+}

package/dist/scripts/export-plugin-contract.d.ts

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

package/dist/scripts/export-plugin-contract.js

@@ -0,0 +1,18 @@
+import { writeFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { buildPluginContract } from './contract/plugin-contract.js';
+// Usage: tsx scripts/export-plugin-contract.ts <plugin-module> <out.json>
+// The plugin module's default export must be a definePlugin(...) value.
+const [modulePath, outPath] = process.argv.slice(2);
+if (!modulePath || !outPath) {
+    console.error('usage: export-plugin-contract <plugin-module> <out.json>');
+    process.exit(1);
+}
+const imported = (await import(pathToFileURL(modulePath).href));
+if (!imported.default) {
+    console.error(`${modulePath} has no default export`);
+    process.exit(1);
+}
+const contract = buildPluginContract(imported.default);
+await writeFile(outPath, JSON.stringify(contract, null, 2) + '\n');
+console.log(`wrote ${outPath} (${contract.handlers.length} handlers)`);

package/dist/scripts/run-security-tests.js

@@ -1,19 +1,18 @@
-import { readdirSync } from "fs";
-import { join, dirname } from "path";
-import { spawnSync } from "child_process";
-import { fileURLToPath } from "url";
+import { readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const testDir = join(__dirname, "..", "test", "unit");
-const testFiles = readdirSync(testDir).filter((f) => (f.startsWith("path-traversal") || f.startsWith("path-security")) &&
-    f.endsWith(".test.ts"));
+const testDir = join(__dirname, '..', 'test', 'unit');
+const testFiles = readdirSync(testDir).filter((f) => (f.startsWith('path-traversal') || f.startsWith('path-security')) && f.endsWith('.test.ts'));
 if (testFiles.length === 0) {
-    console.log("No security tests found.");
+    console.log('No security tests found.');
     process.exit(0);
 }
 let hasFailure = false;
 for (const file of testFiles) {
-    const result = spawnSync("bun", ["run", join(testDir, file)], {
-        stdio: "inherit",
+    const result = spawnSync('bun', ['run', join(testDir, file)], {
+        stdio: 'inherit'
     });
     if (result.status !== 0) {
         hasFailure = true;

package/dist/scripts/run-unit-tests.js

@@ -1,9 +1,9 @@
-import { readFileSync, readdirSync } from "fs";
-import { join, dirname } from "path";
-import { spawnSync } from "child_process";
-import { fileURLToPath } from "url";
+import { readFileSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const testDir = join(__dirname, "..", "test", "unit");
+const testDir = join(__dirname, '..', 'test', 'unit');
 function collectTestFiles(dir) {
     const files = [];
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
@@ -11,7 +11,7 @@ function collectTestFiles(dir) {
         if (entry.isDirectory()) {
             files.push(...collectTestFiles(fullPath));
         }
-        else if (entry.isFile() && entry.name.endsWith(".test.ts")) {
+        else if (entry.isFile() && entry.name.endsWith('.test.ts')) {
             files.push(fullPath);
         }
     }
@@ -20,14 +20,13 @@ function collectTestFiles(dir) {
 const testFiles = collectTestFiles(testDir);
 let hasFailure = false;
 function usesNodeTestRunner(filePath) {
-    const source = readFileSync(filePath, "utf8");
-    return (source.includes("from 'node:test'") ||
-        source.includes('from "node:test"'));
+    const source = readFileSync(filePath, 'utf8');
+    return source.includes("from 'node:test'") || source.includes('from "node:test"');
 }
 for (const file of testFiles) {
-    const args = usesNodeTestRunner(file) ? ["test", file] : ["run", file];
-    const result = spawnSync("bun", args, {
-        stdio: "inherit",
+    const args = usesNodeTestRunner(file) ? ['test', file] : ['run', file];
+    const result = spawnSync('bun', args, {
+        stdio: 'inherit'
     });
     if (result.status !== 0) {
         hasFailure = true;

package/dist/server/bare/delegate-connect-diagnostics.js

@@ -1,5 +1,5 @@
-import { withTimeout } from "../../utils/withTimeout.js";
-import { getServerLogger } from "../../logging/index.js";
+import { withTimeout } from '../../utils/withTimeout.js';
+import { getServerLogger } from '../../logging/index.js';
 const logger = getServerLogger();
 export const DHT_BOOTSTRAP_WAIT_CAP_MS = 5000;
 // A cold routing table makes findPeer return empty -> spurious PEER_NOT_FOUND,
@@ -7,9 +7,7 @@ export const DHT_BOOTSTRAP_WAIT_CAP_MS = 5000;
 export async function ensureDhtBootstrapped(dht, timeout) {
     if (dht.bootstrapped)
         return;
-    const cap = timeout === undefined
-        ? DHT_BOOTSTRAP_WAIT_CAP_MS
-        : Math.min(timeout, DHT_BOOTSTRAP_WAIT_CAP_MS);
+    const cap = timeout === undefined ? DHT_BOOTSTRAP_WAIT_CAP_MS : Math.min(timeout, DHT_BOOTSTRAP_WAIT_CAP_MS);
     try {
         await withTimeout(dht.fullyBootstrapped(), cap);
     }
@@ -21,22 +19,18 @@ export async function ensureDhtBootstrapped(dht, timeout) {
 // on the DHT vs found-but-un-holepunchable. Relays only bridge after a peer is
 // found, so they can never resolve a PEER_NOT_FOUND.
 export function describeConnectFailure(error, publicKey, relayCount) {
-    const code = typeof error === "object" && error !== null && "code" in error
-        ? String(error.code)
-        : undefined;
-    const relayNote = relayCount > 0
-        ? `${relayCount} swarm relay(s) configured`
-        : "no swarm relays configured";
+    const code = typeof error === 'object' && error !== null && 'code' in error ? String(error.code) : undefined;
+    const relayNote = relayCount > 0 ? `${relayCount} swarm relay(s) configured` : 'no swarm relays configured';
     switch (code) {
-        case "PEER_NOT_FOUND":
+        case 'PEER_NOT_FOUND':
             return `provider ${publicKey} was not found on the DHT — it may be offline, still bootstrapping, or unreachable from this network. Relays bridge a connection only after the provider is located, so they cannot find an unannounced provider (${relayNote}).`;
-        case "PEER_CONNECTION_FAILED":
-        case "CANNOT_HOLEPUNCH":
-        case "REMOTE_NOT_HOLEPUNCHABLE":
-        case "REMOTE_NOT_HOLEPUNCHING":
-        case "HOLEPUNCH_ABORTED":
-        case "HOLEPUNCH_PROBE_TIMEOUT":
-        case "HOLEPUNCH_DOUBLE_RANDOMIZED_NATS":
+        case 'PEER_CONNECTION_FAILED':
+        case 'CANNOT_HOLEPUNCH':
+        case 'REMOTE_NOT_HOLEPUNCHABLE':
+        case 'REMOTE_NOT_HOLEPUNCHING':
+        case 'HOLEPUNCH_ABORTED':
+        case 'HOLEPUNCH_PROBE_TIMEOUT':
+        case 'HOLEPUNCH_DOUBLE_RANDOMIZED_NATS':
             return `provider ${publicKey} was found but a connection could not be established (NAT/holepunch failure: ${code}; ${relayNote}).`;
         default:
             return error instanceof Error ? error.message : String(error);

package/dist/server/bare/delegate-rpc-client.d.ts

@@ -1,5 +1,5 @@
-import RPC from "bare-rpc";
-import type { RPCOptions } from "../../schemas/index";
+import RPC from 'bare-rpc';
+import type { RPCOptions } from '../../schemas/index';
 export declare function getRPC(publicKey: string, options?: RPCOptions): Promise<RPC>;
 /**
  * Remove a stale RPC connection for a peer.

package/dist/server/bare/delegate-rpc-client.js

@@ -1,14 +1,14 @@
-import { getSwarm } from "./hyperswarm.js";
-import { getSDKConfig } from "./registry/config-registry.js";
-import { ensureDhtBootstrapped, describeConnectFailure, } from "./delegate-connect-diagnostics.js";
-import RPC from "bare-rpc";
-import { withTimeout } from "../../utils/withTimeout.js";
-import { DelegateConnectionFailedError } from "../../utils/errors-server.js";
-import { getServerLogger } from "../../logging/index.js";
-import { nowMs } from "../../profiling/index.js";
-import { cacheDelegationConnectionTime, clearPeerConnectionTracking, } from "../rpc/profiling/delegation-profiler.js";
-import { getNextCommandId } from "../rpc/rpc-utils.js";
-import { Buffer } from "bare-buffer";
+import { getSwarm } from './hyperswarm.js';
+import { getSDKConfig } from './registry/config-registry.js';
+import { ensureDhtBootstrapped, describeConnectFailure } from './delegate-connect-diagnostics.js';
+import RPC from 'bare-rpc';
+import { withTimeout } from '../../utils/withTimeout.js';
+import { DelegateConnectionFailedError } from '../../utils/errors-server.js';
+import { getServerLogger } from '../../logging/index.js';
+import { nowMs } from '../../profiling/index.js';
+import { cacheDelegationConnectionTime, clearPeerConnectionTracking } from '../rpc/profiling/delegation-profiler.js';
+import { getNextCommandId } from '../rpc/rpc-utils.js';
+import { Buffer } from 'bare-buffer';
 const logger = getServerLogger();
 const activeRPCs = new Map();
 const activeConnections = new Map();
@@ -22,27 +22,27 @@ function getConfiguredRelayCount() {
     return getSDKConfig().swarmRelays?.length ?? 0;
 }
 function isHeartbeatResponse(payload) {
-    return (typeof payload === "object" &&
+    return (typeof payload === 'object' &&
         payload !== null &&
-        payload["type"] === "heartbeat");
+        payload['type'] === 'heartbeat');
 }
 async function isRPCConnectionHealthy(rpc, timeout = HEALTH_CHECK_TIMEOUT_MS) {
     try {
         const req = rpc.request(getNextCommandId());
-        req.send(JSON.stringify({ type: "heartbeat" }), "utf-8");
-        const response = await withTimeout(req.reply("utf-8"), timeout);
-        const payload = JSON.parse(response?.toString() || "{}");
+        req.send(JSON.stringify({ type: 'heartbeat' }), 'utf-8');
+        const response = await withTimeout(req.reply('utf-8'), timeout);
+        const payload = JSON.parse(response?.toString() || '{}');
         return isHeartbeatResponse(payload);
     }
     catch (error) {
-        logger.debug("RPC health check failed", { error });
+        logger.debug('RPC health check failed', { error });
         return false;
     }
 }
 function trackConnection(publicKey, conn, rpc) {
     activeRPCs.set(publicKey, rpc);
     activeConnections.set(publicKey, conn);
-    conn.on("close", () => {
+    conn.on('close', () => {
         logger.debug(`Connection closed for peer: ${publicKey}`);
         if (activeConnections.get(publicKey) === conn) {
             activeConnections.delete(publicKey);
@@ -50,7 +50,7 @@ function trackConnection(publicKey, conn, rpc) {
             clearPeerConnectionTracking(publicKey);
         }
     });
-    conn.on("error", (err) => {
+    conn.on('error', (err) => {
         logger.error(`Connection error for peer ${publicKey}:`, err);
         if (activeConnections.get(publicKey) === conn) {
             activeConnections.delete(publicKey);
@@ -67,7 +67,7 @@ async function closeConnection(publicKey) {
     // Wait for the close event before returning so any pending cleanup
     // in the underlying DHT stream completes before we reconnect.
     await new Promise((resolve) => {
-        existingConnection.once("close", () => resolve());
+        existingConnection.once('close', () => resolve());
         existingConnection.destroy();
     });
     if (activeConnections.get(publicKey) === existingConnection) {
@@ -81,12 +81,10 @@ async function closeConnection(publicKey) {
 // swarm.join()/flush() and let the DHT route by public key.
 function openDhtConnection(publicKey) {
     const swarm = getSwarm();
-    const relayThrough = swarm.relayThrough
-        ? swarm.relayThrough(false, swarm)
-        : null;
-    return swarm.dht.connect(Buffer.from(publicKey, "hex"), {
+    const relayThrough = swarm.relayThrough ? swarm.relayThrough(false, swarm) : null;
+    return swarm.dht.connect(Buffer.from(publicKey, 'hex'), {
         keyPair: swarm.keyPair,
-        relayThrough,
+        relayThrough
     });
 }
 // Resolve when the DHT connection emits "open"; reject promptly on "error"
@@ -95,9 +93,9 @@ function openDhtConnection(publicKey) {
 function waitForOpen(conn, timeout) {
     const opened = new Promise((resolve, reject) => {
         const cleanup = () => {
-            conn.removeListener("open", onOpen);
-            conn.removeListener("error", onError);
-            conn.removeListener("close", onClose);
+            conn.removeListener('open', onOpen);
+            conn.removeListener('error', onError);
+            conn.removeListener('close', onClose);
         };
         const onOpen = () => {
             cleanup();
@@ -109,11 +107,11 @@ function waitForOpen(conn, timeout) {
         };
         const onClose = () => {
             cleanup();
-            reject(new DelegateConnectionFailedError("Connection closed before open (peer unreachable or rejected by firewall)"));
+            reject(new DelegateConnectionFailedError('Connection closed before open (peer unreachable or rejected by firewall)'));
         };
-        conn.once("open", onOpen);
-        conn.once("error", onError);
-        conn.once("close", onClose);
+        conn.once('open', onOpen);
+        conn.once('error', onError);
+        conn.once('close', onClose);
     });
     return withTimeout(opened, timeout);
 }
@@ -142,7 +140,7 @@ async function ensureRPCConnection(publicKey, timeout, healthCheckTimeout) {
     let conn;
     const relayCount = getConfiguredRelayCount();
     try {
-        logger.info(`🔗 Establishing direct DHT connection to peer: ${publicKey}${timeout ? `, timeout: ${timeout}ms` : ""} (${relayCount} swarm relay(s) configured)`);
+        logger.info(`🔗 Establishing direct DHT connection to peer: ${publicKey}${timeout ? `, timeout: ${timeout}ms` : ''} (${relayCount} swarm relay(s) configured)`);
         await ensureDhtBootstrapped(getSwarm().dht, getRemainingTimeout());
         conn = openDhtConnection(publicKey);
         await waitForOpen(conn, getRemainingTimeout());
@@ -160,7 +158,7 @@ async function ensureRPCConnection(publicKey, timeout, healthCheckTimeout) {
             conn.destroy();
         }
         cleanupStaleConnection(publicKey);
-        logger.error("Failed to establish RPC connection:", error);
+        logger.error('Failed to establish RPC connection:', error);
         throw new DelegateConnectionFailedError(`RPC connection failed: ${describeConnectFailure(error, publicKey, relayCount)}`, error);
     }
 }

package/dist/server/bare/hyperswarm.d.ts

@@ -1,6 +1,6 @@
-import Hyperswarm from "hyperswarm";
-import { type FirewallConfig } from "../../schemas/provide";
-export declare function getSwarm({ firewallConfig, }?: {
+import Hyperswarm from 'hyperswarm';
+import { type FirewallConfig } from '../../schemas/provide';
+export declare function getSwarm({ firewallConfig }?: {
     firewallConfig?: FirewallConfig | undefined;
 }): Hyperswarm;
 export declare function registerProvider(): void;

package/dist/server/bare/hyperswarm.js

@@ -1,16 +1,16 @@
-import env from "bare-env";
-import Hyperswarm from "hyperswarm";
-import crypto from "bare-crypto";
-import { envSchema } from "../../schemas/provide.js";
-import { getSDKConfig } from "./registry/config-registry.js";
-import { registerSwarm, unregisterSwarm, } from "./runtime-lifecycle.js";
-import { getServerLogger } from "../../logging/index.js";
-import { Buffer } from "bare-buffer";
+import env from 'bare-env';
+import Hyperswarm from 'hyperswarm';
+import crypto from 'bare-crypto';
+import { envSchema } from '../../schemas/provide.js';
+import { getSDKConfig } from './registry/config-registry.js';
+import { registerSwarm, unregisterSwarm } from './runtime-lifecycle.js';
+import { getServerLogger } from '../../logging/index.js';
+import { Buffer } from 'bare-buffer';
 const logger = getServerLogger();
 function getHyperswarmSeedBuffer() {
     const parsedEnv = envSchema.safeParse(env);
     if (parsedEnv.success) {
-        return Buffer.from(parsedEnv.data.QVAC_HYPERSWARM_SEED, "hex");
+        return Buffer.from(parsedEnv.data.QVAC_HYPERSWARM_SEED, 'hex');
     }
     else {
         logger.info(`🎲 No seed provided, generating random seed (provider will have random identity)`);
@@ -24,8 +24,8 @@ function createFirewallFunction(config) {
     const { mode, publicKeys } = config;
     const publicKeySet = new Set(publicKeys);
     return (remotePublicKey) => {
-        const remoteKeyHex = remotePublicKey.toString("hex");
-        if (mode === "allow") {
+        const remoteKeyHex = remotePublicKey.toString('hex');
+        if (mode === 'allow') {
             const allowed = publicKeySet.has(remoteKeyHex);
             if (!allowed) {
                 logger.debug(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (not in allowlist)`);
@@ -56,7 +56,7 @@ function createSwarm(firewallConfig) {
         if (!relayPublicKeys || relayPublicKeys.length === 0) {
             return null;
         }
-        return relayPublicKeys.map((key) => Buffer.from(key, "hex"));
+        return relayPublicKeys.map((key) => Buffer.from(key, 'hex'));
     };
     const swarmOptions = { seed, firewall, relayThrough: getRelays };
     return new Hyperswarm(swarmOptions);
@@ -67,12 +67,12 @@ let swarm = null;
 // calls and to avoid ever reporting "no active providers" while one is still
 // running.
 let activeProviderCount = 0;
-export function getSwarm({ firewallConfig, } = {}) {
+export function getSwarm({ firewallConfig } = {}) {
     if (swarm) {
         return swarm;
     }
     swarm = createSwarm(firewallConfig);
-    registerSwarm(swarm, { label: "shared-swarm", createdAt: Date.now() });
+    registerSwarm(swarm, { label: 'shared-swarm', createdAt: Date.now() });
     return swarm;
 }
 export function registerProvider() {

package/dist/server/bare/ops/bci-transcribe.d.ts

@@ -1,4 +1,4 @@
-import { type BciStreamOpts, type BciTranscribeParams, type TranscribeSegment, type TranscribeStats } from "../../../schemas/index";
+import { type BciStreamOpts, type BciTranscribeParams, type TranscribeSegment, type TranscribeStats } from '../../../schemas/index';
 type BciTranscribeReturn = {
     modelExecutionMs: number;
     stats?: TranscribeStats;