@qvac/sdk 0.15.0 → 0.17.0

package/dist/server/bare/resources/collector.js

@@ -0,0 +1,226 @@
+import { failedMetric, normalizeBooleanMetric, normalizeEnumMetric, normalizeNonNegativeIntegerMetric, normalizeNonNegativeMetric, normalizePositiveIntegerMetric, normalizeStringMetric, normalizeUtilizationMetric, unavailableMetric, unverifiedMetric } from '../../../server/bare/resources/normalize.js';
+const CPU_SOURCE = 'bare-cpu-info';
+const GPU_SOURCE = 'bare-gpu-info';
+const GPU_MEMORY_SCOPE_REASON = 'GPU memory scope is unverified';
+const cpuSystemProvenance = {
+    source: CPU_SOURCE,
+    scope: 'system'
+};
+const cpuProvenance = {
+    source: CPU_SOURCE
+};
+const gpuDeviceProvenance = {
+    source: GPU_SOURCE,
+    scope: 'device'
+};
+const gpuProvenance = {
+    source: GPU_SOURCE
+};
+function supportedMetric(value, provenance) {
+    return { status: 'supported', value, provenance };
+}
+function normalizeAmbiguousNonNegativeMetric(value, reason) {
+    if (value === undefined || value === null)
+        return unavailableMetric();
+    const normalized = normalizeNonNegativeMetric(value, gpuDeviceProvenance);
+    if (normalized.status !== 'supported')
+        return normalized;
+    return unverifiedMetric(reason);
+}
+function normalizeDriverCapabilities(drivers) {
+    return {
+        vulkan: normalizeBooleanMetric(drivers.vulkan, gpuProvenance),
+        opencl: normalizeBooleanMetric(drivers.opencl, gpuProvenance),
+        opengl: normalizeBooleanMetric(drivers.opengl, gpuProvenance),
+        webgpu: normalizeBooleanMetric(drivers.webgpu, gpuProvenance),
+        metal: normalizeBooleanMetric(drivers.metal, gpuProvenance),
+        direct3d11: normalizeBooleanMetric(drivers.direct3d11, gpuProvenance),
+        direct3d12: normalizeBooleanMetric(drivers.direct3d12, gpuProvenance),
+        cuda: normalizeBooleanMetric(drivers.cuda, gpuProvenance),
+        levelZero: normalizeBooleanMetric(drivers.levelZero, gpuProvenance),
+        rocm: normalizeBooleanMetric(drivers.rocm, gpuProvenance)
+    };
+}
+function normalizeCPUCapabilities(cpu, architectures) {
+    return {
+        name: normalizeStringMetric(cpu.name, cpuProvenance),
+        vendor: normalizeStringMetric(cpu.vendor, cpuProvenance),
+        architecture: normalizeEnumMetric(cpu.arch, architectures, cpuProvenance),
+        physicalCores: normalizePositiveIntegerMetric(cpu.physicalCores, cpuProvenance),
+        logicalCores: normalizePositiveIntegerMetric(cpu.logicalCores, cpuProvenance),
+        performanceCores: normalizeNonNegativeIntegerMetric(cpu.performanceCores, cpuProvenance),
+        efficiencyCores: normalizeNonNegativeIntegerMetric(cpu.efficiencyCores, cpuProvenance),
+        frequencyHz: normalizePositiveIntegerMetric(cpu.frequency, cpuProvenance),
+        cacheLineBytes: normalizePositiveIntegerMetric(cpu.cacheLine, cpuProvenance)
+    };
+}
+function normalizeGPUCapabilities(gpu, id, gpuTypes) {
+    return {
+        id,
+        name: normalizeStringMetric(gpu.name, gpuDeviceProvenance),
+        vendor: normalizeStringMetric(gpu.vendor, gpuDeviceProvenance),
+        type: normalizeEnumMetric(gpu.type, gpuTypes, gpuDeviceProvenance),
+        driverName: normalizeStringMetric(gpu.driverName, gpuDeviceProvenance),
+        driverVersion: normalizeStringMetric(gpu.driverVersion, gpuDeviceProvenance),
+        drivers: normalizeDriverCapabilities(gpu.drivers),
+        unifiedMemory: normalizeBooleanMetric(gpu.unifiedMemory, gpuDeviceProvenance),
+        memoryTotalBytes: normalizeAmbiguousNonNegativeMetric(gpu.memory, GPU_MEMORY_SCOPE_REASON)
+    };
+}
+function failedCPUSample(reason) {
+    const failure = failedMetric(reason);
+    return {
+        cpu: failure,
+        memory: {
+            usedBytes: failure,
+            totalBytes: failure
+        }
+    };
+}
+function failedGPUSample(id, reason) {
+    return {
+        id,
+        compute: failedMetric(reason),
+        encode: failedMetric(reason),
+        decode: failedMetric(reason),
+        memoryUsedBytes: failedMetric(reason),
+        memoryTotalBytes: failedMetric(reason),
+        powerWatts: failedMetric(reason),
+        temperatureCelsius: failedMetric(reason)
+    };
+}
+function normalizeGPUSample(id, usage) {
+    return {
+        id,
+        compute: normalizeUtilizationMetric(usage.compute, gpuDeviceProvenance),
+        encode: normalizeUtilizationMetric(usage.encode, gpuDeviceProvenance),
+        decode: normalizeUtilizationMetric(usage.decode, gpuDeviceProvenance),
+        memoryUsedBytes: normalizeAmbiguousNonNegativeMetric(usage.memoryUsed, 'GPU memory usage scope is unverified'),
+        memoryTotalBytes: normalizeAmbiguousNonNegativeMetric(usage.memoryTotal, GPU_MEMORY_SCOPE_REASON),
+        powerWatts: normalizeNonNegativeMetric(usage.power, gpuDeviceProvenance),
+        temperatureCelsius: normalizeNonNegativeMetric(usage.temperature, gpuDeviceProvenance)
+    };
+}
+function destroyContext(context) {
+    try {
+        context?.destroy();
+    }
+    catch {
+        // Teardown must continue so every native context gets a release attempt.
+    }
+}
+export function createSystemResourceCollector(dependencies) {
+    let cpuContext;
+    let gpuContext;
+    let gpuIds = [];
+    let destroyed = false;
+    let cpuCapabilities;
+    let memoryCapabilities;
+    let gpuCapabilities;
+    try {
+        const context = dependencies.createCPUInfo();
+        if (!context) {
+            cpuCapabilities = failedMetric('CPU collector module is unavailable');
+            memoryCapabilities = {
+                totalBytes: failedMetric('CPU collector module is unavailable')
+            };
+        }
+        else {
+            cpuContext = context;
+            const cpu = context.query();
+            cpuCapabilities = supportedMetric(normalizeCPUCapabilities(cpu, dependencies.cpuArchitectures), cpuProvenance);
+            memoryCapabilities = {
+                totalBytes: normalizePositiveIntegerMetric(cpu.memory, cpuSystemProvenance)
+            };
+        }
+    }
+    catch {
+        cpuCapabilities = failedMetric('CPU collector initialization failed');
+        memoryCapabilities = {
+            totalBytes: failedMetric('CPU collector initialization failed')
+        };
+    }
+    try {
+        const context = dependencies.createGPUInfo();
+        if (!context) {
+            gpuCapabilities = failedMetric('GPU collector module is unavailable');
+        }
+        else {
+            gpuContext = context;
+            const gpus = context.gpus();
+            const normalized = gpus.map((gpu) => normalizeGPUCapabilities(gpu, dependencies.createGPUId(), dependencies.gpuTypes));
+            gpuIds = normalized.map((gpu) => gpu.id);
+            gpuCapabilities = supportedMetric(normalized, gpuProvenance);
+        }
+    }
+    catch {
+        gpuCapabilities = failedMetric('GPU collector initialization failed');
+    }
+    const capabilities = {
+        cpu: cpuCapabilities,
+        memory: memoryCapabilities,
+        gpus: gpuCapabilities
+    };
+    function getCapabilities() {
+        return capabilities;
+    }
+    function sampleCPU() {
+        if (!cpuContext) {
+            return failedCPUSample('CPU collector is unavailable');
+        }
+        try {
+            const usage = cpuContext.sample();
+            return {
+                cpu: normalizeUtilizationMetric(usage.compute, cpuSystemProvenance),
+                memory: {
+                    usedBytes: normalizeNonNegativeIntegerMetric(usage.memoryUsed, cpuSystemProvenance),
+                    totalBytes: normalizePositiveIntegerMetric(usage.memoryTotal, cpuSystemProvenance)
+                }
+            };
+        }
+        catch {
+            return failedCPUSample('CPU resource sampling failed');
+        }
+    }
+    function sampleGPUs() {
+        if (!gpuContext)
+            return failedMetric('GPU collector is unavailable');
+        if (gpuCapabilities.status !== 'supported') {
+            return failedMetric('GPU inventory is unavailable');
+        }
+        const context = gpuContext;
+        const samples = gpuIds.map((id, index) => {
+            try {
+                return normalizeGPUSample(id, context.sample(index));
+            }
+            catch {
+                return failedGPUSample(id, 'GPU resource sampling failed');
+            }
+        });
+        return supportedMetric(samples, gpuProvenance);
+    }
+    function sample() {
+        const cpuSample = sampleCPU();
+        return {
+            sampledAt: dependencies.now(),
+            cpu: cpuSample.cpu,
+            memory: cpuSample.memory,
+            gpus: sampleGPUs()
+        };
+    }
+    function destroy() {
+        if (destroyed)
+            return;
+        destroyed = true;
+        destroyContext(cpuContext);
+        destroyContext(gpuContext);
+        cpuContext = undefined;
+        gpuContext = undefined;
+        gpuIds = [];
+    }
+    return {
+        getCapabilities,
+        sample,
+        destroy
+    };
+}

