@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/bare/rag-hyperdb/handlers/reindex.js

@@ -1,16 +0,0 @@
-import { getRagDbAdapter, hasRagWorkspaceStorage } from '../../../../server/bare/rag-hyperdb/rag-workspace-manager.js';
-import { ragReindexParamsSchema } from '../../../../schemas/index.js';
-import { RAGHyperDBFailedError } from '../../../../utils/errors-server.js';
-export async function reindex(params, options) {
-    const { workspace } = ragReindexParamsSchema.parse(params);
-    if (!hasRagWorkspaceStorage(workspace)) {
-        throw new RAGHyperDBFailedError('workspace is not initialized');
-    }
-    const dbAdapter = await getRagDbAdapter(workspace);
-    const reindexOpts = {
-        onProgress: options?.onProgress,
-        signal: options?.signal
-    };
-    const result = await dbAdapter.reindex(reindexOpts);
-    return result;
-}

package/dist/server/bare/rag-hyperdb/handlers/save-embeddings.d.ts

@@ -1,9 +0,0 @@
-import { type RagSaveEmbeddingsParams } from '../../../../schemas/index.js';
-import type { SaveStage } from '@qvac/rag';
-interface SaveEmbeddingsHandlerOptions {
-    onProgress?: (stage: SaveStage, current: number, total: number) => void;
-    signal?: AbortSignal;
-}
-export declare function saveEmbeddings(params: RagSaveEmbeddingsParams, options?: SaveEmbeddingsHandlerOptions): Promise<import("@qvac/rag").SaveEmbeddingsResult[]>;
-export {};
-//# sourceMappingURL=save-embeddings.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/save-embeddings.js

@@ -1,15 +0,0 @@
-import { getRagDbAdapter } from '../../../../server/bare/rag-hyperdb/rag-workspace-manager.js';
-import { ragSaveEmbeddingsParamsSchema } from '../../../../schemas/index.js';
-export async function saveEmbeddings(params, options) {
-    const { documents, progressInterval, workspace } = ragSaveEmbeddingsParamsSchema.parse(params);
-    if (documents.length === 0) {
-        return [];
-    }
-    const dbAdapter = await getRagDbAdapter(workspace);
-    const saveOpts = {
-        progressInterval,
-        onProgress: options?.onProgress,
-        signal: options?.signal
-    };
-    return await dbAdapter.saveEmbeddings(documents, saveOpts);
-}

package/dist/server/bare/rag-hyperdb/handlers/search.d.ts

@@ -1,3 +0,0 @@
-import { type RagSearchParams } from '../../../../schemas/index.js';
-export declare function search(params: RagSearchParams): Promise<import("@qvac/rag").SearchResult[]>;
-//# sourceMappingURL=search.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/search.js

@@ -1,16 +0,0 @@
-import { getRagInstance, hasRagWorkspaceStorage } from '../../../../server/bare/rag-hyperdb/rag-workspace-manager.js';
-import { embed } from '../../../../server/bare/ops/embed.js';
-import { ragSearchParamsSchema } from '../../../../schemas/index.js';
-export async function search(params) {
-    const { modelId, query, topK, n, workspace } = ragSearchParamsSchema.parse(params);
-    if (!hasRagWorkspaceStorage(workspace)) {
-        return [];
-    }
-    async function embeddingFunction(text) {
-        const result = await embed({ modelId, text });
-        return result.embedding;
-    }
-    const rag = await getRagInstance(modelId, embeddingFunction, workspace);
-    const results = await rag.search(query, { topK, n });
-    return results;
-}

package/dist/server/bare/rag-hyperdb/index.d.ts

