@qvac/harness 0.8.5 → 0.8.7

package/dist-lib/lib/models/model-catalog.js

@@ -1,8 +1,8 @@
-import { AUDIOGEN_ACESTEP_5HZ_LM_0_6B_Q8_0, AUDIOGEN_ACESTEP_V15_SFT_Q8_0, AUDIOGEN_ACESTEP_V15_TURBO_Q4_K_M, AUDIOGEN_ACESTEP_V15_TURBO_Q8_0, AUDIOGEN_QWEN3_EMBEDDING_0_6B_Q8_0, AUDIOGEN_VAE_BF16, EMBEDDINGGEMMA_300M_Q4_0, FLUX_2_KLEIN_4B_Q4_0, FLUX_2_KLEIN_4B_VAE, HEALTHCARE_1_7B_MEDICAL_Q4_K_M, HEALTHCARE_4B_MEDICAL_Q4_K_M, MMPROJ_QWEN3_5_2B_MULTIMODAL_Q8_0, MMPROJ_QWEN3_5_4B_MULTIMODAL_Q8_0, MMPROJ_QWEN3_5_9B_MULTIMODAL_F16, MMPROJ_QWEN3_6_27B_MULTIMODAL_F16, MMPROJ_QWEN3_6_35B_A3B_MULTIMODAL_F16, MMPROJ_QWEN3_8_27B_MULTIMODAL_F16, QWEN3_5_2B_MULTIMODAL_Q4_K_M, QWEN3_5_4B_MULTIMODAL_Q4_K_M, QWEN3_5_9B_MULTIMODAL_Q4_K_M, PARAKEET_TDT_0_6B_V3_Q8_0, QWEN3_4B_Q4_K_M, QWEN3_6_27B_MULTIMODAL_Q4_K_XL, QWEN3_6_35B_A3B_MULTIMODAL_Q4_K_M, QWEN3_8_27B_MULTIMODAL_UD_Q4_K_XL, SD_V2_1_1B_Q8_0, SDXL_BASE_1_0_3B_Q4_0, TTS_MULTILINGUAL_SUPERTONIC3_FP16, TTS_MULTILINGUAL_SUPERTONIC3_Q4_0, TTS_MULTILINGUAL_SUPERTONIC3_Q8_0 } from '@qvac/sdk/models';
+import { AUDIOGEN_ACESTEP_5HZ_LM_0_6B_Q8_0, AUDIOGEN_ACESTEP_V15_SFT_Q8_0, AUDIOGEN_ACESTEP_V15_TURBO_Q4_K_M, AUDIOGEN_ACESTEP_V15_TURBO_Q8_0, AUDIOGEN_QWEN3_EMBEDDING_0_6B_Q8_0, AUDIOGEN_VAE_BF16, EMBEDDINGGEMMA_300M_Q4_0, FLUX_2_KLEIN_4B_Q4_0, FLUX_2_KLEIN_4B_VAE, HEALTHCARE_1_7B_MEDICAL_Q4_K_M, HEALTHCARE_4B_MEDICAL_Q4_K_M, MMPROJ_QWEN3_5_2B_MULTIMODAL_Q8_0, MMPROJ_QWEN3_5_4B_MULTIMODAL_Q8_0, MMPROJ_QWEN3_5_9B_MULTIMODAL_F16, MMPROJ_QWEN3_6_27B_MULTIMODAL_F16, MMPROJ_QWEN3_6_35B_A3B_MULTIMODAL_F16, MMPROJ_QWEN3_8_27B_MULTIMODAL_F16, MMPROJ_TERNARY_BONSAI_2_27B_MULTIMODAL_Q8_0, QWEN3_5_2B_MULTIMODAL_Q4_K_M, QWEN3_5_4B_MULTIMODAL_Q4_K_M, QWEN3_5_9B_MULTIMODAL_Q4_K_M, PARAKEET_TDT_0_6B_V3_Q8_0, QWEN3_4B_Q4_K_M, QWEN3_6_27B_MULTIMODAL_Q4_K_XL, QWEN3_6_35B_A3B_MULTIMODAL_Q4_K_M, QWEN3_8_27B_MULTIMODAL_UD_Q4_K_XL, SD_V2_1_1B_Q8_0, SDXL_BASE_1_0_3B_Q4_0, TERNARY_BONSAI_2_27B_MULTIMODAL_PQ2_0, TERNARY_BONSAI_2_27B_MULTIMODAL_PTQ1_0, TTS_MULTILINGUAL_SUPERTONIC3_FP16, TTS_MULTILINGUAL_SUPERTONIC3_Q4_0, TTS_MULTILINGUAL_SUPERTONIC3_Q8_0 } from '@qvac/sdk/models';
 import { detectToolDialect } from './tool-dialect.js';
 import { defaultTtsModelName } from './tts-model-default.js';