package/dist/server/bare/resources/native.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceCollectorDependencies } from '../../../server/bare/resources/types.js';
+export declare const nativeResourceCollectorDependencies: ResourceCollectorDependencies;
+//# sourceMappingURL=native.d.ts.map

package/dist/server/bare/resources/native.js

@@ -0,0 +1,35 @@
+import { randomUUID } from 'bare-crypto';
+// Load independently so one unavailable native addon cannot disable the other collector.
+const [cpuModule, gpuModule] = await Promise.allSettled([
+    import('bare-cpu-info'),
+    import('bare-gpu-info')
+]);
+function supportedEnumValues(values, unknownValue) {
+    return Object.values(values).filter((value) => value !== unknownValue);
+}
+const cpuArchitectures = cpuModule.status === 'fulfilled'
+    ? supportedEnumValues(cpuModule.value.default.constants.arch, cpuModule.value.default.constants.arch.UNKNOWN)
+    : [];
+const gpuTypes = gpuModule.status === 'fulfilled'
+    ? supportedEnumValues(gpuModule.value.default.constants.gpuType, gpuModule.value.default.constants.gpuType.UNKNOWN)
+    : [];
+export const nativeResourceCollectorDependencies = {
+    cpuArchitectures,
+    gpuTypes,
+    createCPUInfo() {
+        if (cpuModule.status !== 'fulfilled')
+            return undefined;
+        return new cpuModule.value.default();
+    },
+    createGPUInfo() {
+        if (gpuModule.status !== 'fulfilled')
+            return undefined;
+        return new gpuModule.value.default();
+    },
+    createGPUId() {
+        return randomUUID();
+    },
+    now() {
+        return Date.now();
+    }
+};