@@ -1,12 +0,0 @@
-export { chunk } from '../../../server/bare/rag-hyperdb/handlers/chunk.js';
-export { ingest } from '../../../server/bare/rag-hyperdb/handlers/ingest.js';
-export { saveEmbeddings } from '../../../server/bare/rag-hyperdb/handlers/save-embeddings.js';
-export { search } from '../../../server/bare/rag-hyperdb/handlers/search.js';
-export { deleteEmbeddings } from '../../../server/bare/rag-hyperdb/handlers/delete-embeddings.js';
-export { reindex } from '../../../server/bare/rag-hyperdb/handlers/reindex.js';
-export { listWorkspaces } from '../../../server/bare/rag-hyperdb/handlers/list-workspaces.js';
-export { closeWorkspace } from '../../../server/bare/rag-hyperdb/handlers/close-workspace.js';
-export { deleteWorkspace } from '../../../server/bare/rag-hyperdb/handlers/delete-workspace.js';
-export { closeAllRagInstances, DEFAULT_WORKSPACE, type RagWorkspaceInfo } from '../../../server/bare/rag-hyperdb/rag-workspace-manager.js';
-export { getActiveRagRequest, setActiveRagRequest, clearActiveRagRequest, getWorkspaceKey } from '../../../server/bare/rag-hyperdb/rag-operation-manager.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/server/bare/rag-hyperdb/index.js

@@ -1,11 +0,0 @@
-export { chunk } from '../../../server/bare/rag-hyperdb/handlers/chunk.js';
-export { ingest } from '../../../server/bare/rag-hyperdb/handlers/ingest.js';
-export { saveEmbeddings } from '../../../server/bare/rag-hyperdb/handlers/save-embeddings.js';
-export { search } from '../../../server/bare/rag-hyperdb/handlers/search.js';
-export { deleteEmbeddings } from '../../../server/bare/rag-hyperdb/handlers/delete-embeddings.js';
-export { reindex } from '../../../server/bare/rag-hyperdb/handlers/reindex.js';
-export { listWorkspaces } from '../../../server/bare/rag-hyperdb/handlers/list-workspaces.js';
-export { closeWorkspace } from '../../../server/bare/rag-hyperdb/handlers/close-workspace.js';
-export { deleteWorkspace } from '../../../server/bare/rag-hyperdb/handlers/delete-workspace.js';
-export { closeAllRagInstances, DEFAULT_WORKSPACE } from '../../../server/bare/rag-hyperdb/rag-workspace-manager.js';
-export { getActiveRagRequest, setActiveRagRequest, clearActiveRagRequest, getWorkspaceKey } from '../../../server/bare/rag-hyperdb/rag-operation-manager.js';

package/dist/server/bare/rag-hyperdb/rag-operation-manager.d.ts

@@ -1,29 +0,0 @@
-export declare function getWorkspaceKey(workspace?: string): string;
-/**
- * Returns the `requestId` of any in-flight RAG operation on the workspace
- * (or `undefined` if none). The dispatcher uses this to decide whether to
- * pre-empt before calling `registry.begin(...)`.
- */
-export declare function getActiveRagRequest(workspace?: string): string | undefined;
-/**
- * Records the `requestId` of a freshly-begun RAG operation. Called by the
- * dispatcher in `rag.ts` after `registry.begin(...)` succeeds; paired with
- * `clearActiveRagRequest` via the request scope's deferred cleanup so the
- * map never outlives the request.
- */
-export declare function setActiveRagRequest(workspace: string | undefined, requestId: string): void;
-/**
- * Clears the workspace's mapping iff it still belongs to `requestId`. The
- * conditional guard handles the natural race between two ingest calls on
- * the same workspace: the older context's scope unwind must not stomp the
- * newer context's mapping installed by the pre-emption sequence.
- */
-export declare function clearActiveRagRequest(workspace: string | undefined, requestId: string): void;
-/**
- * Shutdown / workspace-close sweep. Cancels every tracked RAG request via
- * the registry and clears the workspace map. Idempotent — callers that
- * re-invoke during a teardown (workspace-close fired twice, shutdown
- * racing with `close-all`) get a no-op on the second pass.
- */
-export declare function cancelAllRagOperations(): void;
-//# sourceMappingURL=rag-operation-manager.d.ts.map

package/dist/server/bare/rag-hyperdb/rag-operation-manager.js

