@qvac/harness 0.4.0 → 0.6.0

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

@@ -3,16 +3,18 @@ import { transferProgress } from '../model-download-progress.js';
 import ResourcePuddle from 'resource-puddle';
 import { ModelHandle } from './model-handle.js';
 import { defaultContextSize } from './context.js';
+import { customContextLength } from './model-catalog.js';
 import { adrenoSafeKvCache } from './kv-cache.js';
 import { DEFAULT_EMBED_BATCH_SIZE } from './embed-config.js';
 import { hlog } from '../log.js';
 import { RUNAWAY_STOP_SEQUENCES } from '../helpers/control-tokens.js';
+import { raceTimeout } from '../helpers/race-timeout.js';
 import { resolveModelSrc } from './model-source.js';
 export function createLoadTracker() {
     const inflight = new Set();
     let draining = null;
     const cancel = (sdk, requestId) => {
-        void sdk.cancel({ requestId }).catch(() => { });
+        void sdk.cancel({ requestId }).catch(noop);
     };
     return {
         get draining() {
@@ -20,8 +22,9 @@ export function createLoadTracker() {
         },
         track(pending) {
             const { requestId } = pending;
-            if (!requestId)
+            if (!requestId) {
                 return pending;
+            }
             if (draining) {
                 cancel(draining, requestId);
                 return pending;
@@ -33,8 +36,9 @@ export function createLoadTracker() {
         },
         drain(sdk) {
             draining = sdk;
-            for (const requestId of inflight)
+            for (const requestId of inflight) {
                 cancel(sdk, requestId);
+            }
             inflight.clear();
         },
         undrain() {
@@ -60,9 +64,14 @@ export function modelKey(model, opts = {}) {
         opts.projectionModel ?? ''
     ].join('\0');
 }
+class ModelPuddle extends ResourcePuddle {
+}
 function entryOf(pool, key) {
     return pool.resources.get(key);
 }
+export function modelOf(key) {
+    return key.split('\0')[0];
+}
 export function releaseModel(pool, key) {
     if (pool.destroyed)
         return;
@@ -79,8 +88,9 @@ export function releaseModel(pool, key) {
     void pending.then(() => releaseSettled(pool, key), () => releaseSettled(pool, key));
 }
 function releaseSettled(pool, key) {
-    if (!pool.destroyed)
+    if (!pool.destroyed) {
         pool.release(key);
+    }
 }
 export function loadedModels(pool) {
     const out = [];
@@ -95,8 +105,9 @@ export async function leaseResidentModel(pool, wanted = () => true) {
     for (const entry of pool.resources.values()) {
         const key = entry.id;
         const pending = entry.value.peek();
-        if (!pending || entry.value.loading || !wanted(key.split('\0')[0]))
+        if (!pending || entry.value.loading || !wanted(key.split('\0')[0])) {
             continue;
+        }
         pool.open(key);
         const loaded = await pending;
         return { model: loaded.model, modelId: loaded.modelId, release: () => releaseModel(pool, key) };
@@ -115,8 +126,43 @@ export async function evictIdle(pool) {
         await pool.gc();
     }
 }
-export async function awaitModelCapacity(pool, cap, deadlineMs, tickMs = 250, signal) {
-    const roomed = () => loadedModels(pool).length < cap;
+export async function evictIdleWhere(pool, wanted) {
+    for (let tick = 0; tick <= pool.gcIdleTicks; tick++) {
+        if (pool.destroyed)
+            return;
+        const held = [];
+        for (const entry of pool.resources.values()) {
+            if (entry.refs === 0 && !wanted(entry.id)) {
+                held.push(entry.id);
+            }
+        }
+        if (pool.idle === held.length) {
+            return;
+        }
+        for (const key of held) {
+            pool.open(key);
+        }
+        try {
+            await pool.gc();
+        }
+        finally {
+            for (const key of held) {
+                releaseSettled(pool, key);
+            }
+        }
+    }
+}
+function residentCount(pool, wanted) {
+    let count = 0;
+    for (const entry of pool.resources.values()) {
+        if (wanted(entry.id) && entry.value.peek() !== null) {
+            count++;
+        }
+    }
+    return count;
+}
+export async function awaitModelCapacity(pool, { cap, deadlineMs, tickMs = 250, signal, evictable = () => true }) {
+    const roomed = () => residentCount(pool, evictable) < cap;
     let done = false;
     let timer = null;
     const expired = new Promise((resolve) => {
@@ -126,14 +172,15 @@ export async function awaitModelCapacity(pool, cap, deadlineMs, tickMs = 250, si
         }, deadlineMs);
     });
     const evicting = (async () => {
-        await evictIdle(pool);
+        await evictIdleWhere(pool, evictable);
         while (!roomed()) {
             if (done || signal?.aborted)
                 return false;
             await new Promise((resolve) => setTimeout(resolve, tickMs));
-            if (done || signal?.aborted)
+            if (done || signal?.aborted) {
                 return false;
-            await evictIdle(pool);
+            }
+            await evictIdleWhere(pool, evictable);
         }
         return true;
     })();
@@ -142,40 +189,51 @@ export async function awaitModelCapacity(pool, cap, deadlineMs, tickMs = 250, si
     }
     finally {
         done = true;
-        if (timer !== null)
+        if (timer !== null) {
             clearTimeout(timer);
+        }
     }
 }
-export async function evictModelWithin(pool, key, deadlineMs, tickMs = 250) {
-    let timer = null;
-    const expired = new Promise((resolve) => {
-        timer = setTimeout(() => resolve(false), deadlineMs);
-    });
+export function evictModelWithin(pool, key, options) {
+    return evictWhereWithin(pool, (candidate) => candidate === key, options);
+}
+export function evictModel(pool, model, options) {
+    return evictWhereWithin(pool, (key) => modelOf(key) === model, options);
+}
+async function evictWhereWithin(pool, wanted, { deadlineMs, tickMs = 250 }) {
+    let done = false;
     const evicting = (async () => {
-        while (isResident(pool, key)) {
-            await evictIdle(pool);
-            if (!isResident(pool, key))
+        while (residentCount(pool, wanted) > 0) {
+            await evictIdleWhere(pool, wanted);
+            if (residentCount(pool, wanted) === 0) {
                 break;
+            }
             await new Promise((resolve) => setTimeout(resolve, tickMs));
+            if (done) {
+                return false;
+            }
         }
         return true;
     })();
     try {
-        return await Promise.race([evicting, expired]);
+        return await raceTimeout(evicting, { ms: deadlineMs, fallback: false });
     }
     finally {
-        if (timer !== null)
-            clearTimeout(timer);
+        done = true;
     }
 }
+function definedFields(config) {
+    return Object.fromEntries(Object.entries(config).filter(([, value]) => value !== undefined));
+}
 function llmVerbosity() {
     const raw = Number(process.env.QVAC_LLM_VERBOSITY ?? 0);
     return raw === 1 || raw === 2 || raw === 3 ? raw : 0;
 }
 export function progressState(model, progress) {
     const transfer = transferProgress(progress);
-    if (!transfer)
+    if (!transfer) {
         return { status: 'loading', model };
+    }
     const { percentage, downloaded, total } = transfer;
     return percentage < 100
         ? { ...progress, status: 'downloading', model, percentage, downloaded, total }
@@ -188,14 +246,11 @@ function monotonicMs() {
 }
 export function loadClockGuard(model, sdk, { now = () => Date.now(), monoMs = monotonicMs, sampleMs = CLOCK_SAMPLE_MS, jumpMs = CLOCK_JUMP_MS } = {}) {
     let timer = null;
-    let fail;
+    const { promise: jumped, reject: fail } = Promise.withResolvers();
     let done = false;
     let abandoned = false;
     let lastWall = now();
     let lastMono = monoMs();
-    const jumped = new Promise((_resolve, reject) => {
-        fail = reject;
-    });
     const arm = () => {
         timer = setTimeout(sample, sampleMs);
         timer.unref?.();
@@ -221,36 +276,40 @@ export function loadClockGuard(model, sdk, { now = () => Date.now(), monoMs = mo
         }
         catch (err) {
             if (abandoned && pending.requestId) {
-                void sdk.cancel?.({ requestId: pending.requestId }).catch(() => { });
+                void sdk.cancel?.({ requestId: pending.requestId }).catch(noop);
             }
             throw err;
         }
         finally {
             done = true;
-            if (timer !== null)
+            if (timer !== null) {
                 clearTimeout(timer);
+            }
         }
     };
     return { race };
 }
-export function createModelPool(loadSdk, notify, deviceConfig = {}, loads = createLoadTracker()) {
+export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = createLoadTracker() } = {}) {
     const load = async (model, opts) => {
         const sdk = await loadSdk();
         notify({ status: 'loading', model });
         const modelSrc = await resolveModelSrc(sdk, model);
         const resolved = resolveLoadOptions(opts, deviceConfig);
-        const ctxSize = resolved.ctxSize || defaultContextSize(modelSrc);
+        const ctxSize = resolved.ctxSize || defaultContextSize(modelSrc, customContextLength(model));
         const projectionModelSrc = resolved.projectionModel
             ? await resolveModelSrc(sdk, resolved.projectionModel)
             : undefined;
         const mainGpu = deviceConfig.device !== 'cpu' && deviceConfig.mainGpu
             ? await deviceConfig.mainGpu()
             : undefined;
-        const kvCache = adrenoSafeKvCache(deviceConfig.device, resolved.kvCacheK, resolved.kvCacheV);
+        const kvCache = adrenoSafeKvCache(deviceConfig.device, {
+            k: resolved.kvCacheK,
+            v: resolved.kvCacheV
+        });
         const openclCache = deviceConfig.device !== 'cpu' && deviceConfig.openclCacheDir
             ? deviceConfig.openclCacheDir()
             : undefined;
-        const modelConfig = {
+        const modelConfig = definedFields({
             verbosity: llmVerbosity(),
             tools: true,
             stop_sequences: RUNAWAY_STOP_SEQUENCES,
@@ -258,11 +317,11 @@ export function createModelPool(loadSdk, notify, deviceConfig = {}, loads = crea
             'cache-type-k': kvCache.k,
             'cache-type-v': kvCache.v,
             projectionModelSrc,
-            ...(deviceConfig.device ? { device: deviceConfig.device } : {}),
-            ...(deviceConfig.gpuLayers === undefined ? {} : { gpu_layers: deviceConfig.gpuLayers }),
-            ...(mainGpu === undefined ? {} : { 'main-gpu': mainGpu }),
-            ...(openclCache ? { openclCacheDir: openclCache } : {})
-        };
+            device: deviceConfig.device,
+            gpu_layers: deviceConfig.gpuLayers,
+            'main-gpu': mainGpu,
+            openclCacheDir: openclCache || undefined
+        });
         const { projectionModelSrc: projection, ...loggedConfig } = modelConfig;
         hlog('llm load config', { model, projection: Boolean(projection), ...loggedConfig });
         const loadStarted = Date.now();
@@ -276,13 +335,13 @@ export function createModelPool(loadSdk, notify, deviceConfig = {}, loads = crea
         notify({ status: 'ready', model });
         return { model, modelId, ctxSize };
     };
-    return new ResourcePuddle({
+    return new ModelPuddle({
         open: (key, model = key, opts = {}) => new ModelHandle({ load: () => load(model, opts) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
     });
 }
-export function createEmbedPool(loadSdk, notify, faults, batchSize = DEFAULT_EMBED_BATCH_SIZE, openclCacheDir, loads = createLoadTracker()) {
+export function createEmbedPool(loadSdk, notify, { faults, batchSize = DEFAULT_EMBED_BATCH_SIZE, openclCacheDir, loads = createLoadTracker() }) {
     const load = async (model) => {
         const sdk = await loadSdk();
         notify({ status: 'loading', model });
@@ -295,20 +354,20 @@ export function createEmbedPool(loadSdk, notify, faults, batchSize = DEFAULT_EMB
                 batchSize,
                 gpuLayers: faults.gpuLayers(),
                 device: faults.device,
-                ...(openclCache ? { openclCacheDir: openclCache } : {})
+                openclCacheDir: openclCache || undefined
             },
             onProgress: (progress) => notify(progressState(model, progress))
         })));
         notify({ status: 'ready', model });
         return { model, modelId };
     };
-    return new ResourcePuddle({
+    return new ModelPuddle({
         open: (key, model = key) => new ModelHandle({ load: () => load(model) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
     });
 }
-export function createVoicePool(loadSdk, notify, modelType, addon, modelConfig, openclCacheDir, loads = createLoadTracker()) {
+export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig, openclCacheDir, loads = createLoadTracker() }) {
     const wantsGpu = modelConfig?.['useGPU'] === true;
     let gpuRefused = false;
     const load = async (model) => {
@@ -335,7 +394,7 @@ export function createVoicePool(loadSdk, notify, modelType, addon, modelConfig,
         notify({ status: 'ready', model });
         return { model, modelId };
     };
-    return new ResourcePuddle({
+    return new ModelPuddle({
         open: (key, model = key) => new ModelHandle({ load: () => load(model) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
@@ -346,8 +405,9 @@ function unloadOnGc(loadSdk, notify) {
         const sdk = await loadSdk();
         for (const handle of handles) {
             const pending = handle.peek();
-            if (pending === null)
+            if (pending === null) {
                 continue;
+            }
             let loaded;
             try {
                 loaded = await pending;
@@ -367,3 +427,4 @@ function unloadOnGc(loadSdk, notify) {
         }
     };
 }
+function noop() { }

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

@@ -1,21 +1,26 @@
 import { audioGenModelByName, curatedModelAsset, customModelSrc } from './model-catalog.js';
 export async function resolveModelSrc(sdk, model, addon = 'llm') {
-    if (/^(\/|~|\.|file:|https?:|registry:|pear:|hyper:)/.test(model))
+    if (/^(\/|~|\.|file:|https?:|registry:|pear:|hyper:)/.test(model)) {
         return model;
+    }
     const custom = customModelSrc(model, addon);
-    if (custom)
+    if (custom) {
         return custom;
+    }
     if (addon === 'audiogen') {
         const audio = audioGenModelByName(model);
-        if (!audio)
+        if (!audio) {
             throw new Error(`audiogen model not found: ${model}`);
+        }
         return audio.src;
     }
     const asset = curatedModelAsset(model, addon);
-    if (asset)
+    if (asset) {
         return asset;
+    }
     const [entry] = await sdk.modelRegistrySearch({ filter: model, addon });
-    if (!entry)
+    if (!entry) {
         throw new Error(`model not found in registry: ${model} (addon=${addon})`);
+    }
     return { ...entry, src: `registry://${entry.registrySource}/${entry.registryPath}` };
 }

package/dist-lib/lib/models/music-catalog.d.ts

@@ -2,11 +2,11 @@ export declare const MUSIC_MODEL_CHOICES: readonly ['turbo', 'turbo-hq', 'sft'];
 export type MusicModelChoice = (typeof MUSIC_MODEL_CHOICES)[number];
 export declare const GENERATE_MUSIC_TOOL = "generate_music";
 export declare const DEFAULT_MUSIC_MODEL_CHOICE: MusicModelChoice;
-export type MusicChoiceEntry = {
+export interface MusicChoiceEntry {
     readonly choice: MusicModelChoice;
     readonly label: string;
     readonly sizeBytesApprox: number;
     readonly requiresGpu: boolean;
     readonly notes: string;
-};
+}
 export declare const MUSIC_CHOICE_CATALOG: ReadonlyArray<MusicChoiceEntry>;

package/dist-lib/lib/models/nmt-catalog.d.ts

@@ -28,7 +28,8 @@ export interface SlmPlan {
     model: string;
 }
 export type TranslationPlan = NmtPlan | SlmPlan;
-export declare function sameLanguage(from: string, to: string): boolean;
-export declare function translationPlanFor(requestedFrom: string, requestedTo: string): TranslationPlan | {
+export interface TranslationRefusal {
     error: string;
-};
+}
+export declare function sameLanguage(from: string, to: string): boolean;
+export declare function translationPlanFor(requestedFrom: string, requestedTo: string): TranslationPlan | TranslationRefusal;

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

@@ -115,8 +115,9 @@ function canonical(code) {
 export function translationPlanFor(requestedFrom, requestedTo) {
     const from = requestedFrom.toLowerCase();
     const to = requestedTo.toLowerCase();
-    if (sameLanguage(from, to))
+    if (sameLanguage(from, to)) {
         return { error: `${from} is already the target language` };
+    }
     const slmFrom = slmLanguage(from);
     const slmTo = slmLanguage(to);
     if (slmFrom || slmTo) {
@@ -146,16 +147,20 @@ export function translationPlanFor(requestedFrom, requestedTo) {
         };
     }
     if (to === ENGLISH) {
-        if (!TO_ENGLISH.includes(from))
+        if (!TO_ENGLISH.includes(from)) {
             return { error: `cannot translate from ${from}` };
+        }
         return { route: 'nmt', from, to, model: modelFilter(`${from}${ENGLISH}`) };
     }
-    if (!FROM_ENGLISH.includes(to))
+    if (!FROM_ENGLISH.includes(to)) {
         return { error: `cannot translate to ${to}` };
-    if (from === ENGLISH)
+    }
+    if (from === ENGLISH) {
         return { route: 'nmt', from, to, model: modelFilter(`${ENGLISH}${to}`) };
-    if (!TO_ENGLISH.includes(from))
+    }
+    if (!TO_ENGLISH.includes(from)) {
         return { error: `cannot translate from ${from}` };
+    }
     return {
         route: 'nmt',
         from,

package/dist-lib/lib/models/opencl-cache.d.ts

@@ -2,4 +2,9 @@ export declare const OPENCL_CACHE_MAX_AGE_MS: number;
 export declare function openclEngineKey(sdkVersion?: string): string;
 export declare function openclCacheRoot(env?: Record<string, string | undefined>, hostPlatform?: string): string | undefined;
 export declare function openclCacheDir(env?: Record<string, string | undefined>, hostPlatform?: string, sdkVersion?: string): string | undefined;
-export declare function prepareOpenclCache(env?: Record<string, string | undefined>, hostPlatform?: string, sdkVersion?: string, now?: number): void;
+export interface PrepareOpenclCacheOptions {
+    hostPlatform?: string;
+    sdkVersion?: string | undefined;
+    now?: number;
+}
+export declare function prepareOpenclCache(env?: Record<string, string | undefined>, { hostPlatform, sdkVersion, now }?: PrepareOpenclCacheOptions): void;

package/dist-lib/lib/models/opencl-cache.js

@@ -13,18 +13,20 @@ export function openclCacheRoot(env = process.env, hostPlatform = platform()) {
     if (hostPlatform !== 'android')
         return undefined;
     const dir = env[OPENCL_CACHE_DIR_ENV];
-    if (!dir?.startsWith('/'))
+    if (!dir?.startsWith('/')) {
         return undefined;
+    }
     return dir.split('/').includes('..') ? undefined : dir;
 }
 export function openclCacheDir(env = process.env, hostPlatform = platform(), sdkVersion) {
     const root = openclCacheRoot(env, hostPlatform);
     return root === undefined ? undefined : path.join(root, openclEngineKey(sdkVersion));
 }
-export function prepareOpenclCache(env = process.env, hostPlatform = platform(), sdkVersion, now = Date.now()) {
+export function prepareOpenclCache(env = process.env, { hostPlatform = platform(), sdkVersion, now = Date.now() } = {}) {
     const root = openclCacheRoot(env, hostPlatform);
-    if (root === undefined)
+    if (root === undefined) {
         return;
+    }
     const key = openclEngineKey(sdkVersion);
     try {
         fs.mkdirSync(path.join(root, key), { recursive: true });

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

@@ -3,19 +3,22 @@ export declare function isSdkGpuDeviceLostError(err: unknown): boolean;
 export declare function isSdkModelWedgedError(err: unknown): boolean;
 export declare function isContextOverflowError(err: unknown): boolean;
 export type GpuFaultDecision = 'reload' | 'fallback';
-export declare function createGpuFaultEscalation(): {
+interface GpuFaultEscalation {
     recordFault(onGpu: boolean): GpuFaultDecision;
     reset(): void;
-};
-export type GpuFaultState = ReturnType<typeof createGpuFaultState>;
-export declare function createGpuFaultState({ device, gpuLayers }?: {
-    device?: EmbedDevice;
-    gpuLayers?: number;
-}): {
+}
+export declare function createGpuFaultEscalation(): GpuFaultEscalation;
+export interface GpuFaultState {
     readonly device: EmbedDevice;
     readonly generation: number;
     gpuLayers(): number;
     key(model: string): string;
     recordFault(bornAt: number): void;
     reset(): void;
-};
+}
+export interface GpuFaultStateOptions {
+    device?: EmbedDevice;
+    gpuLayers?: number;
+}
+export declare function createGpuFaultState({ device, gpuLayers }?: GpuFaultStateOptions): GpuFaultState;
+export {};

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

@@ -1,23 +1,25 @@
 export function isSdkGpuDeviceLostError(err) {
     if (typeof err !== 'object' || err === null)
         return false;
-    const message = err.message;
-    if (typeof message !== 'string')
+    const message = 'message' in err ? err.message : undefined;
+    if (typeof message !== 'string') {
         return false;
+    }
     return /ErrorDeviceLost/i.test(message) || /VK_ERROR_DEVICE_LOST/i.test(message);
 }
 export function isSdkModelWedgedError(err) {
     if (typeof err !== 'object' || err === null)
         return false;
-    const message = err.message;
-    if (typeof message !== 'string')
+    const message = 'message' in err ? err.message : undefined;
+    if (typeof message !== 'string') {
         return false;
+    }
     return /failed to (decode next token|eval chunk)/i.test(message);
 }
 export function isContextOverflowError(err) {
     if (typeof err !== 'object' || err === null)
         return false;
-    return err.name === 'CONTEXT_OVERFLOW';
+    return 'name' in err && err.name === 'CONTEXT_OVERFLOW';
 }
 export function createGpuFaultEscalation() {
     let count = 0;
@@ -56,8 +58,9 @@ export function createGpuFaultState({ device, gpuLayers } = {}) {
                 return;
             lastFaulted = bornAt;
             generation += 1;
-            if (escalation.recordFault(current === 'gpu') === 'fallback')
+            if (escalation.recordFault(current === 'gpu') === 'fallback') {
                 current = 'cpu';
+            }
         },
         reset() {
             escalation.reset();

package/dist-lib/lib/models/shards.d.ts

@@ -0,0 +1,11 @@
+export interface Shard {
+    readonly url: string;
+    readonly filename: string;
+}
+export interface ShardSet {
+    readonly base: string;
+    readonly baseUrl: string;
+    readonly extension: string;
+    readonly shards: ReadonlyArray<Shard>;
+}
+export declare function shardSet(src: string): ShardSet | null;

package/dist-lib/lib/models/shards.js

@@ -0,0 +1,15 @@
+const SHARD = /^(.+)-(\d{5})-of-(\d{5})(\.\w+)$/;
+export function shardSet(src) {
+    const parts = src.split('/');
+    const match = SHARD.exec(parts[parts.length - 1]?.split('?')[0] ?? '');
+    if (!match) {
+        return null;
+    }
+    const [, base, , total, extension] = match;
+    const baseUrl = parts.slice(0, -1).join('/');
+    const shards = Array.from({ length: Number(total) }, (_, i) => {
+        const filename = `${base}-${String(i + 1).padStart(5, '0')}-of-${total}${extension}`;
+        return { url: `${baseUrl}/${filename}`, filename };
+    });
+    return { base, baseUrl, extension, shards };
+}

package/dist-lib/lib/models/tool-dialect.js

@@ -5,15 +5,20 @@ export function detectToolDialect(src, name) {
         .filter(Boolean)
         .pop() ?? '';
     const tag = `${(name ?? '').toLowerCase()}|${basename}`;
-    if (/qwen3[._-]?[56](?![a-z0-9])/.test(tag))
+    if (/qwen3[._-]?[56](?![a-z0-9])/.test(tag)) {
         return 'qwen35';
-    if (/gemma[-_]?4(?=[^a-z0-9]|$)/.test(tag))
+    }
+    if (/gemma[-_]?4(?=[^a-z0-9]|$)/.test(tag)) {
         return 'gemma4';
-    if (/gpt[_-]?oss/.test(tag))
+    }
+    if (/gpt[_-]?oss/.test(tag)) {
         return 'harmony';
-    if (/deepseek[-_. ]?v(?:4|3[._-]?2)(?![0-9])/.test(tag))
+    }
+    if (/deepseek[-_. ]?v(?:4|3[._-]?2)(?![0-9])/.test(tag)) {
         return 'dsml';
-    if (/lfm[_-]?\d/.test(tag))
+    }
+    if (/lfm[_-]?\d/.test(tag)) {
         return 'pythonic';
+    }
     return undefined;
 }

package/dist-lib/lib/no-redirect-fetch-bare.d.ts

@@ -1,15 +1,15 @@
 import { type BareLookupAll } from './validating-lookup.ts';
 import { type NoRedirectFetchInit, type NoRedirectFetchResponse } from './no-redirect-fetch-impl.ts';
 export type { NoRedirectFetchResponse };
-export type ConnectionAgent = {
+export interface ConnectionAgent {
     createConnection(opts: {
         readonly host?: string;
     }): unknown;
-};
+}
 export type AgentCtor<A extends ConnectionAgent> = new (opts: object) => A;
 export declare class BlockedHostError extends Error {
     readonly code = "EBLOCKEDHOST";
     constructor(host: string);
 }
 export declare function makeValidatingAgent<A extends ConnectionAgent>(Agent: AgentCtor<A>, lookup: BareLookupAll): A;
-export default function noRedirectFetch(url: URL, init?: NoRedirectFetchInit): Promise<NoRedirectFetchResponse>;
+export declare function noRedirectFetch(url: URL, init?: NoRedirectFetchInit): Promise<NoRedirectFetchResponse>;

package/dist-lib/lib/no-redirect-fetch-bare.js

@@ -35,7 +35,7 @@ const rawAllLookup = (hostname, opts, cb) => {
 const validatingLookup = makeValidatingLookup(rawAllLookup);
 const httpAgent = makeValidatingAgent(HttpAgent, validatingLookup);
 const httpsAgent = makeValidatingAgent(HttpsAgent, validatingLookup);
-export default function noRedirectFetch(url, init = {}) {
+export function noRedirectFetch(url, init = {}) {
     const request = (target, opts, onresponse) => {
         const common = { method: readMethod(opts.method), headers: opts.headers };
         const forward = (res) => onresponse(res);