package/dist/server/bare/resources/normalize.d.ts

@@ -0,0 +1,13 @@
+import type { ResourceMetric, ResourceProvenance } from '../../../server/bare/resources/types.js';
+export declare function unavailableMetric<T>(reason?: string): ResourceMetric<T>;
+export declare function unverifiedMetric<T>(reason?: string): ResourceMetric<T>;
+export declare function failedMetric<T>(reason: string): ResourceMetric<T>;
+export declare function normalizeNonNegativeMetric(value: unknown, provenance: ResourceProvenance): ResourceMetric<number>;
+export declare function normalizePositiveMetric(value: unknown, provenance: ResourceProvenance): ResourceMetric<number>;
+export declare function normalizeNonNegativeIntegerMetric(value: unknown, provenance: ResourceProvenance): ResourceMetric<number>;
+export declare function normalizePositiveIntegerMetric(value: unknown, provenance: ResourceProvenance): ResourceMetric<number>;
+export declare function normalizeUtilizationMetric(value: unknown, provenance: ResourceProvenance): ResourceMetric<number>;
+export declare function normalizeEnumMetric(value: unknown, allowedValues: readonly number[], provenance: ResourceProvenance): ResourceMetric<number>;
+export declare function normalizeStringMetric(value: unknown, provenance: ResourceProvenance): ResourceMetric<string>;
+export declare function normalizeBooleanMetric(value: unknown, provenance: ResourceProvenance): ResourceMetric<boolean>;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/server/bare/resources/normalize.js