@@ -1,76 +0,0 @@
-import { getRequestRegistry } from '../../../server/bare/runtime/index.js';
-// Sentinel for "no workspace specified". Mirrors the value re-exported
-// from `rag-workspace-manager.ts`; redeclared locally so this module is
-// safely importable in environments that don't have the Bare runtime
-// (unit tests, doc generators) — `rag-workspace-manager` pulls in
-// `bare-fs` / `bare-path` at module load.
-const DEFAULT_WORKSPACE = 'default';
-/**
- * RAG operation tracking — workspace-level admission bookkeeping.
- *
- * In 0.11.0 the cancel surface for in-flight RAG operations consolidates
- * onto the request registry (`getRequestRegistry().cancel({ requestId })`).
- * The historical workspace-level pre-emption rule — "starting a new
- * `ingest` / `reindex` / `saveEmbeddings` on a workspace cancels any prior
- * op on the same workspace" — is preserved by the dispatcher in
- * `server/rpc/handlers/rag.ts`: the dispatcher cancels the workspace's
- * prior `requestId` (if any) and then begins a new registry context.
- * Workspace-level admission lives in the dispatcher rather than as a
- * registry policy primitive — it's a dispatch concern, not part of the
- * registry's per-`kind` admission rules.
- *
- * This module owns the small workspace → requestId map that makes that
- * pre-emption decision routable from the dispatcher. The map is module-
- * scoped (one per Bare worker) so the dispatcher, the shutdown sweep
- * (`cancelAllRagOperations`), and the workspace-close sweep (which
- * delegates to it via `rag-workspace-manager.ts`) all see the same state.
- */
-// workspace key → requestId of the in-flight RAG operation on that workspace.
-const activeRagRequestByWorkspace = new Map();
-export function getWorkspaceKey(workspace) {
-    return workspace ?? DEFAULT_WORKSPACE;
-}
-/**
- * Returns the `requestId` of any in-flight RAG operation on the workspace
- * (or `undefined` if none). The dispatcher uses this to decide whether to
- * pre-empt before calling `registry.begin(...)`.
- */
-export function getActiveRagRequest(workspace) {
-    return activeRagRequestByWorkspace.get(getWorkspaceKey(workspace));
-}
-/**
- * Records the `requestId` of a freshly-begun RAG operation. Called by the
- * dispatcher in `rag.ts` after `registry.begin(...)` succeeds; paired with
- * `clearActiveRagRequest` via the request scope's deferred cleanup so the
- * map never outlives the request.
- */
-export function setActiveRagRequest(workspace, requestId) {
-    activeRagRequestByWorkspace.set(getWorkspaceKey(workspace), requestId);
-}
-/**
- * Clears the workspace's mapping iff it still belongs to `requestId`. The
- * conditional guard handles the natural race between two ingest calls on
- * the same workspace: the older context's scope unwind must not stomp the
- * newer context's mapping installed by the pre-emption sequence.
- */
-export function clearActiveRagRequest(workspace, requestId) {
-    const key = getWorkspaceKey(workspace);
-    if (activeRagRequestByWorkspace.get(key) === requestId) {
-        activeRagRequestByWorkspace.delete(key);
-    }
-}
-/**
- * Shutdown / workspace-close sweep. Cancels every tracked RAG request via
- * the registry and clears the workspace map. Idempotent — callers that
- * re-invoke during a teardown (workspace-close fired twice, shutdown
- * racing with `close-all`) get a no-op on the second pass.
- */
-export function cancelAllRagOperations() {
-    if (activeRagRequestByWorkspace.size === 0)
-        return;
-    const registry = getRequestRegistry();
-    for (const [key, requestId] of activeRagRequestByWorkspace) {
-        registry.cancel({ requestId, reason: 'rag-shutdown' });
-        activeRagRequestByWorkspace.delete(key);
-    }
-}

package/dist/server/bare/rag-hyperdb/rag-workspace-manager.d.ts