-import { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName } from './model-catalog-constants.js';
-export { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName };
+import { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, BONSAI_2_27B_PQ2, BONSAI_2_27B_PTQ1, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName } from './model-catalog-constants.js';
+export { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, BONSAI_2_27B_PQ2, BONSAI_2_27B_PTQ1, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName };
 export const LLM_CATALOG = [
     {
         name: QWEN_35_2B,
@@ -51,6 +51,20 @@ export const LLM_CATALOG = [
         weight: QWEN3_8_27B_MULTIMODAL_UD_Q4_K_XL,
         capabilityProfile: 'xhigh',
         projection: MMPROJ_QWEN3_8_27B_MULTIMODAL_F16
+    },
+    {
+        name: BONSAI_2_27B_PQ2,
+        weight: TERNARY_BONSAI_2_27B_MULTIMODAL_PQ2_0,
+        capabilityProfile: 'high',
+        projection: MMPROJ_TERNARY_BONSAI_2_27B_MULTIMODAL_Q8_0,
+        toolDialect: 'qwen35'
+    },
+    {
+        name: BONSAI_2_27B_PTQ1,
+        weight: TERNARY_BONSAI_2_27B_MULTIMODAL_PTQ1_0,
+        capabilityProfile: 'high',
+        projection: MMPROJ_TERNARY_BONSAI_2_27B_MULTIMODAL_Q8_0,
+        toolDialect: 'qwen35'
     }
 ];
 export function defaultProjectionMap() {
@@ -181,6 +195,16 @@ export function diffusionDownloadMetadata(model, addon) {
         assetSizes
     };
 }
+export function assetBytes(src) {
+    const assets = [
+        ...curatedListables().map((entry) => entry.asset),
+        ...LLM_CATALOG.flatMap((entry) => (entry.projection ? [entry.projection] : [])),
+        ...DIFFUSION_CATALOG.flatMap(diffusionAssets),
+        ...AUDIOGEN_CATALOG.flatMap((entry) => [entry.dit, entry.textEnc, entry.lm, entry.vae])
+    ];
+    const custom = customModels().find((entry) => entry.src === src);
+    return assets.find((asset) => asset.src === src)?.expectedSize ?? custom?.expectedSize;
+}
 import { DEFAULT_MUSIC_MODEL_CHOICE, isMusicModelChoice, musicModelChoiceFrom } from './music-catalog.js';
 export { DEFAULT_MUSIC_MODEL_CHOICE, isMusicModelChoice, musicModelChoiceFrom };
 const MUSIC_GENERATION_SKILL = 'music-generation';
@@ -363,6 +387,11 @@ export function modelAddonOf(model) {
 export function residentSrc(model, addon) {
     return curatedModelAsset(model, addon)?.src ?? model;
 }
+export function catalogModelName(model, addon) {
+    const known = curatedListables().find((entry) => entry.asset.addon === addon &&
+        (entry.name === model || entry.asset.name === model || entry.asset.src === model));
+    return known?.name ?? model;
+}
 export const CUSTOM_TASK_TYPES = ['llm'];
 let CUSTOM_MODELS = new Map();
 export function setCustomModels(entries) {
@@ -378,6 +407,9 @@ export function customModelSrc(name, addon) {
     const entry = CUSTOM_MODELS.get(name);
     return entry && (entry.taskType ?? 'llm') === addon ? entry.src : undefined;
 }
+export function toolDialectFor(name) {
+    return LLM_CATALOG.find((entry) => entry.name === name)?.toolDialect ?? customToolDialect(name);
+}
 export function customToolDialect(name) {
     const entry = CUSTOM_MODELS.get(name);
     return entry

package/dist-lib/lib/models/model-handle.d.ts

@@ -1,10 +1,12 @@
+import { type AbortSignal } from 'bare-abort-controller';
 export interface ModelResource {
     model: string;
     modelId: string;
     ctxSize?: number;
+    bytes?: number;
 }
 export interface ModelHandleOptions {
-    load(): Promise<ModelResource>;
+    load(signal: AbortSignal): Promise<ModelResource>;
     onLoaded?(): void;
     onFailed?(err: unknown): void;
 }
@@ -15,8 +17,13 @@ export declare class ModelHandle {
     private readonly _onFailed;
     private _tracked;
     private _loading;
+    private _resource;
+    lastUsed: number;
+    private _attempt;
     constructor({ load, onLoaded, onFailed }: ModelHandleOptions);
     load(): Promise<ModelResource>;
     get loading(): boolean;
+    abandon(): void;
     peek(): Promise<ModelResource> | null;
+    get resource(): ModelResource | null;
 }

package/dist-lib/lib/models/model-handle.js

@@ -1,3 +1,5 @@
+import { AbortController } from 'bare-abort-controller';
+import { AbortedError } from '../helpers/race-abort.js';
 import { retryMemo } from '../helpers/retry-memo.js';
 export class ModelHandle {
     _load;
@@ -6,8 +8,15 @@ export class ModelHandle {
     _onFailed;
     _tracked = null;
     _loading = false;
+    _resource = null;
+    lastUsed = 0;
+    _attempt = null;
     constructor({ load, onLoaded, onFailed }) {
-        const memo = retryMemo(load);
+        const memo = retryMemo(() => {
+            const attempt = new AbortController();
+            this._attempt = attempt;
+            return load(attempt.signal);
+        });
         this._load = memo;
         this._peek = memo.peek;
         this._onLoaded = onLoaded;
@@ -25,15 +34,24 @@ export class ModelHandle {
                     report();
                 }
             };
-            attempt.then(() => settle(() => this._onLoaded?.()), (err) => settle(() => this._onFailed?.(err)));
+            attempt.then((resource) => settle(() => {
+                this._resource = resource;
+                this._onLoaded?.();
+            }), (err) => settle(() => this._onFailed?.(err)));
         }
         return attempt;
     }
     get loading() {
         return this._loading;
     }
+    abandon() {
+        this._attempt?.abort(new AbortedError());
+    }
     peek() {
         return this._peek();
     }
+    get resource() {
+        return this._loading ? null : this._resource;
+    }
 }
 function noop() { }

package/dist-lib/lib/models/model-list.d.ts

@@ -1,5 +1,5 @@
 import type * as QvacSdk from '@qvac/sdk';
-import type { ModelAddon, ModelRegistrySdk } from './model-source.ts';
+import { type ModelAddon, type ModelRegistrySdk } from './model-source.ts';
 import { type ModelTaskType } from './model-task.ts';
 export type ModelType = ModelAddon;
 export interface StaticCatalogEntry {
@@ -22,6 +22,7 @@ export interface ModelInfo {
     actualSize?: number;
     label?: string;
     taskType: ModelTaskType;
+    memoryBytes?: number | undefined;
 }
 export type CatalogRow = Omit<ModelInfo, 'isLoading'>;
 export interface ListModelsOptions {
@@ -54,4 +55,10 @@ export interface CustomModelRowsContext {
 }
 export declare function customModelRows({ type, cachedOnly }: ListModelsOptions, { modelsDir, loaded }: CustomModelRowsContext): Promise<CatalogRow[]>;
 export declare function mergeCustomRows(catalog: ReadonlyArray<CatalogRow>, custom: ReadonlyArray<CatalogRow>): CatalogRow[];
+export interface ModelSourceQuery {
+    readonly model: string;
+    readonly addon: ModelAddon;
+    readonly modelsDir: string | undefined;
+}
+export declare function isModelSourceCached(sdk: ModelListSdk, { model, addon, modelsDir }: ModelSourceQuery): Promise<boolean>;
 export {};

package/dist-lib/lib/models/model-list.js

@@ -1,3 +1,4 @@
+import { resolveModelSrc } from './model-source.js';
 import { addonTaskType } from './model-task.js';
 import { isCustomModelCached } from './custom-model-cache.js';
 import { companionRegistryPaths, curatedListables, customModels, musicListables } from './model-catalog.js';
@@ -153,3 +154,25 @@ export function mergeCustomRows(catalog, custom) {
     const shadowed = new Set(custom.map((row) => row.name));
     return [...catalog.filter((row) => !shadowed.has(row.name)), ...custom];
 }
+export async function isModelSourceCached(sdk, { model, addon, modelsDir }) {
+    const src = await resolveModelSrc(sdk, model, addon).catch(() => null);
+    if (src === null) {
+        return false;
+    }
+    const name = registryCatalogName(sdk, src);
+    if (name === undefined) {
+        return typeof src === 'string' && isCustomModelCached({ name: model, src }, modelsDir);
+    }
+    const info = await sdk.getModelInfo({ name }).catch(() => null);
+    return info?.isCached ?? false;
+}
+function registryCatalogName(sdk, src) {
+    if (typeof src !== 'string') {
+        return sdk.models.find((entry) => entry.registryPath === src.registryPath)?.name ?? src.name;
+    }
+    const registryPath = /^registry:\/\/[^/]+\/(.+)$/.exec(src)?.[1];
+    if (registryPath === undefined) {
+        return undefined;
+    }
+    return sdk.models.find((entry) => entry.registryPath === registryPath)?.name;
+}

package/dist-lib/lib/models/model-pool.d.ts

@@ -3,14 +3,29 @@ import { ModelHandle } from './model-handle.ts';
 import { type ModelSrc } from './context.ts';
 import { type ModelAddon } from './model-source.ts';
 import type { GpuFaultState } from './sdk-faults.ts';
+import type { HoldFn } from './download-gate.ts';
 type SdkModule = typeof import('@qvac/sdk');
+type FitModelType = NonNullable<import('@qvac/sdk').AssessModelFitInput['models'][number]['modelType']>;
 export interface ModelState {
-    status: 'loading' | 'downloading' | 'downloaded' | 'ready' | 'error' | 'unloading' | 'unloaded';
+    status: 'held' | 'loading' | 'downloading' | 'downloaded' | 'ready' | 'error' | 'unloading' | 'unloaded';
     model: string;
     catalogChanged?: boolean;
     [key: string]: unknown;
 }
 export type NotifyFn = (state: ModelState) => void;
+export interface PendingLoad {
+    readonly key: string;
+    readonly model: string;
+    readonly modelSrc: ModelSrc;
+    readonly modelType: FitModelType;
+    readonly modelConfig?: Record<string, unknown> | undefined;
+}
+export interface Admission {
+    readonly bytes: number | undefined;
+    release(): void;
+}
+export type BeforeLoad = (load: PendingLoad) => Promise<Admission | undefined>;
+export type ChooseContext = (load: PendingLoad, tier: number) => Promise<number>;
 export interface LlmDeviceConfig {
     device?: 'cpu' | 'gpu';
     gpuLayers?: number;
@@ -80,6 +95,13 @@ export declare function modelOf(key: string): string;
 export declare function releaseModel(pool: PoolLike, key: string): void;
 export declare function loadedModels(pool: PoolLike): LoadedModel[];
 export declare function settledModels(pool: PoolLike): string[];
+export interface SettledEntry {
+    readonly key: string;
+    readonly refs: number;
+    readonly bytes: number | undefined;
+    readonly lastUsed: number;
+}
+export declare function settledEntries(pool: PoolLike): SettledEntry[];
 export declare function loadingModels(pool: PoolLike): string[];
 export interface ResidentLease {
     model: string;
@@ -104,6 +126,7 @@ export interface ModelCapacityOptions extends DeadlineOptions {
 }
 export declare function awaitModelCapacity(pool: PoolLike, { cap, deadlineMs, tickMs, signal, evictable }: ModelCapacityOptions): Promise<boolean>;
 export declare function evictModelWithin(pool: PoolLike, key: string, options: DeadlineOptions): Promise<boolean>;
+export declare function evictIdleWithin(pool: PoolLike, key: string, { deadlineMs }: DeadlineOptions): Promise<boolean>;
 export declare function evictModel(pool: PoolLike, model: string, options: DeadlineOptions): Promise<boolean>;
 export type LoadSdk = () => Promise<ModelLifecycleSdk>;
 export type EmbedLifecycleSdk = Pick<SdkModule, 'unloadModel' | 'modelRegistrySearch'> & Partial<CancelSdk> & {
@@ -134,15 +157,20 @@ export declare function loadClockGuard(model: string, sdk: Partial<CancelSdk>, {
 export interface ModelPoolOptions {
     deviceConfig?: LlmDeviceConfig;
     loads?: LoadTracker;
+    beforeLoad?: BeforeLoad;
+    chooseContext?: ChooseContext;
+    hold?: HoldFn;
 }
-export declare function createModelPool(loadSdk: LoadSdk, notify: NotifyFn, { deviceConfig, loads }?: ModelPoolOptions): ModelPuddle;
+export declare function createModelPool(loadSdk: LoadSdk, notify: NotifyFn, { deviceConfig, loads, beforeLoad, chooseContext, hold }?: ModelPoolOptions): ModelPuddle;
 export interface EmbedPoolOptions {
     faults: GpuFaultState;
     batchSize?: number;
     openclCacheDir?: (() => string | undefined) | undefined;
     loads?: LoadTracker;
+    beforeLoad?: BeforeLoad;
+    hold?: HoldFn;
 }
-export declare function createEmbedPool(loadSdk: LoadEmbedSdk, notify: NotifyFn, { faults, batchSize, openclCacheDir, loads }: EmbedPoolOptions): ModelPuddle;
+export declare function createEmbedPool(loadSdk: LoadEmbedSdk, notify: NotifyFn, { faults, batchSize, openclCacheDir, loads, beforeLoad, hold }: EmbedPoolOptions): ModelPuddle;
 export type VoiceLifecycleSdk = Pick<SdkModule, 'unloadModel' | 'modelRegistrySearch'> & Partial<CancelSdk> & {
     loadModel(params: {
         modelSrc: ModelSrc;
@@ -153,12 +181,14 @@ export type VoiceLifecycleSdk = Pick<SdkModule, 'unloadModel' | 'modelRegistrySe
 };
 export type LoadVoiceSdk = () => Promise<VoiceLifecycleSdk>;
 export interface VoicePoolOptions {
-    modelType: string;
+    modelType: FitModelType;
     addon: ModelAddon;
     modelConfig?: Record<string, unknown> | undefined;
     modelConfigFor?: (modelSrc: ModelSrc) => Readonly<Record<string, unknown>> | undefined;
     openclCacheDir?: (() => string | undefined) | undefined;
     loads?: LoadTracker;
+    beforeLoad?: BeforeLoad;
+    hold?: HoldFn;
 }
-export declare function createVoicePool(loadSdk: LoadVoiceSdk, notify: NotifyFn, { modelType, addon, modelConfig, modelConfigFor, openclCacheDir, loads }: VoicePoolOptions): ModelPuddle;
+export declare function createVoicePool(loadSdk: LoadVoiceSdk, notify: NotifyFn, { modelType, addon, modelConfig, modelConfigFor, openclCacheDir, loads, beforeLoad, hold }: VoicePoolOptions): ModelPuddle;
 export {};

package/dist-lib/lib/models/model-pool.js

@@ -11,6 +11,7 @@ import { RUNAWAY_STOP_SEQUENCES } from '../helpers/control-tokens.js';
 import { raceTimeout } from '../helpers/race-timeout.js';
 import { resolveModelSrc } from './model-source.js';
 import { errorMessage } from '../guards.js';
+import { AbortedError } from '../helpers/race-abort.js';
 export function createLoadTracker() {
     const inflight = new Set();
     let draining = null;
@@ -73,10 +74,14 @@ function entryOf(pool, key) {
 export function modelOf(key) {
     return key.split('\0')[0];
 }
+let uses = 0;
 export function releaseModel(pool, key) {
     if (pool.destroyed)
         return;
     const handle = entryOf(pool, key)?.value;
+    if (handle) {
+        handle.lastUsed = ++uses;
+    }
     if (handle === undefined || !handle.loading) {
         pool.release(key);
         return;
@@ -86,8 +91,18 @@ export function releaseModel(pool, key) {
         pool.release(key);
         return;
     }
-    void pending.then(() => releaseSettled(pool, key), () => releaseSettled(pool, key));
+    const deferred = (deferredReleases.get(handle) ?? 0) + 1;
+    deferredReleases.set(handle, deferred);
+    if (deferred >= (entryOf(pool, key)?.refs ?? 0)) {
+        handle.abandon();
+    }
+    const settle = () => {
+        deferredReleases.set(handle, (deferredReleases.get(handle) ?? 1) - 1);
+        releaseSettled(pool, key);
+    };
+    void pending.then(settle, settle);
 }
+const deferredReleases = new WeakMap();
 function releaseSettled(pool, key) {
     if (!pool.destroyed) {
         pool.release(key);
@@ -111,6 +126,21 @@ export function settledModels(pool) {
     }
     return out;
 }
+export function settledEntries(pool) {
+    const out = [];
+    for (const entry of pool.resources.values()) {
+        const resource = entry.value.resource;
+        if (resource !== null) {
+            out.push({
+                key: entry.id,
+                refs: entry.refs,
+                bytes: resource.bytes,
+                lastUsed: entry.value.lastUsed
+            });
+        }
+    }
+    return out;
+}
 export function loadingModels(pool) {
     const out = [];
     for (const entry of pool.resources.values()) {
@@ -120,14 +150,19 @@ export function loadingModels(pool) {
     }
     return out;
 }
-function reportedHandle(notify, model, load) {
+function reportedHandle({ notify, model, addon, hold, load }) {
     return new ModelHandle({
-        load: () => {
+        load: async (signal) => {
+            await hold?.(model, addon, signal);
             notify({ status: 'loading', model, catalogChanged: true });
             return load();
         },
         onLoaded: () => notify({ status: 'ready', model, catalogChanged: true }),
-        onFailed: (err) => notify({ status: 'error', model, message: errorMessage(err), catalogChanged: true })
+        onFailed: (err) => {
+            if (err instanceof AbortedError)
+                return;
+            notify({ status: 'error', model, message: errorMessage(err), catalogChanged: true });
+        }
     });
 }
 export async function leaseResidentModel(pool, wanted = () => true) {
@@ -226,6 +261,10 @@ export async function awaitModelCapacity(pool, { cap, deadlineMs, tickMs = 250,
 export function evictModelWithin(pool, key, options) {
     return evictWhereWithin(pool, (candidate) => candidate === key, options);
 }
+export function evictIdleWithin(pool, key, { deadlineMs }) {
+    const evicting = evictIdleWhere(pool, (candidate) => candidate === key).then(() => !isResident(pool, key));
+    return raceTimeout(evicting, { ms: deadlineMs, fallback: false });
+}
 export function evictModel(pool, model, options) {
     return evictWhereWithin(pool, (key) => modelOf(key) === model, options);
 }
@@ -318,12 +357,12 @@ export function loadClockGuard(model, sdk, { now = () => Date.now(), monoMs = mo
     };
     return { race };
 }
-export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = createLoadTracker() } = {}) {
-    const load = async (model, opts) => {
+export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = createLoadTracker(), beforeLoad, chooseContext, hold } = {}) {
+    const load = async (key, model, opts) => {
         const sdk = await loadSdk();
         const modelSrc = await resolveModelSrc(sdk, model);
         const resolved = resolveLoadOptions(opts, deviceConfig);
-        const ctxSize = resolved.ctxSize || defaultContextSize(modelSrc, customContextLength(model));
+        const tier = defaultContextSize(modelSrc, customContextLength(model));
         const projectionModelSrc = resolved.projectionModel
             ? await resolveModelSrc(sdk, resolved.projectionModel)
             : undefined;
@@ -337,11 +376,10 @@ export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = cr
         const openclCache = deviceConfig.device !== 'cpu' && deviceConfig.openclCacheDir
             ? deviceConfig.openclCacheDir()
             : undefined;
-        const modelConfig = definedFields({
+        const config = definedFields({
             verbosity: llmVerbosity(),
             tools: true,
             stop_sequences: RUNAWAY_STOP_SEQUENCES,
-            ctx_size: ctxSize,
             'cache-type-k': kvCache.k,
             'cache-type-v': kvCache.v,
             projectionModelSrc,
@@ -350,56 +388,80 @@ export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = cr
             'main-gpu': mainGpu,
             openclCacheDir: openclCache || undefined
         });
+        const pending = { key, model, modelSrc, modelType: 'llamacpp-completion' };
+        const ctxSize = resolved.ctxSize ||
+            (chooseContext ? await chooseContext({ ...pending, modelConfig: config }, tier) : tier);
+        const modelConfig = { ...config, ctx_size: ctxSize };
         const { projectionModelSrc: projection, ...loggedConfig } = modelConfig;
         hlog('llm load config', { model, projection: Boolean(projection), ...loggedConfig });
+        const admission = await beforeLoad?.({ ...pending, modelConfig });
         const loadStarted = Date.now();
-        const modelId = await loadClockGuard(model, sdk).race(loads.track(sdk.loadModel({
+        const modelId = await loadClockGuard(model, sdk)
+            .race(loads.track(sdk.loadModel({
             modelSrc,
             modelType: 'llamacpp-completion',
             modelConfig,
             onProgress: (progress) => notify(progressState(model, progress))
-        })));
+        })))
+            .finally(() => admission?.release());
         hlog('llm loaded', { model, loadMs: Date.now() - loadStarted });
-        return { model, modelId, ctxSize };
+        return { model, modelId, ctxSize, bytes: admission?.bytes };
     };
     return new ModelPuddle({
-        open: (key, model = key, opts = {}) => reportedHandle(notify, model, () => load(model, opts)),
+        open: (key, model = key, opts = {}) => reportedHandle({ notify, model, addon: 'llm', hold, load: () => load(key, model, opts) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
     });
 }
-export function createEmbedPool(loadSdk, notify, { faults, batchSize = DEFAULT_EMBED_BATCH_SIZE, openclCacheDir, loads = createLoadTracker() }) {
-    const load = async (model) => {
+export function createEmbedPool(loadSdk, notify, { faults, batchSize = DEFAULT_EMBED_BATCH_SIZE, openclCacheDir, loads = createLoadTracker(), beforeLoad, hold }) {
+    const load = async (key, model) => {
         const sdk = await loadSdk();
         const modelSrc = await resolveModelSrc(sdk, model, 'embeddings');
         const openclCache = faults.device !== 'cpu' && openclCacheDir ? openclCacheDir() : undefined;
-        const modelId = await loadClockGuard(model, sdk).race(loads.track(sdk.loadModel({
+        const modelConfig = {
+            batchSize,
+            gpuLayers: faults.gpuLayers(),
+            device: faults.device,
+            openclCacheDir: openclCache || undefined
+        };
+        const admission = await beforeLoad?.({
+            key,
+            model,
+            modelSrc,
+            modelType: 'llamacpp-embedding',
+            modelConfig
+        });
+        const modelId = await loadClockGuard(model, sdk)
+            .race(loads.track(sdk.loadModel({
             modelSrc,
             modelType: 'llamacpp-embedding',
-            modelConfig: {
-                batchSize,
-                gpuLayers: faults.gpuLayers(),
-                device: faults.device,
-                openclCacheDir: openclCache || undefined
-            },
+            modelConfig,
             onProgress: (progress) => notify(progressState(model, progress))
-        })));
-        return { model, modelId };
+        })))
+            .finally(() => admission?.release());
+        return { model, modelId, bytes: admission?.bytes };
     };
     return new ModelPuddle({
-        open: (key, model = key) => reportedHandle(notify, model, () => load(model)),
+        open: (key, model = key) => reportedHandle({ notify, model, addon: 'embeddings', hold, load: () => load(key, model) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
     });
 }
-export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig, modelConfigFor, openclCacheDir, loads = createLoadTracker() }) {
+export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig, modelConfigFor, openclCacheDir, loads = createLoadTracker(), beforeLoad, hold }) {
     const wantsGpu = modelConfig?.['useGPU'] === true;
     let gpuRefused = false;
-    const load = async (model) => {
+    const load = async (key, model) => {
         const sdk = await loadSdk();
         const modelSrc = await resolveModelSrc(sdk, model, addon);
         const tuned = modelConfigFor?.(modelSrc);
         const loadConfig = tuned ? { ...modelConfig, ...tuned } : modelConfig;
+        const admission = await beforeLoad?.({
+            key,
+            model,
+            modelSrc,
+            modelType,
+            modelConfig: loadConfig
+        });
         const attempt = () => {
             const config = gpuRefused ? { ...loadConfig, useGPU: false } : loadConfig;
             const openclCache = gpuRefused ? undefined : openclCacheDir?.();
@@ -410,17 +472,19 @@ export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig
                 onProgress: (progress) => notify(progressState(model, progress))
             }));
         };
-        const modelId = await loadClockGuard(model, sdk).race(attempt().catch((err) => {
+        const modelId = await loadClockGuard(model, sdk)
+            .race(attempt().catch((err) => {
             if (!wantsGpu || gpuRefused || loads.draining)
                 throw err;
             hlog('voice gpu load refused, retrying on cpu', { model, modelType, error: String(err) });
             gpuRefused = true;
             return attempt();
-        }));
-        return { model, modelId };
+        }))
+            .finally(() => admission?.release());
+        return { model, modelId, bytes: admission?.bytes };
     };
     return new ModelPuddle({
-        open: (key, model = key) => reportedHandle(notify, model, () => load(model)),
+        open: (key, model = key) => reportedHandle({ notify, model, addon, hold, load: () => load(key, model) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
     });
@@ -445,7 +509,8 @@ function unloadOnGc(loadSdk, notify) {
             try {
                 await sdk.unloadModel({ modelId });
             }
-            catch {
+            catch (err) {
+                hlog('unload failed', { model, err: errorMessage(err) });
                 continue;
             }
             notify({ status: 'unloaded', model, catalogChanged: true });

package/dist-lib/lib/models/sdk-faults.d.ts

@@ -1,6 +1,7 @@
 import type { EmbedDevice } from './embed-config.ts';
 export declare function isSdkGpuDeviceLostError(err: unknown): boolean;
 export declare function isSdkModelWedgedError(err: unknown): boolean;
+export declare function isGrammarOverrunError(err: unknown): boolean;
 export declare function isContextOverflowError(err: unknown): boolean;
 export type GpuFaultDecision = 'reload' | 'fallback';
 interface GpuFaultEscalation {

package/dist-lib/lib/models/sdk-faults.js

@@ -16,6 +16,12 @@ export function isSdkModelWedgedError(err) {
     }
     return /failed to (decode next token|eval chunk)/i.test(message);
 }
+export function isGrammarOverrunError(err) {
+    if (typeof err !== 'object' || err === null)
+        return false;
+    const message = 'message' in err ? err.message : undefined;
+    return typeof message === 'string' && /empty grammar stack/i.test(message);
+}
 export function isContextOverflowError(err) {
     if (typeof err !== 'object' || err === null)
         return false;

package/dist-lib/lib/office/engine/pptx/picture-area.d.ts

@@ -0,0 +1,23 @@
+import type { Box } from './inherit.ts';
+import type { SlideSize } from './template.ts';
+export type Role = 'slot' | 'blank' | 'body' | 'picture' | 'other';
+export interface Size {
+    readonly width: number;
+    readonly height: number;
+}
+export interface Placed {
+    readonly box: Box;
+    readonly role: Role;
+}
+export interface Beside<T> {
+    readonly shape: T;
+    readonly box: Box;
+}
+export interface Area<T> {
+    readonly box: Box;
+    readonly cleared: readonly T[];
+    readonly beside: Beside<T> | null;
+}
+export declare function framed(slide: SlideSize): Box;
+export declare function fitted(size: Size, area: Box): Box;
+export declare function pictureArea<T extends Placed>(slide: SlideSize, shapes: readonly T[]): Area<T>;