@@ -0,0 +1,73 @@
+const UNAVAILABLE_REASON = 'Metric is unavailable';
+const UNVERIFIED_REASON = 'Metric value could not be verified';
+export function unavailableMetric(reason = UNAVAILABLE_REASON) {
+    return { status: 'unavailable', reason };
+}
+export function unverifiedMetric(reason = UNVERIFIED_REASON) {
+    return { status: 'unverified', reason };
+}
+export function failedMetric(reason) {
+    return { status: 'failed', reason };
+}
+export function normalizeNonNegativeMetric(value, provenance) {
+    if (value === undefined || value === null)
+        return unavailableMetric();
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        return unverifiedMetric();
+    }
+    return { status: 'supported', value, provenance };
+}
+export function normalizePositiveMetric(value, provenance) {
+    const metric = normalizeNonNegativeMetric(value, provenance);
+    if (metric.status !== 'supported')
+        return metric;
+    if (metric.value === 0)
+        return unverifiedMetric();
+    return metric;
+}
+export function normalizeNonNegativeIntegerMetric(value, provenance) {
+    const metric = normalizeNonNegativeMetric(value, provenance);
+    if (metric.status !== 'supported')
+        return metric;
+    if (!Number.isInteger(metric.value))
+        return unverifiedMetric();
+    return metric;
+}
+export function normalizePositiveIntegerMetric(value, provenance) {
+    const metric = normalizePositiveMetric(value, provenance);
+    if (metric.status !== 'supported')
+        return metric;
+    if (!Number.isInteger(metric.value))
+        return unverifiedMetric();
+    return metric;
+}
+export function normalizeUtilizationMetric(value, provenance) {
+    const metric = normalizeNonNegativeMetric(value, provenance);
+    if (metric.status !== 'supported')
+        return metric;
+    if (metric.value > 1)
+        return unverifiedMetric();
+    return metric;
+}
+export function normalizeEnumMetric(value, allowedValues, provenance) {
+    if (value === undefined || value === null)
+        return unavailableMetric();
+    if (typeof value !== 'number' || !Number.isInteger(value) || !allowedValues.includes(value)) {
+        return unverifiedMetric();
+    }
+    return { status: 'supported', value, provenance };
+}
+export function normalizeStringMetric(value, provenance) {
+    if (value === undefined || value === null)
+        return unavailableMetric();
+    if (typeof value !== 'string' || value.length === 0)
+        return unverifiedMetric();
+    return { status: 'supported', value, provenance };
+}
+export function normalizeBooleanMetric(value, provenance) {
+    if (value === undefined || value === null)
+        return unavailableMetric();
+    if (typeof value !== 'boolean')
+        return unverifiedMetric();
+    return { status: 'supported', value, provenance };
+}

package/dist/server/bare/resources/types.d.ts