@@ -1,15 +0,0 @@
-import { RAG, HyperDBAdapter, type EmbeddingFunction } from '@qvac/rag';
-export declare const DEFAULT_WORKSPACE = "default";
-export declare function hasRagWorkspaceStorage(workspace?: string): boolean;
-export declare function getRagDbAdapter(workspace?: string): Promise<HyperDBAdapter>;
-export declare function getRagInstance(modelId: string, embeddingFunction: EmbeddingFunction, workspace?: string): Promise<RAG>;
-export declare function closeRagInstance(workspace?: string): Promise<void>;
-export declare function closeAllRagInstances(): Promise<void>;
-export interface RagWorkspaceInfo {
-    name: string;
-    open: boolean;
-}
-export declare function listWorkspaces(): RagWorkspaceInfo[];
-export declare function isWorkspaceLoaded(workspace: string): boolean;
-export declare function deleteWorkspace(workspace: string): Promise<boolean>;
-//# sourceMappingURL=rag-workspace-manager.d.ts.map

package/dist/server/bare/rag-hyperdb/rag-workspace-manager.js

@@ -1,143 +0,0 @@
-import { RAG, HyperDBAdapter } from '@qvac/rag';
-import Corestore from 'corestore';
-import fs, { promises as fsPromises } from 'bare-fs';
-import path from 'bare-path';
-import { getConfiguredCacheDir } from '../../../server/bare/registry/config-registry.js';
-import { RAGWorkspaceModelMismatchError, RAGWorkspaceNotOpenError } from '../../../utils/errors-server.js';
-import { validateAndJoinPath } from '../../../server/utils/path-security.js';
-import { createStreamLogger, getServerLogger, RAG_NAMESPACE } from '../../../logging/index.js';
-import { cancelAllRagOperations } from '../../../server/bare/rag-hyperdb/rag-operation-manager.js';
-import { registerCorestore, unregisterCorestore } from '../../../server/bare/runtime-lifecycle.js';
-const logger = getServerLogger();
-const ragWorkspaces = new Map();
-export const DEFAULT_WORKSPACE = 'default';
-function getWorkspaceKey(workspace) {
-    return workspace ?? DEFAULT_WORKSPACE;
-}
-function getRagBaseDir() {
-    const cacheDir = getConfiguredCacheDir();
-    return path.join(path.dirname(cacheDir), 'rag-hyperdb');
-}
-function getStorePath(workspace) {
-    return validateAndJoinPath(getRagBaseDir(), workspace);
-}
-export function hasRagWorkspaceStorage(workspace) {
-    const key = getWorkspaceKey(workspace);
-    if (ragWorkspaces.has(key))
-        return true;
-    return fs.existsSync(getStorePath(key));
-}
-async function getOrCreateWorkspaceEntry(workspace) {
-    const key = getWorkspaceKey(workspace);
-    const existing = ragWorkspaces.get(key);
-    if (existing) {
-        return existing;
-    }
-    const storePath = getStorePath(key);
-    const corestore = new Corestore(storePath);
-    const dbAdapter = new HyperDBAdapter({
-        store: corestore,
-        dbName: key
-    });
-    await dbAdapter.ready();
-    registerCorestore(corestore, {
-        label: `rag-workspace:${key}`,
-        createdAt: Date.now()
-    });
-    const entry = {
-        corestore,
-        dbAdapter
-    };
-    ragWorkspaces.set(key, entry);
-    return entry;
-}
-export async function getRagDbAdapter(workspace) {
-    const entry = await getOrCreateWorkspaceEntry(workspace);
-    return entry.dbAdapter;
-}
-export async function getRagInstance(modelId, embeddingFunction, workspace) {
-    const key = getWorkspaceKey(workspace);
-    const entry = await getOrCreateWorkspaceEntry(workspace);
-    if (entry.rag) {
-        if (entry.modelId && entry.modelId !== modelId) {
-            throw new RAGWorkspaceModelMismatchError(key, entry.modelId, modelId);
-        }
-        return entry.rag;
-    }
-    const workspaceLogger = createStreamLogger(key, RAG_NAMESPACE);
-    const rag = new RAG({
-        dbAdapter: entry.dbAdapter,
-        embeddingFunction,
-        logger: workspaceLogger
-    });
-    await rag.ready();
-    entry.rag = rag;
-    entry.modelId = modelId;
-    return rag;
-}
-export async function closeRagInstance(workspace) {
-    const key = getWorkspaceKey(workspace);
-    const entry = ragWorkspaces.get(key);
-    if (!entry) {
-        throw new RAGWorkspaceNotOpenError(key);
-    }
-    if (entry.rag) {
-        await entry.rag.close();
-    }
-    await entry.dbAdapter.close();
-    await entry.corestore.close();
-    unregisterCorestore(entry.corestore);
-    ragWorkspaces.delete(key);
-}
-let isCleaningUp = false;
-export async function closeAllRagInstances() {
-    if (isCleaningUp)
-        return;
-    isCleaningUp = true;
-    try {
-        cancelAllRagOperations();
-        const closures = Array.from(ragWorkspaces.entries()).map(async ([key, entry]) => {
-            if (entry.rag) {
-                await entry.rag.close();
-            }
-            await entry.dbAdapter.close();
-            await entry.corestore.close();
-            unregisterCorestore(entry.corestore);
-            ragWorkspaces.delete(key);
-        });
-        await Promise.all(closures);
-    }
-    catch (error) {
-        logger.error('❌ Error during RAG cleanup:', error);
-    }
-    finally {
-        isCleaningUp = false;
-    }
-}
-export function listWorkspaces() {
-    const baseDir = getRagBaseDir();
-    if (!fs.existsSync(baseDir)) {
-        return [];
-    }
-    const entries = fs.readdirSync(baseDir, {
-        withFileTypes: true
-    });
-    const directories = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'));
-    return directories.map((entry) => ({
-        name: entry.name,
-        open: ragWorkspaces.has(entry.name)
-    }));
-}
-export function isWorkspaceLoaded(workspace) {
-    const key = getWorkspaceKey(workspace);
-    return ragWorkspaces.has(key);
-}
-export async function deleteWorkspace(workspace) {
-    const key = getWorkspaceKey(workspace);
-    const storePath = getStorePath(key);
-    if (!fs.existsSync(storePath)) {
-        return false;
-    }
-    await fsPromises.rm(storePath, { recursive: true, force: true });
-    return true;
-}

