@qvac/sdk 0.14.1 → 0.15.0

package/dist/schemas/unload-model.js

@@ -1,18 +1,18 @@
-import { z } from "zod";
+import { z } from 'zod';
 export const unloadModelParamsSchema = z.object({
     modelId: z.string(),
     clearStorage: z.boolean().default(false),
-    autoClose: z.boolean().optional(),
+    autoClose: z.boolean().optional()
 });
 export const unloadModelRequestSchema = z.object({
-    type: z.literal("unloadModel"),
+    type: z.literal('unloadModel'),
     modelId: z.string(),
-    clearStorage: z.boolean().default(false),
+    clearStorage: z.boolean().default(false)
 });
 export const unloadModelResponseSchema = z.object({
-    type: z.literal("unloadModel"),
+    type: z.literal('unloadModel'),
     success: z.boolean(),
     error: z.string().optional(),
     hasActiveModels: z.boolean().optional(),
-    hasActiveProviders: z.boolean().optional(),
+    hasActiveProviders: z.boolean().optional()
 });

package/dist/schemas/vla.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const vlaConfigSchema: z.ZodObject<{
     backend: z.ZodOptional<z.ZodEnum<{
         cpu: "cpu";

package/dist/schemas/vla.js

@@ -1,20 +1,20 @@
-import { z } from "zod";
+import { z } from 'zod';
 const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
 // ============================================
 // Load-time config
 // ============================================
 export const vlaConfigSchema = z.object({
     backend: z
-        .enum(["auto", "cpu"])
+        .enum(['auto', 'cpu'])
         .optional()
-        .describe("Backend selection passed to `VlaModel.load({ backend })`. " +
+        .describe('Backend selection passed to `VlaModel.load({ backend })`. ' +
         "`'auto'` (default) prefers an accepted GPU (Vulkan / Metal / OpenCL) and falls back to CPU. " +
         "`'cpu'` forces CPU regardless of available accelerators."),
     verbosity: z
         .number()
         .int()
         .optional()
-        .describe("Native log verbosity forwarded to the addon (0=ERROR, 1=WARN, 2=INFO, 3=DEBUG)."),
+        .describe('Native log verbosity forwarded to the addon (0=ERROR, 1=WARN, 2=INFO, 3=DEBUG).')
 });
 // ============================================
 // Hparams (returned by the addon after load)
@@ -31,16 +31,16 @@ export const vlaHparamsSchema = z.object({
         .int()
         .positive()
         .optional()
-        .describe("Number of camera views the model expects (2 for SmolVLA, 3 for π₀.₅). " +
-        "Pass exactly this many preprocessed frames in `images`. Optional for " +
-        "back-compat — older addon builds may omit it."),
+        .describe('Number of camera views the model expects (2 for SmolVLA, 3 for π₀.₅). ' +
+        'Pass exactly this many preprocessed frames in `images`. Optional for ' +
+        'back-compat — older addon builds may omit it.'),
     stateInputMode: z
-        .enum(["continuous", "discrete"])
+        .enum(['continuous', 'discrete'])
         .optional()
         .describe("How the robot state is consumed. `'continuous'` (SmolVLA): the `state` " +
         "Float32Array is projected by an in-model linear layer. `'discrete'` " +
-        "(π₀.₅): the state is tokenised into the language prompt and the `state` " +
-        "buffer is ignored — pass an empty `Float32Array(0)`. Optional for back-compat."),
+        '(π₀.₅): the state is tokenised into the language prompt and the `state` ' +
+        'buffer is ignored — pass an empty `Float32Array(0)`. Optional for back-compat.')
 });
 // ============================================
 // Stats
@@ -59,7 +59,7 @@ export const vlaStatsSchema = z.object({
     backendDevice: z
         .number()
         .optional()
-        .describe("0 = CPU backend, 1 = GPU backend (Vulkan / Metal / OpenCL)."),
+        .describe('0 = CPU backend, 1 = GPU backend (Vulkan / Metal / OpenCL).')
 });
 // ============================================
 // Run request / response (wire format)
@@ -70,62 +70,62 @@ export const vlaStatsSchema = z.object({
 // and handle the encoding internally.
 // ============================================
 export const vlaRunRequestSchema = z.object({
-    type: z.literal("vlaRun"),
+    type: z.literal('vlaRun'),
     modelId: z.string(),
     images: z
         .array(z.string().min(1).regex(BASE64_PATTERN))
         .min(1)
-        .describe("Base64-encoded preprocessed images. Each entry is the underlying " +
-        "ArrayBuffer of a `Float32Array` produced by `vlaPreprocessImage(...)`. " +
-        "Length per image must equal `3 * imgWidth * imgHeight`."),
+        .describe('Base64-encoded preprocessed images. Each entry is the underlying ' +
+        'ArrayBuffer of a `Float32Array` produced by `vlaPreprocessImage(...)`. ' +
+        'Length per image must equal `3 * imgWidth * imgHeight`.'),
     imgWidth: z.number().int().positive(),
     imgHeight: z.number().int().positive(),
     state: z
         .string()
         .regex(BASE64_PATTERN)
-        .describe("Base64-encoded `Float32Array`. For continuous-state models (SmolVLA) " +
-        "this is length `hparams.maxStateDim` — use " +
-        "`vlaPadState(state, hparams.maxStateDim)` to zero-pad. For " +
+        .describe('Base64-encoded `Float32Array`. For continuous-state models (SmolVLA) ' +
+        'this is length `hparams.maxStateDim` — use ' +
+        '`vlaPadState(state, hparams.maxStateDim)` to zero-pad. For ' +
         "discrete-state models (π₀.₅, `stateInputMode: 'discrete'`) the state " +
-        "is tokenised into the prompt and this buffer is ignored — encode an " +
-        "empty `Float32Array(0)` (which is the empty string)."),
+        'is tokenised into the prompt and this buffer is ignored — encode an ' +
+        'empty `Float32Array(0)` (which is the empty string).'),
     tokens: z
         .string()
         .min(1)
         .regex(BASE64_PATTERN)
-        .describe("Base64-encoded `Int32Array` of length `hparams.tokenizerMaxLength`."),
+        .describe('Base64-encoded `Int32Array` of length `hparams.tokenizerMaxLength`.'),
     mask: z
         .string()
         .min(1)
         .regex(BASE64_PATTERN)
-        .describe("Base64-encoded `Uint8Array` of length `hparams.tokenizerMaxLength`."),
+        .describe('Base64-encoded `Uint8Array` of length `hparams.tokenizerMaxLength`.'),
     noise: z
         .string()
         .min(1)
         .regex(BASE64_PATTERN)
         .optional()
-        .describe("Optional base64-encoded `Float32Array` of length " +
-        "`hparams.chunkSize * hparams.maxActionDim`. When omitted the addon " +
-        "samples its own prior."),
+        .describe('Optional base64-encoded `Float32Array` of length ' +
+        '`hparams.chunkSize * hparams.maxActionDim`. When omitted the addon ' +
+        'samples its own prior.')
 });
 export const vlaRunResponseSchema = z.object({
     actions: z
         .string()
         .min(1)
         .regex(BASE64_PATTERN)
-        .describe("Base64-encoded `Float32Array` of length `hparams.chunkSize * hparams.actionDim`."),
+        .describe('Base64-encoded `Float32Array` of length `hparams.chunkSize * hparams.actionDim`.'),
     actionDim: z.number().int().positive(),
     chunkSize: z.number().int().positive(),
-    stats: vlaStatsSchema.optional(),
+    stats: vlaStatsSchema.optional()
 });
 // ============================================
 // Hparams request / response (plugin handler)
 // ============================================
 export const vlaHparamsRequestSchema = z.object({
-    type: z.literal("vlaHparams"),
-    modelId: z.string(),
+    type: z.literal('vlaHparams'),
+    modelId: z.string()
 });
 export const vlaHparamsResponseSchema = z.object({
     hparams: vlaHparamsSchema,
-    backendName: z.string().nullable(),
+    backendName: z.string().nullable()
 });

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;