@@ -0,0 +1,66 @@
+import type { GraphicsDriver, SystemResourceCapabilities, SystemResourceSample } from '../../../schemas/system-resources.js';
+export type { CPUResourceCapabilities, GPUResourceCapabilities, GPUResourceSample, GraphicsDriver, GraphicsDriverCapabilities, ResourceMetric, ResourceProvenance, ResourceScope, SystemResourceCapabilities, SystemResourceSample } from '../../../schemas/system-resources.js';
+export interface NativeCPUCapabilities {
+    name: string | null;
+    vendor: string | null;
+    arch: number;
+    physicalCores: number;
+    logicalCores: number;
+    performanceCores: number;
+    efficiencyCores: number;
+    frequency: number | undefined;
+    cacheLine: number | undefined;
+    memory: number | undefined;
+}
+export interface NativeCPUUsage {
+    compute: number | undefined;
+    memoryUsed: number | undefined;
+    memoryTotal: number | undefined;
+}
+export interface CPUInfoContext {
+    query(): NativeCPUCapabilities;
+    sample(): NativeCPUUsage;
+    destroy(): void;
+}
+export interface NativeGPUCapabilities {
+    name: string | null;
+    vendor: string | null;
+    driverName: string | null;
+    driverVersion: string | null;
+    type: number;
+    drivers: Record<GraphicsDriver, boolean>;
+    vendorId: number | undefined;
+    deviceId: number | undefined;
+    subsystemId: number | undefined;
+    revision: number;
+    unifiedMemory: boolean;
+    memory: number | undefined;
+}
+export interface NativeGPUUsage {
+    compute: number | undefined;
+    encode: number | undefined;
+    decode: number | undefined;
+    memoryUsed: number | undefined;
+    memoryTotal: number | undefined;
+    power: number | undefined;
+    temperature: number | undefined;
+}
+export interface GPUInfoContext {
+    gpus(): NativeGPUCapabilities[];
+    sample(index: number): NativeGPUUsage;
+    destroy(): void;
+}
+export interface ResourceCollectorDependencies {
+    cpuArchitectures: readonly number[];
+    gpuTypes: readonly number[];
+    createCPUInfo(): CPUInfoContext | undefined;
+    createGPUInfo(): GPUInfoContext | undefined;
+    createGPUId(): string;
+    now(): number;
+}
+export interface SystemResourceCollector {
+    getCapabilities(): SystemResourceCapabilities;
+    sample(): SystemResourceSample;
+    destroy(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/server/bare/resources/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/bare/resources/worker-collector.d.ts

@@ -0,0 +1,5 @@
+import type { ResourceCollectorDependencies, SystemResourceCollector } from '../../../server/bare/resources/types.js';
+export declare function initializeWorkerResourceCollector(dependencies: ResourceCollectorDependencies): SystemResourceCollector;
+export declare function getWorkerResourceCollector(): SystemResourceCollector | undefined;
+export declare function destroyWorkerResourceCollector(): void;
+//# sourceMappingURL=worker-collector.d.ts.map

package/dist/server/bare/resources/worker-collector.js

@@ -0,0 +1,15 @@
+import { createSystemResourceCollector } from '../../../server/bare/resources/collector.js';
+let workerResourceCollector;
+export function initializeWorkerResourceCollector(dependencies) {
+    if (!workerResourceCollector) {
+        workerResourceCollector = createSystemResourceCollector(dependencies);
+    }
+    return workerResourceCollector;
+}
+export function getWorkerResourceCollector() {
+    return workerResourceCollector;
+}
+export function destroyWorkerResourceCollector() {
+    workerResourceCollector?.destroy();
+    workerResourceCollector = undefined;
+}

package/dist/server/bare/runtime/index.d.ts

@@ -1,8 +1,8 @@
-export { createDisposableScope } from './disposable-scope';
-export type { DisposableScope } from './disposable-scope';
-export type { RequestContext, RequestKind, RequestState } from './request-context';
-export { createRequestRegistry, getRequestRegistry } from './request-registry-singleton';
-export type { BeginOpts, CancelByModelId, CancelByRequestId, CancelTarget, ConcurrencyPolicy, ManagedRequestContext, RequestOutcome, RequestRegistry } from './request-registry';
-export { withRequestContext } from './with-request-context';
-export type { RequestLogContext } from './with-request-context';
+export { createDisposableScope } from '../../../server/bare/runtime/disposable-scope.js';
+export type { DisposableScope } from '../../../server/bare/runtime/disposable-scope.js';
+export type { RequestContext, RequestKind, RequestState } from '../../../server/bare/runtime/request-context.js';
+export { createRequestRegistry, getRequestRegistry } from '../../../server/bare/runtime/request-registry-singleton.js';
+export type { BeginOpts, CancelByModelId, CancelByRequestId, CancelTarget, ConcurrencyPolicy, ManagedRequestContext, RequestOutcome, RequestRegistry } from '../../../server/bare/runtime/request-registry.js';
+export { withRequestContext } from '../../../server/bare/runtime/with-request-context.js';
+export type { RequestLogContext } from '../../../server/bare/runtime/with-request-context.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/bare/runtime/index.js

@@ -1,3 +1,3 @@
-export { createDisposableScope } from './disposable-scope.js';
-export { createRequestRegistry, getRequestRegistry } from './request-registry-singleton.js';
-export { withRequestContext } from './with-request-context.js';
+export { createDisposableScope } from '../../../server/bare/runtime/disposable-scope.js';
+export { createRequestRegistry, getRequestRegistry } from '../../../server/bare/runtime/request-registry-singleton.js';
+export { withRequestContext } from '../../../server/bare/runtime/with-request-context.js';

package/dist/server/bare/runtime/request-context.d.ts

@@ -1,5 +1,5 @@
 import type { AbortSignal } from 'bare-abort-controller';
-import type { DisposableScope } from './disposable-scope';
+import type { DisposableScope } from '../../../server/bare/runtime/disposable-scope.js';
 /**
  * Coarse classification of a long-running request. Used by
  * `RequestRegistry.cancel({ modelId, kind })` so a broad cancel can target
@@ -9,7 +9,7 @@ import type { DisposableScope } from './disposable-scope';
  * The set is intentionally open-coded — adding a new kind is a one-line
  * change and the union surfaces in editor autocomplete at every call site.
  */
-export type RequestKind = 'completion' | 'batchCompletion' | 'embeddings' | 'transcribe' | 'translate' | 'diffusion' | 'tts' | 'ocr' | 'vla' | 'finetune' | 'loadModel' | 'downloadAsset' | 'rag';
+export type RequestKind = 'completion' | 'batchCompletion' | 'embeddings' | 'transcribe' | 'translate' | 'diffusion' | 'audiogen' | 'tts' | 'ocr' | 'vla' | 'finetune' | 'loadModel' | 'downloadAsset' | 'rag';
 /**
  * Lifecycle states a request transitions through. A new context starts in
  * `"running"`. `cancel(...)` flips it to `"cancelling"` and aborts the

package/dist/server/bare/runtime/request-registry-singleton.d.ts

@@ -1,4 +1,4 @@
-import { createRequestRegistry as createRegistry, type RequestRegistry } from './request-registry';
+import { createRequestRegistry as createRegistry, type RequestRegistry } from '../../../server/bare/runtime/request-registry.js';
 export declare function getRequestRegistry(): RequestRegistry;
 export { createRegistry as createRequestRegistry };
 //# sourceMappingURL=request-registry-singleton.d.ts.map

package/dist/server/bare/runtime/request-registry-singleton.js

@@ -1,4 +1,4 @@
-import { createRequestRegistry as createRegistry } from './request-registry.js';
+import { createRequestRegistry as createRegistry } from '../../../server/bare/runtime/request-registry.js';
 /**
  * Worker-process singleton. Every long-running request in this Bare
  * worker registers under this registry, so a `cancel({ requestId })` RPC
@@ -42,6 +42,16 @@ function installDefaultPolicies(r) {
         maxQueueDepthPerModel: 64,
         sharedSlotGroup: LLAMACPP_COMPLETION_SLOT_GROUP
     });
+    // ACE-Step owns one active job per model. Starting another run replaces
+    // the addon's active response, and model-scoped cancel targets that single
+    // active job. Keep the SDK registry authoritative by admitting one AudioGen
+    // request per model and queueing later requests FIFO.
+    r.policy({
+        kind: 'audiogen',
+        maxConcurrentPerModel: 1,
+        onOverflow: 'queue',
+        maxQueueDepthPerModel: 64
+    });
 }
 export function getRequestRegistry() {
     if (!registry) {

package/dist/server/bare/runtime/request-registry.d.ts

@@ -1,6 +1,6 @@
 import { type AbortSignal } from 'bare-abort-controller';
-import type { RequestContext, RequestKind } from './request-context';
-import type { Logger } from '../../../logging/types';
+import type { RequestContext, RequestKind } from '../../../server/bare/runtime/request-context.js';
+import type { Logger } from '../../../logging/types.js';
 /**
  * Outcome the caller declares when terminating a request through
  * `registry.end(...)`. The registry maps it to a terminal `RequestState`

package/dist/server/bare/runtime/request-registry.js

@@ -1,5 +1,5 @@
 import { AbortController } from 'bare-abort-controller';
-import { createDisposableScope } from './disposable-scope.js';
+import { createDisposableScope } from '../../../server/bare/runtime/disposable-scope.js';
 import { RequestIdConflictError, RequestRejectedByPolicyError } from '../../../utils/errors-server.js';
 import { getServerLogger } from '../../../logging/index.js';
 /**

package/dist/server/bare/runtime/with-request-context.d.ts

@@ -1,4 +1,4 @@
-import type { Logger } from '../../../logging/types';
+import type { Logger } from '../../../logging/types.js';
 export interface RequestLogContext {
     requestId: string;
     kind: string;

package/dist/server/bare/runtime-lifecycle.d.ts

@@ -1,4 +1,4 @@
-import type { LifecycleState, Request } from '../../schemas/index';
+import type { LifecycleState, Request } from '../../schemas/index.js';
 export interface SuspendableSwarm {
     readonly suspended: boolean;
     suspend(): Promise<void>;

package/dist/server/bare/types/addon-responses.d.ts

@@ -1,3 +1,4 @@
+import type ASRGgml from '@qvac/asr-ggml';
 export interface LlmStats {
     TTFT?: number;
     TPS?: number;
@@ -26,6 +27,8 @@ export interface NmtResponse {
 export interface TtsStats {
     audioDurationMs?: number;
     totalSamples?: number;
+    enhancerBackendDevice?: number;
+    enhancerBackendId?: number;
 }
 export interface TtsResponse {
     stats?: TtsStats;
@@ -44,40 +47,11 @@ export interface EmbedResponse {
     stats?: EmbedStats;
     await(): Promise<Float32Array[][]>;
 }
-export interface TranscribeStats {
-    audioDurationMs?: number;
-    realTimeFactor?: number;
-    tokensPerSecond?: number;
-    totalTokens?: number;
-    totalSegments?: number;
-    whisperEncodeMs?: number;
-    whisperDecodeMs?: number;
-    encoderMs?: number;
-    decoderMs?: number;
-    melSpecMs?: number;
-    backendDevice?: number;
-    backendId?: number;
-    gpuUnsupported?: number;
-    gpuMemTotalMb?: number;
-    gpuMemFreeMb?: number;
-}
-export interface TranscribeAddonSegment {
-    text: string;
-    start?: number;
-    end?: number;
-    toAppend?: boolean;
-    id?: number;
-}
-export interface TranscribeAddonVadEvent {
-    type: 'vad';
-    speaking: boolean;
-    probability: number;
-}
-export interface TranscribeAddonEndOfTurnEvent {
-    type: 'endOfTurn';
-    silenceDurationMs: number;
-}
-export type TranscribeAddonOutput = Array<TranscribeAddonSegment> | TranscribeAddonVadEvent | TranscribeAddonEndOfTurnEvent;
+export type TranscribeStats = Partial<ASRGgml.WhisperRuntimeStats & ASRGgml.ParakeetRuntimeStats>;
+export type TranscribeAddonSegment = ASRGgml.TranscriptionSegment;
+export type TranscribeAddonVadEvent = ASRGgml.VadEvent;
+export type TranscribeAddonEndOfTurnEvent = ASRGgml.EndOfTurnEvent;
+export type TranscribeAddonOutput = ASRGgml.ASRStreamOutput;
 export interface TranscribeResponse {
     stats?: TranscribeStats;
     iterate(): AsyncIterable<TranscribeAddonOutput>;

package/dist/server/bare/utils/asr-events.d.ts

@@ -0,0 +1,15 @@
+import type ASRGgml from '@qvac/asr-ggml';
+export declare function isVadEvent(event: ASRGgml.ASRStreamOutput): event is ASRGgml.VadEvent;
+export declare function isEndOfTurnEvent(event: ASRGgml.ASRStreamOutput): event is ASRGgml.EndOfTurnEvent;
+export declare function toVadStateEvent(event: ASRGgml.VadEvent): {
+    speaking: boolean;
+    probability: number;
+};
+export declare function toEndOfTurnEvent(event: ASRGgml.EndOfTurnEvent): {
+    source: "parakeet";
+    silenceDurationMs?: never;
+} | {
+    source: "whisper";
+    silenceDurationMs: number;
+} | null;
+//# sourceMappingURL=asr-events.d.ts.map

package/dist/server/bare/utils/asr-events.js

@@ -0,0 +1,30 @@
+export function isVadEvent(event) {
+    return (!Array.isArray(event) &&
+        event.type === 'vad' &&
+        typeof event.speaking === 'boolean' &&
+        typeof event.score === 'number' &&
+        (event.source === 'silero' || event.source === 'energy'));
+}
+export function isEndOfTurnEvent(event) {
+    return (!Array.isArray(event) &&
+        event.type === 'endOfTurn' &&
+        (event.source === 'vad-silence' || event.source === 'model-eou'));
+}
+export function toVadStateEvent(event) {
+    return {
+        speaking: event.speaking,
+        probability: event.score
+    };
+}
+export function toEndOfTurnEvent(event) {
+    if (event.source === 'model-eou') {
+        return { source: 'parakeet' };
+    }
+    if (event.silenceDurationMs === undefined) {
+        return null;
+    }
+    return {
+        source: 'whisper',
+        silenceDurationMs: event.silenceDurationMs
+    };
+}