package/dist/server/bare/registry/config-registry.d.ts

@@ -1,14 +0,0 @@
-import type { QvacConfig } from '../../../schemas/index.js';
-/**
- * Sets the SDK configuration. This can only be called ONCE during initialization.
- * After the first call, the config becomes immutable and any subsequent calls will throw.
- *
- * @param config - The configuration to set
- * @throws {ConfigAlreadySetError} If config has already been set
- * @throws {CacheDirNotAbsoluteError} If cacheDirectory is not an absolute path
- * @throws {CacheDirNotWritableError} If cacheDirectory is not writable
- */
-export declare function setSDKConfig(config: QvacConfig): void;
-export declare function getSDKConfig(): QvacConfig;
-export declare function getConfiguredCacheDir(): string;
-//# sourceMappingURL=config-registry.d.ts.map

package/dist/server/bare/registry/config-registry.js

@@ -1,90 +0,0 @@
-import fs from 'bare-fs';
-import path from 'bare-path';
-import { getQvacPath } from '../../../server/utils/qvac-paths.js';
-import { CacheDirNotAbsoluteError, CacheDirNotWritableError, ConfigAlreadySetError } from '../../../utils/errors-server.js';
-import { getServerLogger, setGlobalConsoleOutput, setGlobalLogLevel } from '../../../logging/index.js';
-const logger = getServerLogger();
-const configRegistry = {
-    cacheDirectory: undefined,
-    swarmRelays: undefined,
-    loggerLevel: undefined,
-    loggerConsoleOutput: undefined,
-    httpDownloadConcurrency: undefined,
-    registryDownloadMaxRetries: undefined,
-    registryStreamTimeoutMs: undefined,
-    deviceDefaults: undefined
-};
-let configIsSet = false;
-/**
- * Sets the SDK configuration. This can only be called ONCE during initialization.
- * After the first call, the config becomes immutable and any subsequent calls will throw.
- *
- * @param config - The configuration to set
- * @throws {ConfigAlreadySetError} If config has already been set
- * @throws {CacheDirNotAbsoluteError} If cacheDirectory is not an absolute path
- * @throws {CacheDirNotWritableError} If cacheDirectory is not writable
- */
-export function setSDKConfig(config) {
-    // Enforce immutability - config can only be set once
-    if (configIsSet) {
-        throw new ConfigAlreadySetError();
-    }
-    if (config.cacheDirectory !== undefined && config.cacheDirectory !== null) {
-        if (!path.isAbsolute(config.cacheDirectory)) {
-            throw new CacheDirNotAbsoluteError();
-        }
-        try {
-            fs.mkdirSync(config.cacheDirectory, { recursive: true });
-            const testFile = path.join(config.cacheDirectory, '.qvac-test');
-            fs.writeFileSync(testFile, 'test');
-            fs.unlinkSync(testFile);
-        }
-        catch (error) {
-            throw new CacheDirNotWritableError(config.cacheDirectory, error instanceof Error ? error.message : String(error), error);
-        }
-        configRegistry.cacheDirectory = config.cacheDirectory;
-        logger.info(`✅ Cache directory set to: ${config.cacheDirectory}`);
-    }
-    if (config.swarmRelays !== undefined && config.swarmRelays !== null) {
-        configRegistry.swarmRelays = config.swarmRelays;
-        logger.info(`✅ Swarm relays configured: ${config.swarmRelays.length} relay(s)`);
-    }
-    if (config.loggerLevel !== undefined && config.loggerLevel !== null) {
-        configRegistry.loggerLevel = config.loggerLevel;
-        setGlobalLogLevel(config.loggerLevel);
-        logger.info(`Log level set to: ${config.loggerLevel}`);
-    }
-    if (config.loggerConsoleOutput !== undefined && config.loggerConsoleOutput !== null) {
-        configRegistry.loggerConsoleOutput = config.loggerConsoleOutput;
-        setGlobalConsoleOutput(config.loggerConsoleOutput);
-        logger.info(`Console output ${config.loggerConsoleOutput ? 'enabled' : 'disabled'}`);
-    }
-    if (config.httpDownloadConcurrency !== undefined && config.httpDownloadConcurrency !== null) {
-        configRegistry.httpDownloadConcurrency = config.httpDownloadConcurrency;
-        logger.info(`HTTP download concurrency set to: ${config.httpDownloadConcurrency}`);
-    }
-    if (config.registryDownloadMaxRetries !== undefined &&
-        config.registryDownloadMaxRetries !== null) {
-        configRegistry.registryDownloadMaxRetries = config.registryDownloadMaxRetries;
-        logger.info(`✅ Registry download max retries set to: ${config.registryDownloadMaxRetries}`);
-    }
-    if (config.registryStreamTimeoutMs !== undefined && config.registryStreamTimeoutMs !== null) {
-        configRegistry.registryStreamTimeoutMs = config.registryStreamTimeoutMs;
-        logger.info(`✅ Registry stream timeout set to: ${config.registryStreamTimeoutMs}ms`);
-    }
-    if (config.deviceDefaults !== undefined && config.deviceDefaults !== null) {
-        configRegistry.deviceDefaults = config.deviceDefaults;
-        logger.info(`✅ Device defaults configured: ${config.deviceDefaults.length} pattern(s)`);
-    }
-    // Mark config as set - now it's immutable
-    configIsSet = true;
-}
-export function getSDKConfig() {
-    return { ...configRegistry };
-}
-function getDefaultCacheDir() {
-    return getQvacPath('models');
-}
-export function getConfiguredCacheDir() {
-    return configRegistry.cacheDirectory || getDefaultCacheDir();
-}

