@qvac/sdk 0.18.2 → 0.19.0

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

@@ -1,226 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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/disposable-scope.d.ts

@@ -1,36 +0,0 @@
-/**
- * Bounded-lifetime cleanup scope for an in-flight request.
- *
- * Callers register cleanup callbacks via `defer(...)` while a handler runs.
- * On `[Symbol.asyncDispose]()` (used implicitly by `await using` or
- * explicitly) every registered callback is awaited in **LIFO** order — the
- * mirror of how `try/finally` blocks would unwind in a sequential write-up
- * of the same handler.
- *
- * Guarantees:
- *
- *  - **Idempotent.** A scope can be disposed once. Subsequent disposes are
- *    no-ops; subsequent `defer` calls run the cleanup eagerly so callers
- *    never silently leak a deferred resource if they hand a deferred
- *    callback to an already-disposed scope.
- *  - **Error aggregation.** Every deferred cleanup runs even when an
- *    earlier one throws. If a single cleanup throws, that error is
- *    rethrown verbatim. If two or more throw, an `AggregateError` is
- *    rethrown carrying every failure in the order it occurred. The
- *    handler unwinding the scope can therefore see _all_ cleanup
- *    failures, not just the first one.
- */
-export interface DisposableScope {
-    /**
-     * Register a cleanup callback. Cleanups run on dispose in LIFO order.
-     * Calling `defer` after the scope has been disposed runs the cleanup
-     * eagerly so resources never leak silently.
-     */
-    defer(cleanup: () => Promise<void> | void): void;
-    /** Run all registered cleanups. Idempotent. */
-    [Symbol.asyncDispose](): Promise<void>;
-    /** True after the first dispose has been initiated. */
-    readonly disposed: boolean;
-}
-export declare function createDisposableScope(): DisposableScope;
-//# sourceMappingURL=disposable-scope.d.ts.map

package/dist/server/bare/runtime/disposable-scope.js

@@ -1,69 +0,0 @@
-import { AsyncDisposeUnavailableError } from '../../../utils/errors-server.js';
-/**
- * Module-load guard. The whole request-lifecycle primitive stack (scopes,
- * the registry's `ManagedRequestContext`, `await using ctx = ...`) is
- * built on `Symbol.asyncDispose`, which is an ES2024 feature. If the host
- * runtime doesn't expose it (older Bare/Expo build, missing polyfill),
- * the `[Symbol.asyncDispose]:` property key in this file's `dispose`
- * function would coerce to the string `"undefined"` and silently produce
- * objects that look async-disposable but are not — handlers would leak
- * registry entries forever. Better to fail loudly at import time with a
- * clear error than to debug a slow registry leak in production.
- */
-if (typeof Symbol.asyncDispose !== 'symbol') {
-    throw new AsyncDisposeUnavailableError();
-}
-export function createDisposableScope() {
-    const cleanups = [];
-    let disposed = false;
-    let disposing = false;
-    function defer(cleanup) {
-        if (disposed || disposing) {
-            void runEagerly(cleanup);
-            return;
-        }
-        cleanups.push(cleanup);
-    }
-    async function runEagerly(cleanup) {
-        try {
-            await cleanup();
-        }
-        catch {
-            // Late-deferred cleanups have no caller waiting on them; the
-            // unwinding path that disposed the scope already returned its own
-            // errors. Swallowing here matches the user's intent of registering
-            // a fire-and-forget cleanup.
-        }
-    }
-    async function dispose() {
-        if (disposed || disposing)
-            return;
-        disposing = true;
-        const errors = [];
-        while (cleanups.length > 0) {
-            const cleanup = cleanups.pop();
-            if (!cleanup)
-                continue;
-            try {
-                await cleanup();
-            }
-            catch (err) {
-                errors.push(err);
-            }
-        }
-        disposed = true;
-        disposing = false;
-        if (errors.length === 1)
-            throw errors[0];
-        if (errors.length > 1) {
-            throw new AggregateError(errors, `DisposableScope: ${errors.length} cleanups failed`);
-        }
-    }
-    return {
-        defer,
-        [Symbol.asyncDispose]: dispose,
-        get disposed() {
-            return disposed;
-        }
-    };
-}

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

@@ -1,8 +0,0 @@
-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 +0,0 @@
-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,49 +0,0 @@
-import type { AbortSignal } from 'bare-abort-controller';
-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
- * just one operation kind on a given model (e.g. cancel an in-flight
- * completion without touching a finetune running on the same model).
- *
- * 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' | '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
- * signal; `end({ outcome: "completed" | "failed" | "cancelled" })` flips
- * it to a terminal state and removes it from the registry.
- *
- * Kept as a string union (not a state machine) on purpose — handlers read
- * `state` defensively at most a couple of points and a flat enum is easier
- * to log/assert than a transition table.
- */
-export type RequestState = 'running' | 'cancelling' | 'completed' | 'failed' | 'cancelled';
-/**
- * Per-request lifecycle handle. Created by `RequestRegistry.begin(...)`
- * and consumed by long-running handlers as the single owner of:
- *
- *  - `requestId` — stable identity; visible to the client so it can
- *    target this exact request with `cancel({ requestId })`.
- *  - `signal` — `AbortSignal` that fires when the request is cancelled.
- *    Composes with addon-level cancellation through a single
- *    `signal.addEventListener("abort", ...)` hook installed by the
- *    handler.
- *  - `scope` — `DisposableScope` for `await using` / `Symbol.asyncDispose`
- *    cleanup. The scope unwinds whether the handler returns, throws, or
- *    is cancelled — there is no manual cleanup path for handlers to
- *    forget on the cancel branch.
- *  - `state` — current lifecycle state. Treat as read-mostly; the
- *    registry mutates it.
- */
-export interface RequestContext {
-    readonly requestId: string;
-    readonly kind: RequestKind;
-    readonly modelId: string | undefined;
-    readonly signal: AbortSignal;
-    readonly scope: DisposableScope;
-    state: RequestState;
-}
-//# sourceMappingURL=request-context.d.ts.map

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

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

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

@@ -1,12 +0,0 @@
-/**
- * Server-side fallback for `requestId`. The new wire contract is that
- * the client generates the id (UUIDv4) at call time so it's surfaced
- * synchronously on the `CompletionRun` for use with `cancel({ requestId })`.
- * To keep older clients working, the request schema marks `requestId`
- * optional and the server fills it in here when it's missing.
- *
- * `bare-crypto.randomUUID()` mirrors Node's `crypto.randomUUID()` and is
- * Bare-runtime safe. Returns a v4 UUID.
- */
-export declare function generateServerRequestId(): string;
-//# sourceMappingURL=request-id.d.ts.map

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

@@ -1,14 +0,0 @@
-import { randomUUID } from 'bare-crypto';
-/**
- * Server-side fallback for `requestId`. The new wire contract is that
- * the client generates the id (UUIDv4) at call time so it's surfaced
- * synchronously on the `CompletionRun` for use with `cancel({ requestId })`.
- * To keep older clients working, the request schema marks `requestId`
- * optional and the server fills it in here when it's missing.
- *
- * `bare-crypto.randomUUID()` mirrors Node's `crypto.randomUUID()` and is
- * Bare-runtime safe. Returns a v4 UUID.
- */
-export function generateServerRequestId() {
-    return randomUUID();
-}

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

@@ -1,4 +0,0 @@
-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