@qvac/harness 0.4.0 → 0.6.0

package/dist-lib/lib/context-window.js

@@ -5,8 +5,9 @@ function isTurnBoundary(message) {
 }
 export function contextCandidates(history) {
     const { prefix, turns } = splitTurns(history);
-    if (!turns.length)
+    if (!turns.length) {
         return [{ history, droppedTurns: 0 }];
+    }
     const maxDropped = Math.max(0, turns.length - 1);
     const candidates = dropCounts(maxDropped).map((droppedTurns) => ({
         history: droppedTurns ? [...prefix, ...turns.slice(droppedTurns).flat()] : history,
@@ -17,57 +18,60 @@ export function contextCandidates(history) {
 }
 function splitTurns(history) {
     const firstUser = history.findIndex(isTurnBoundary);
-    if (firstUser === -1)
+    if (firstUser === -1) {
         return { prefix: history, turns: [] };
+    }
     const prefix = history.slice(0, firstUser);
     const starts = [];
-    for (let i = firstUser; i < history.length; i++) {
-        if (isTurnBoundary(history[i]))
+    for (const [i, message] of history.entries()) {
+        if (i >= firstUser && isTurnBoundary(message)) {
             starts.push(i);
+        }
     }
     const turns = starts.map((start, index) => history.slice(start, starts[index + 1]));
     return { prefix, turns };
 }
 function dropCounts(max) {
     const counts = [0];
-    for (let step = 1; counts[counts.length - 1] < max; step *= 2) {
+    let last = 0;
+    for (let step = 1; last < max; step *= 2) {
         const next = Math.min(max, step);
-        if (next !== counts[counts.length - 1])
-            counts.push(next);
+        if (next === last) {
+            continue;
+        }
+        counts.push(next);
+        last = next;
     }
     return counts;
 }
 function appendToolCompactions(candidates) {
     const last = candidates[candidates.length - 1];
-    if (!last)
+    if (!last) {
         return;
+    }
     const tools = compactableTools(last.history);
     let history = last.history;
     while (true) {
         const selected = longestTool(tools);
-        if (!selected)
+        if (!selected) {
             return;
+        }
         selected.target = Math.max(TOOL_RESULT_TRUNCATION_MARKER.length, Math.floor(selected.target / 2));
         history = history.map(compactTool.bind(null, selected));
         candidates.push({ history, droppedTurns: last.droppedTurns });
     }
 }
 function compactableTools(history) {
-    let newestUser = -1;
-    for (let index = history.length - 1; index >= 0; index--) {
-        if (!isTurnBoundary(history[index]))
-            continue;
-        newestUser = index;
-        break;
-    }
-    if (newestUser === -1)
+    const newestUser = history.findLastIndex(isTurnBoundary);
+    if (newestUser === -1) {
         return [];
+    }
     const tools = [];
-    for (let index = newestUser + 1; index < history.length; index++) {
-        const message = history[index];
-        if (message.role !== 'tool' || message.content.length <= TOOL_RESULT_TRUNCATION_MARKER.length) {
+    for (const [index, message] of history.entries()) {
+        if (index <= newestUser || message.role !== 'tool')
+            continue;
+        if (message.content.length <= TOOL_RESULT_TRUNCATION_MARKER.length)
             continue;
-        }
         tools.push({ index, original: message.content, target: message.content.length });
     }
     return tools;

package/dist-lib/lib/contract-types.d.ts

@@ -113,6 +113,17 @@ export interface WarmModelContext {
     agent?: AgentKnobs;
     signal?: CompletionContext['signal'];
 }
+export type LoadModelContext = WarmModelContext;
+export interface LoadModelResult {
+    loaded: boolean;
+    reason?: 'memory';
+}
+export interface UnloadModelContext {
+    model: string;
+}
+export interface UnloadModelResult {
+    unloaded: boolean;
+}
 export interface DownloadContext {
     model: string;
     addon?: string;
@@ -165,6 +176,24 @@ export interface CapabilityInfo {
     recommendedModelName: string;
     memoryBudget?: MemoryBudget;
 }
+export interface CredentialEntry {
+    key: string;
+    token?: string | null;
+    expiresAt?: number | null;
+    agentId?: string | null;
+    skill?: string | null;
+}
+export interface SkillsOptions {
+    readonly refresh?: boolean;
+    readonly skipCredentialProbe?: boolean;
+}
+export interface SkillWriteResult {
+    ok: boolean;
+}
+export interface InfraModel {
+    name: string;
+    addon: string;
+}
 export interface HarnessContract {
     completion(context: CompletionContext): AsyncIterable<HarnessEvent>;
     invoke?(context: InvokeContext): AsyncIterable<HarnessEvent>;
@@ -183,24 +212,16 @@ export interface HarnessContract {
     suspend?(): Promise<void> | void;
     wakeup?(): Promise<void> | void;
     resume?(): Promise<void> | void;
-    skills?(agentId?: string | null, modelName?: string | null, options?: {
-        readonly refresh?: boolean;
-        readonly skipCredentialProbe?: boolean;
-    }): Promise<ResolvedSkillCatalogEntry[]>;
+    skills?(agentId?: string | null, modelName?: string | null, options?: SkillsOptions): Promise<ResolvedSkillCatalogEntry[]>;
     tools?(): Promise<ToolCatalogEntry[]>;
-    setCredentials?(entries: ReadonlyArray<{
-        key: string;
-        token?: string | null;
-        expiresAt?: number | null;
-        agentId?: string | null;
-        skill?: string | null;
-    }>): void | Promise<void>;
+    setCredentials?(entries: ReadonlyArray<CredentialEntry>): void | Promise<void>;
     setSkillSettings?(entries: ReadonlyArray<{
         skill: string;
         key: string;
         value: string;
         agentId?: string | null;
     }>): void | Promise<void>;
+    setModelIdleTimeout?(ms: number): void | Promise<void>;
     listManagedSkills?(): Promise<ManagedSkill[]>;
     readSkillFile?(name: string): Promise<SkillFileContent | null>;
     writeSkillFile?(name: string, content: string): Promise<{
@@ -214,13 +235,12 @@ export interface HarnessContract {
     }>;
     list?(options?: ListModelsOptions): Promise<ModelInfo[]>;
     warmModel?(context: WarmModelContext): Promise<void>;
+    loadModel?(context: LoadModelContext): Promise<LoadModelResult>;
+    unloadModel?(context: UnloadModelContext): Promise<UnloadModelResult>;
     deleteModel?(name: string): Promise<DeleteModelSummary>;
     clearKvCache?(): Promise<KvCacheDeletionResult>;
     deleteKvCache?(kvCacheKey: string): Promise<KvCacheDeletionResult>;
-    infraModels?(profile: string): Promise<ReadonlyArray<{
-        name: string;
-        addon: string;
-    }>>;
+    infraModels?(profile: string): Promise<ReadonlyArray<InfraModel>>;
     setCustomModels?(entries: ReadonlyArray<CustomModelEntry>): void | Promise<void>;
     previewModelSource?(context: PreviewModelSourceContext): Promise<ModelSourcePreview>;
     capability?(): Promise<CapabilityInfo>;

package/dist-lib/lib/diagram-repair.d.ts

@@ -4,18 +4,18 @@ export declare function diagramRepairPromptCount(content: string, parentRunId?:
 export declare function isDiagramRepairPrompt(content: string): boolean;
 export declare function completeMermaidDiagramCount(content: string): number;
 export declare function diagramRepairAccepted(text: string): boolean;
-type DiagramRepairRecord = {
+interface DiagramRepairRecord {
     readonly id: string;
     readonly seq: number;
     readonly runId?: string | null;
     readonly parentId?: string | null;
-};
-export type DiagramRepairLink = {
+}
+export interface DiagramRepairLink {
     readonly expectedCount: number;
     readonly parentId: string;
     readonly promptId: string;
     readonly promptText: string;
     readonly runId: string;
-};
+}
 export declare function diagramRepairLinks<T extends DiagramRepairRecord>(records: ReadonlyArray<T>, textOf: (record: T) => string | null): ReadonlyArray<DiagramRepairLink>;
 export {};

package/dist-lib/lib/diagram-repair.js

@@ -3,8 +3,9 @@ export const DIAGRAM_REPAIR_PROMPT_SUFFIX = 'Rewrite the complete previous answe
     'Common fixes: put every label with spaces or punctuation in double quotes like A["Send (HTTP)"]; never use lowercase end as a node label - write "End"; the first line inside the fence must be the diagram type; close the fence before any prose - never leave a sentence inside it; give every node a unique id.';
 export function diagramRepairPromptCount(content, parentRunId) {
     const match = /^<!-- qvac:diagram-repair:(\d+):([^\s>]+) -->\n(\d+) Mermaid diagram(?:s)? in your previous answer fail(?:s)? to render\.\n/.exec(content);
-    if (!match || !content.endsWith(`\n\n${DIAGRAM_REPAIR_PROMPT_SUFFIX}`))
+    if (!match || !content.endsWith(`\n\n${DIAGRAM_REPAIR_PROMPT_SUFFIX}`)) {
         return null;
+    }
     const expected = Number(match[1]);
     return Number.isSafeInteger(expected) &&
         expected > 0 &&
@@ -31,8 +32,9 @@ export function diagramRepairLinks(records, textOf) {
         if (!child.runId || !child.parentId)
             return [];
         const parent = byId.get(child.parentId);
-        if (!parent?.runId)
+        if (!parent?.runId) {
             return [];
+        }
         const prompt = [...ordered]
             .reverse()
             .find((candidate) => candidate.seq > parent.seq &&
@@ -41,8 +43,9 @@ export function diagramRepairLinks(records, textOf) {
             diagramRepairPromptCount(textOf(candidate) ?? '', parent.runId ?? undefined) !== null);
         const promptText = prompt ? textOf(prompt) : null;
         const expectedCount = diagramRepairPromptCount(promptText ?? '', parent.runId);
-        if (prompt)
+        if (prompt) {
             used.add(prompt.id);
+        }
         return prompt && promptText && expectedCount
             ? [
                 {

package/dist-lib/lib/docx/index.d.ts

@@ -1,5 +1,6 @@
 import type { AbortSignal } from 'bare-abort-controller';
 export { closePythonWorker as closeDocxWorker } from '../tools/exec/adapters/python/worker/client.ts';
-export declare function extractDocxText(bytes: Uint8Array, fileName: string, options?: {
+export interface DocxExtractOptions {
     readonly signal?: AbortSignal;
-}): Promise<string>;
+}
+export declare function extractDocxText(bytes: Uint8Array, fileName: string, options?: DocxExtractOptions): Promise<string>;

package/dist-lib/lib/{error-fields.d.ts → guards.d.ts}

@@ -1,2 +1,3 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function errorMessage(err: unknown): string;
 export declare function errorCode(err: unknown): string | undefined;

package/dist-lib/lib/{error-fields.js → guards.js}

@@ -1,3 +1,6 @@
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
 export function errorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }

package/dist-lib/lib/hardware/capability-probe.js

@@ -13,8 +13,9 @@ function pickTier(availableBytes) {
         return 'xhigh';
     if (availableBytes >= 30 * GIB)
         return 'high';
-    if (availableBytes >= 8 * GIB)
+    if (availableBytes >= 8 * GIB) {
         return 'mid';
+    }
     return 'low';
 }
 function tierProfile(budget) {
@@ -38,8 +39,9 @@ function recommend(budget) {
 async function probeSysfs(reads) {
     for (const path of SYSFS_VRAM_PATHS) {
         const raw = await reads.readFile(path);
-        if (!raw)
+        if (!raw) {
             continue;
+        }
         const bytes = Number.parseInt(raw.trim(), 10);
         if (!Number.isNaN(bytes) && bytes > 0) {
             return { totalBytes: bytes, availableBytes: bytes, source: 'vram' };
@@ -50,25 +52,31 @@ async function probeSysfs(reads) {
 async function probeDesktop(reads) {
     const ram = reads.totalmem();
     const addon = probeWithAddon(await reads.readGpuStats(), ram);
-    if (addon && addon.source === 'vram')
+    if (addon && addon.source === 'vram') {
         return addon;
+    }
     const nvidia = await reads.run('nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits');
     const nvidiaBudget = nvidia ? parseNvidiaSmiOutput(nvidia) : null;
-    if (nvidiaBudget)
+    if (nvidiaBudget) {
         return nvidiaBudget;
+    }
     const rocm = await reads.run('rocm-smi --showmeminfo vram');
     const rocmBudget = rocm ? parseRocmSmiOutput(rocm) : null;
-    if (rocmBudget)
+    if (rocmBudget) {
         return rocmBudget;
+    }
     const sysfs = await probeSysfs(reads);
-    if (sysfs)
+    if (sysfs) {
         return sysfs;
+    }
     const registry = await reads.run(`powershell -Command "${WINDOWS_REGISTRY_QUERY}"`);
     const registryBudget = registry ? parseWindowsRegistryOutput(registry, ram) : null;
-    if (registryBudget)
+    if (registryBudget) {
         return registryBudget;
-    if (addon)
+    }
+    if (addon) {
         return addon;
+    }
     return { ...sharedRamBudget(ram), source: 'no-gpu' };
 }
 async function isPixel(reads) {
@@ -77,10 +85,12 @@ async function isPixel(reads) {
 }
 async function probeMemoryBudget(reads) {
     const os = reads.platform();
-    if (os === 'android' || os === 'ios')
+    if (os === 'android' || os === 'ios') {
         return mobileBudget(reads.totalmem(), await isPixel(reads));
-    if (os === 'darwin')
+    }
+    if (os === 'darwin') {
         return sharedRamBudget(reads.totalmem());
+    }
     return probeDesktop(reads);
 }
 function forcedProfile() {

package/dist-lib/lib/hardware/gpu-classify.js

@@ -19,14 +19,17 @@ const INTEGRATED_GPU = [
 ];
 const SOFTWARE_GPU = [/llvmpipe/i, /swrast/i, /mesa/i];
 export function classifyGpu(name) {
-    for (const re of DISCRETE_GPU)
+    for (const re of DISCRETE_GPU) {
         if (re.test(name))
             return 'discrete';
-    for (const re of INTEGRATED_GPU)
+    }
+    for (const re of INTEGRATED_GPU) {
         if (re.test(name))
             return 'integrated';
-    for (const re of SOFTWARE_GPU)
+    }
+    for (const re of SOFTWARE_GPU) {
         if (re.test(name))
             return 'software';
+    }
     return 'integrated';
 }

package/dist-lib/lib/hardware/gpu-probe-addon.js

@@ -12,8 +12,9 @@ const StatsSchema = z.object({
 function classifyBestDevice(devices, systemRamBytes) {
     for (const device of devices) {
         const cls = classifyGpu(device.name);
-        if (cls === 'software')
+        if (cls === 'software') {
             continue;
+        }
         if (cls === 'discrete') {
             const vram = device.videoMemoryBytes;
             if (vram > systemRamBytes * IGPU_LIE_THRESHOLD) {
@@ -26,15 +27,18 @@ function classifyBestDevice(devices, systemRamBytes) {
 }
 export function probeWithAddon(rawStats, systemRamBytes) {
     const parsed = StatsSchema.safeParse(rawStats);
-    if (!parsed.success)
+    if (!parsed.success) {
         return null;
+    }
     const devices = parsed.data.gpu?.devices ?? [];
-    if (devices.length === 0)
+    if (devices.length === 0) {
         return null;
+    }
     const totalRamBytes = parsed.data.memory?.totalBytes ?? systemRamBytes;
     const best = classifyBestDevice(devices, totalRamBytes);
-    if (best)
+    if (best) {
         return best;
+    }
     if (devices.every((device) => classifyGpu(device.name) === 'software')) {
         return { ...sharedRamBudget(totalRamBytes), source: 'software' };
     }

package/dist-lib/lib/hardware/gpu-probe.js

@@ -1,3 +1,4 @@
+import b4a from 'b4a';
 import { spawn } from 'child_process';
 import os from 'os';
 import { readSystemStats } from '#hw-gpu-stats';
@@ -11,8 +12,9 @@ export function runGpuProbeIfRequested() {
 }
 export function parseGpuProbeOutput(output) {
     const line = output.trim().split('\n').at(-1) ?? '';
-    if (line.length === 0)
+    if (line.length === 0) {
         return null;
+    }
     try {
         const parsed = JSON.parse(line);
         return typeof parsed === 'object' ? parsed : null;
@@ -32,7 +34,7 @@ export function spawnGpuProbe(entry = Bare.argv[1]) {
             resolve({ ok: false, stats: null });
         }, TIMEOUT_MS);
         child.stdout?.on('data', (chunk) => {
-            output += Buffer.from(chunk).toString();
+            output += b4a.toString(chunk);
         });
         child.stderr?.on('data', () => { });
         child.on('error', () => {

package/dist-lib/lib/hardware/gpu-stats.native.cjs

@@ -1,22 +1,21 @@
 const os = require('os')
 
-// loaded on first read: the addon drags the graphics stack (and on Linux a
-// second LLVM) into whichever process imports it
+// lazy: the addon drags the graphics stack (and on Linux a second LLVM) into its importer
 let GPUInfo
 
-// Shaped for probeWithAddon (gpu-probe-addon.ts): the probe only wants each
-// device's name and VRAM total, plus system RAM to catch integrated-GPU lies.
+// system RAM is here to catch integrated-GPU lies
 exports.readSystemStats = function readSystemStats() {
   try {
     GPUInfo ??= require('bare-gpu-info')
     const info = new GPUInfo()
     try {
-      const devices = []
-      for (const gpu of info) {
-        if (typeof gpu.memory !== 'number' || !gpu.name) continue
-        devices.push({ name: gpu.name, videoMemoryBytes: gpu.memory })
+      const devices = [...info]
+        .filter((gpu) => typeof gpu.memory === 'number' && gpu.name)
+        .map((gpu) => ({ name: gpu.name, videoMemoryBytes: gpu.memory }))
+      if (devices.length === 0) {
+        return null
       }
-      if (devices.length === 0) return null
+
       return { memory: { totalBytes: os.totalmem() }, gpu: { devices } }
     } finally {
       info.destroy()

package/dist-lib/lib/hardware/parsers.js

@@ -7,25 +7,29 @@ export const IGPU_LIE_THRESHOLD = 0.9;
 export function parseNvidiaSmiOutput(stdout) {
     const firstLine = stdout.split('\n')[0] ?? '';
     const mib = Number.parseInt(firstLine, 10);
-    if (Number.isNaN(mib) || mib <= 0)
+    if (Number.isNaN(mib) || mib <= 0) {
         return null;
+    }
     const bytes = mib * 1024 * 1024;
     return { totalBytes: bytes, availableBytes: bytes, source: 'vram', gpuClass: 'discrete' };
 }
 export function parseRocmSmiOutput(stdout) {
     const match = /Total.*?:\s*(\d+)/i.exec(stdout);
-    if (!match)
+    if (!match) {
         return null;
+    }
     const bytes = Number.parseInt(match[1] ?? '', 10);
-    if (Number.isNaN(bytes) || bytes <= 0)
+    if (Number.isNaN(bytes) || bytes <= 0) {
         return null;
+    }
     return { totalBytes: bytes, availableBytes: bytes, source: 'vram' };
 }
 export function parseWindowsRegistryOutput(stdout, systemRamBytes) {
     const firstLine = stdout.split('\n')[0] ?? '';
     const bytes = Number.parseInt(firstLine, 10);
-    if (Number.isNaN(bytes) || bytes <= 0)
+    if (Number.isNaN(bytes) || bytes <= 0) {
         return null;
+    }
     if (bytes > systemRamBytes * IGPU_LIE_THRESHOLD) {
         return { ...sharedRamBudget(systemRamBytes), source: 'integrated' };
     }

package/dist-lib/lib/helpers/buffer-burst.js

@@ -7,14 +7,16 @@ export async function* bufferBurst(tokens, ms) {
             continue;
         }
         if (Date.now() >= deadline) {
-            if (burst)
+            if (burst) {
                 yield burst;
+            }
             burst = null;
             yield token;
             continue;
         }
         burst += token;
     }
-    if (burst)
+    if (burst) {
         yield burst;
+    }
 }

package/dist-lib/lib/helpers/control-tokens.js

@@ -19,14 +19,16 @@ export async function* stopAtControlToken(tokens, onStop) {
     const safe = scanner({ stop: STOP_MARKERS });
     for await (const token of tokens) {
         const shown = safe.push(token);
-        if (shown)
+        if (shown) {
             yield shown;
+        }
         if (safe.stopped !== null) {
             onStop?.(safe.stopped);
             return;
         }
     }
     const rest = safe.flush();
-    if (rest)
+    if (rest) {
         yield rest;
+    }
 }

package/dist-lib/lib/helpers/join-guard.d.ts

@@ -1,6 +1,6 @@
-export type JoinGuard = {
+export interface JoinGuard {
     readonly push: (text: string) => string;
     readonly cut: () => void;
     readonly flush: () => string;
-};
+}
 export declare function createJoinGuard(markers: readonly string[]): JoinGuard;

package/dist-lib/lib/helpers/join-guard.js

@@ -30,8 +30,9 @@ export function createJoinGuard(markers) {
 function mend(text, at, markers) {
     for (;;) {
         const found = spanning(text, at, markers);
-        if (found === null)
+        if (found === null) {
             return { text, at };
+        }
         text = text.slice(0, found.index) + text.slice(found.index + found.marker.length);
         at = found.index;
     }
@@ -39,8 +40,9 @@ function mend(text, at, markers) {
 function spanning(text, at, markers) {
     for (const marker of markers) {
         const index = text.indexOf(marker, Math.max(0, at - marker.length + 1));
-        if (index !== -1 && index < at)
+        if (index !== -1 && index < at) {
             return { index, marker };
+        }
     }
     return null;
 }

package/dist-lib/lib/helpers/load-stall.js

@@ -5,8 +5,9 @@ export function createLoadStall(ms, message) {
         rejectStall = reject;
     });
     const arm = () => {
-        if (timer !== null)
+        if (timer !== null) {
             clearTimeout(timer);
+        }
         timer = setTimeout(() => {
             rejectStall?.(new Error(message));
         }, ms);
@@ -15,8 +16,9 @@ export function createLoadStall(ms, message) {
     return {
         bump: arm,
         clear: () => {
-            if (timer !== null)
+            if (timer !== null) {
                 clearTimeout(timer);
+            }
             timer = null;
         },
         promise

package/dist-lib/lib/helpers/markup-stream-filter.d.ts

@@ -1,5 +1,5 @@
-export type MarkupStreamFilter = {
+export interface MarkupStreamFilter {
     readonly push: (token: string) => string;
     readonly flush: () => string;
-};
+}
 export declare function createMarkupStreamFilter(): MarkupStreamFilter;

package/dist-lib/lib/helpers/markup-stream-filter.js

@@ -22,8 +22,9 @@ export function createMarkupStreamFilter() {
             for (;;) {
                 const step = state.closer ? consumeSuppressed(state) : emitUntilOpener(state);
                 out += step.out;
-                if (step.done)
+                if (step.done) {
                     return out;
+                }
             }
         },
         flush() {
@@ -52,8 +53,9 @@ function dropResumeNewline(state) {
     if (!state.stripNewline || state.buffer.length === 0)
         return;
     state.stripNewline = false;
-    if (state.buffer[0] === '\n')
+    if (state.buffer[0] === '\n') {
         state.buffer = state.buffer.slice(1);
+    }
 }
 function emitUntilOpener(state) {
     dropResumeNewline(state);
@@ -63,8 +65,9 @@ function emitUntilOpener(state) {
         state.guard.cut();
         state.buffer = state.buffer.slice(marker.index + marker.marker.length);
         const closer = MARKUP_CLOSERS[marker.marker];
-        if (closer === undefined)
+        if (closer === undefined) {
             state.stripNewline = true;
+        }
         state.closer = closer ?? null;
         return { out, done: false };
     }

package/dist-lib/lib/helpers/race-abort.js

@@ -8,8 +8,9 @@ export class AbortedError extends Error {
 export function raceAbort(promise, signal) {
     if (!signal)
         return promise;
-    if (signal.aborted)
+    if (signal.aborted) {
         return Promise.reject(new AbortedError());
+    }
     return new Promise((resolve, reject) => {
         const onAbort = () => reject(new AbortedError());
         signal.addEventListener('abort', onAbort, { once: true });

package/dist-lib/lib/helpers/race-timeout.d.ts

@@ -0,0 +1,5 @@
+export interface RaceTimeoutOptions<T> {
+    ms: number;
+    fallback: T;
+}
+export declare function raceTimeout<T>(pending: Promise<T>, { ms, fallback }: RaceTimeoutOptions<T>): Promise<T>;

package/dist-lib/lib/helpers/race-timeout.js

@@ -0,0 +1,14 @@
+export async function raceTimeout(pending, { ms, fallback }) {
+    let timer = null;
+    const expired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(fallback), ms);
+    });
+    try {
+        return await Promise.race([pending, expired]);
+    }
+    finally {
+        if (timer !== null) {
+            clearTimeout(timer);
+        }
+    }
+}