package/dist/server/bare/registry/logging-stream-registry.js

@@ -1,137 +0,0 @@
-/**
- * Logging Stream Registry
- *
- * Manages RPC subscriptions for streaming logs from server to connected clients.
- *
- * Purpose:
- * - Registers client subscriptions to model/SDK log streams
- * - Routes log messages to subscribed clients via RPC
- * - Buffers logs during model loading (before client subscribes)
- * - Manages stream lifecycle (subscribe/unsubscribe)
- *
- */
-import { SDK_ALL_LOG_ID } from '../../../logging/namespaces.js';
-const loggingStreams = new Map();
-// Buffering for logs emitted during model loading (before client subscribes)
-const MAX_BUFFERED_LOGS_PER_MODEL = 100;
-const BUFFER_EXPIRY_MS = 30_000;
-const BUFFERING_TIMEOUT_MS = 5_000;
-const logBuffer = new Map();
-const modelsWithBuffering = new Set();
-const bufferingTimeouts = new Map();
-function clearBufferingTimeout(id) {
-    const timeout = bufferingTimeouts.get(id);
-    if (timeout) {
-        clearTimeout(timeout);
-        bufferingTimeouts.delete(id);
-    }
-}
-export function startLogBuffering(id) {
-    modelsWithBuffering.add(id);
-}
-export function stopLogBufferingWithTimeout(id) {
-    clearBufferingTimeout(id);
-    const timeout = setTimeout(() => {
-        if (modelsWithBuffering.has(id)) {
-            modelsWithBuffering.delete(id);
-            logBuffer.delete(id);
-        }
-        bufferingTimeouts.delete(id);
-    }, BUFFERING_TIMEOUT_MS);
-    bufferingTimeouts.set(id, timeout);
-}
-export function registerLoggingStream(id, streamHandler) {
-    if (!loggingStreams.has(id)) {
-        loggingStreams.set(id, new Set());
-    }
-    loggingStreams.get(id).add(streamHandler);
-    const buffered = logBuffer.get(id);
-    if (buffered && buffered.length > 0) {
-        for (const log of buffered) {
-            try {
-                streamHandler(log.level, log.namespace, log.message, log.sourceId);
-            }
-            catch (error) {
-                console.error(`Error flushing buffered log for ID ${id}:`, error); // fallback (avoid recursion)
-            }
-        }
-        logBuffer.delete(id);
-    }
-    modelsWithBuffering.delete(id);
-    clearBufferingTimeout(id);
-}
-export function unregisterLoggingStream(id, streamHandler) {
-    const streams = loggingStreams.get(id);
-    if (streams) {
-        streams.delete(streamHandler);
-        if (streams.size === 0) {
-            loggingStreams.delete(id);
-        }
-    }
-}
-export function unregisterAllLoggingStreams(id) {
-    // Simply remove all logging handlers
-    // Active streams will naturally terminate when no more logs flow
-    loggingStreams.delete(id);
-    logBuffer.delete(id);
-    modelsWithBuffering.delete(id);
-    clearBufferingTimeout(id);
-}
-export function sendLogToStreams(id, level, namespace, message) {
-    // The originating id is preserved as `sourceId` so the global stream keeps the
-    // real origin of each log instead of reporting the subscription id.
-    deliverToStream(id, level, namespace, message, id);
-    if (id !== SDK_ALL_LOG_ID) {
-        deliverToStream(SDK_ALL_LOG_ID, level, namespace, message, id);
-    }
-}
-function deliverToStream(id, level, namespace, message, sourceId) {
-    const streams = loggingStreams.get(id);
-    const isBuffering = modelsWithBuffering.has(id);
-    if (streams && streams.size > 0) {
-        for (const streamHandler of streams) {
-            try {
-                streamHandler(level, namespace, message, sourceId);
-            }
-            catch (error) {
-                console.error(`Error sending log to stream for ID ${id}:`, error); // fallback (avoid recursion)
-            }
-        }
-    }
-    else if (isBuffering) {
-        if (!logBuffer.has(id)) {
-            logBuffer.set(id, []);
-        }
-        const buffer = logBuffer.get(id);
-        const now = Date.now();
-        const validLogs = buffer.filter((log) => now - log.timestamp < BUFFER_EXPIRY_MS);
-        if (validLogs.length >= MAX_BUFFERED_LOGS_PER_MODEL) {
-            validLogs.shift();
-        }
-        validLogs.push({ level, namespace, message, sourceId, timestamp: now });
-        logBuffer.set(id, validLogs);
-    }
-}
-export function hasLoggingStreams(id) {
-    const streams = loggingStreams.get(id);
-    return streams && streams.size > 0;
-}
-export function getLoggingStreamStats() {
-    return {
-        totalIds: loggingStreams.size,
-        ids: Array.from(loggingStreams.keys()),
-        totalStreams: Array.from(loggingStreams.values()).reduce((sum, streams) => sum + streams.size, 0),
-        bufferedIds: logBuffer.size,
-        idsWithBuffering: modelsWithBuffering.size,
-        activeTimeouts: bufferingTimeouts.size
-    };
-}
-export function clearAllLoggingStreams() {
-    for (const timeout of bufferingTimeouts.values()) {
-        clearTimeout(timeout);
-    }
-    loggingStreams.clear();
-    logBuffer.clear();
-    modelsWithBuffering.clear();
-    bufferingTimeouts.clear();
-}

package/dist/server/bare/registry/model-config-registry.d.ts

@@ -1,4 +0,0 @@
-import type { CanonicalModelType } from '../../../schemas/index.js';
-export { CANONICAL_TO_ALIAS, MODEL_CONFIG_SCHEMAS, BUILTIN_DEVICE_PATTERNS, matchesPattern, findAllMatchingPatterns, getDefaultsFromPattern, resolveModelConfigWithContext } from '../../../server/bare/registry/model-config-utils.js';
-export declare function resolveModelConfig<T>(modelType: CanonicalModelType, userInput: Record<string, unknown>): T;
-//# sourceMappingURL=model-config-registry.d.ts.map

package/dist/server/bare/registry/model-config-registry.js

@@ -1,15 +0,0 @@
-import { getSDKConfig } from '../../../server/bare/registry/config-registry.js';
-import { getRuntimeContext } from '../../../server/bare/registry/runtime-context-registry.js';
-import { getServerLogger } from '../../../logging/index.js';
-export { CANONICAL_TO_ALIAS, MODEL_CONFIG_SCHEMAS, BUILTIN_DEVICE_PATTERNS, matchesPattern, findAllMatchingPatterns, getDefaultsFromPattern, resolveModelConfigWithContext } from '../../../server/bare/registry/model-config-utils.js';
-import { BUILTIN_DEVICE_PATTERNS, resolveModelConfigWithContext } from '../../../server/bare/registry/model-config-utils.js';
-const logger = getServerLogger();
-export function resolveModelConfig(modelType, userInput) {
-    const ctx = getRuntimeContext();
-    const userPatterns = getSDKConfig().deviceDefaults ?? [];
-    return resolveModelConfigWithContext(modelType, userInput, ctx, userPatterns, BUILTIN_DEVICE_PATTERNS, (log) => {
-        if (log.appliedPatterns.length > 0) {
-            logger.debug(`[device-defaults] ${modelType}: applied [${log.appliedPatterns.join(' → ')}]`);
-        }
-    });
-}

package/dist/server/bare/registry/model-config-utils.d.ts

@@ -1,15 +0,0 @@
-import type { ZodSchema } from 'zod';
-import { type CanonicalModelType, type DevicePattern, type DeviceMatch, type RuntimeContext } from '../../../schemas/index.js';
-export declare const CANONICAL_TO_ALIAS: Record<CanonicalModelType, string>;
-export declare const MODEL_CONFIG_SCHEMAS: Partial<Record<CanonicalModelType, ZodSchema>>;
-export declare const BUILTIN_DEVICE_PATTERNS: DevicePattern[];
-export declare function matchesPattern(ctx: RuntimeContext, match: DeviceMatch): boolean;
-export declare function findAllMatchingPatterns(ctx: RuntimeContext, patterns: DevicePattern[]): DevicePattern[];
-export declare function getDefaultsFromPattern(modelType: CanonicalModelType, pattern: DevicePattern): Record<string, unknown> | undefined;
-export type ConfigResolutionLog = {
-    appliedPatterns: string[];
-    mergedDefaults: Record<string, unknown>;
-    finalConfig: Record<string, unknown>;
-};
-export declare function resolveModelConfigWithContext<T>(modelType: CanonicalModelType, userInput: Record<string, unknown>, ctx: RuntimeContext, userPatterns: DevicePattern[], builtinPatterns?: DevicePattern[], onLog?: (log: ConfigResolutionLog) => void): T;
-//# sourceMappingURL=model-config-utils.d.ts.map