@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

package/dist-lib/lib/residency/index.js

@@ -0,0 +1,539 @@
+import { errorMessage } from '../guards.js';
+import { AbortedError, raceAbort } from '../helpers/race-abort.js';
+import { hlog } from '../log.js';
+import { resolveMainGpu } from '../models/gpu-selection.js';
+import { createIdleReaper } from '../models/idle-unload.js';
+import { curatedListables, curatedModelAsset, modelAddonOf } from '../models/model-catalog.js';
+import { ModelFit } from '../models/model-fit.js';
+import { createModelStatusCache, invalidateModelStatusCache } from '../models/model-list.js';
+import { awaitModelCapacity, contextSize, slotCount, createModelPool, evictIdle, evictIdleWhere, evictModel, evictModelWithin, isResident, leaseCount, loadedModels, loadingModels, modelKey, modelOf, releaseModel, resolveLoadOptions, settledModels } from '../models/model-pool.js';
+import { openclCacheDir } from '../models/opencl-cache.js';
+import { prepareCompletionRuntime } from './completion-runtime.js';
+const PLUGIN_EVICT_WAIT_MS = 15_000;
+const WEDGED_EVICT_WAIT_MS = 10_000;
+const MODEL_ROOM_WAIT_MS = 300_000;
+const WARM_ROOM_WAIT_MS = 2_000;
+const LOAD_BUSY_MESSAGE = 'the chat model is busy; load this model once the current reply finishes';
+const UNLOAD_LEASE_WAIT_MS = 10_000;
+const DEFAULT_COMPLETION_MODEL_CAP = 1;
+const WEDGED_EVICT_LEASED_MS = 120_000;
+export class Residency {
+    gate;
+    sdk;
+    fit = new ModelFit(async (input) => (await this.sdk.load()).assessModelFit(input));
+    _loads;
+    _emit;
+    _projectionFor;
+    _otherPools;
+    _poolFor;
+    _embedRoom;
+    _evictIdle;
+    _unloadIdlePlugins;
+    _tools;
+    _skills;
+    _pinned = new Set();
+    _borrowed = new Set();
+    _replying = [];
+    _modelStatus = createModelStatusCache();
+    _llmDevice;
+    _llmGpuLayers;
+    _contextSize;
+    _kvCacheK;
+    _kvCacheV;
+    _llmLoad;
+    _slots;
+    _completionModelCap;
+    _modelFaults = new Map();
+    _idle;
+    _models;
+    constructor(opts) {
+        this.gate = opts.gate;
+        this.sdk = opts.sdk;
+        this._loads = opts.loads;
+        this._emit = opts.emit;
+        this._projectionFor = opts.projectionFor;
+        this._otherPools = opts.pools;
+        this._poolFor = opts.poolFor;
+        this._embedRoom = opts.embedRoom;
+        this._evictIdle = opts.evictIdle;
+        this._unloadIdlePlugins = opts.unloadIdlePlugins;
+        this._tools = opts.tools;
+        this._skills = opts.skills;
+        this._llmDevice = opts.llmDevice;
+        this._llmGpuLayers = opts.llmGpuLayers;
+        this._contextSize = opts.contextSize;
+        this._kvCacheK = opts.kvCacheK;
+        this._kvCacheV = opts.kvCacheV;
+        this._llmLoad = opts.llmLoad;
+        this._slots = opts.slots;
+        this._completionModelCap = opts.completionModelCap ?? DEFAULT_COMPLETION_MODEL_CAP;
+        this._models = this._createPool();
+        this._idle = createIdleReaper({
+            sweep: () => this._unloadIdleModels(),
+            waitMs: WEDGED_EVICT_WAIT_MS,
+            onError: (err) => hlog('idle unload failed', { err: errorMessage(err) })
+        });
+    }
+    get pool() {
+        return this._models;
+    }
+    get status() {
+        return this._modelStatus;
+    }
+    tools() {
+        return this._tools();
+    }
+    skills(agentId, model) {
+        return this._skills(agentId, model);
+    }
+    recreate() {
+        this.fit.clearRows();
+        this._models = this._createPool();
+    }
+    destroy() {
+        return this._models?.destroy();
+    }
+    setIdleTimeout(ms) {
+        this._idle.configure(ms);
+    }
+    closeIdle() {
+        this._idle.close();
+    }
+    invalidateStatus() {
+        invalidateModelStatusCache(this._modelStatus);
+    }
+    statusChanged() {
+        invalidateModelStatusCache(this._modelStatus);
+        this.fit.clearRows();
+    }
+    async makeRoomForPlugin(signal, busyMessage) {
+        if (!(await this._roomForPlugin(signal, PLUGIN_EVICT_WAIT_MS))) {
+            throw new Error(busyMessage);
+        }
+    }
+    async _roomForPlugin(signal, deadlineMs) {
+        if (this._models.destroyed)
+            return true;
+        const evicted = await awaitModelCapacity(this._models, { cap: 1, deadlineMs, signal });
+        if (signal?.aborted) {
+            throw new AbortedError();
+        }
+        return evicted;
+    }
+    async borrow(model, signal) {
+        this._borrowed.add(model);
+        const loadOpts = resolveLoadOptions({}, this.deviceConfig());
+        const key = modelKey(model, loadOpts);
+        const pool = this._models;
+        if (!isResident(pool, key)) {
+            await this.makeRoomForCompletion(model, { loadOpts, signal });
+        }
+        try {
+            const { modelId } = await raceAbort(pool.open(key, model, loadOpts).load(), signal);
+            return { modelId, release: () => releaseModel(pool, key) };
+        }
+        catch (err) {
+            releaseModel(pool, key);
+            throw err;
+        }
+    }
+    borrowed(model) {
+        return this._borrowed.has(model);
+    }
+    evictIdleChat() {
+        return evictIdleWhere(this._models, (key) => !this._pinned.has(key) && !this._replying.includes(key));
+    }
+    reply(key) {
+        this._replying.push(key);
+    }
+    replied(key) {
+        this._replying.splice(this._replying.indexOf(key), 1);
+    }
+    clearFaults(model) {
+        this._modelFaults.delete(model);
+    }
+    loaded() {
+        return this._pools().flatMap((pool) => loadedModels(pool));
+    }
+    loading() {
+        return new Set(this._pools().flatMap((pool) => loadingModels(pool)));
+    }
+    settled() {
+        return new Set(this._pools().flatMap((pool) => settledModels(pool)));
+    }
+    _pools() {
+        return [this._models, ...this._otherPools()];
+    }
+    deviceConfig() {
+        return {
+            device: this._llmDevice,
+            gpuLayers: this._llmGpuLayers,
+            contextSize: this._contextSize,
+            kvCacheK: this._kvCacheK,
+            kvCacheV: this._kvCacheV,
+            llama: this._llmLoad,
+            slots: this._slots,
+            mainGpu: resolveMainGpu,
+            openclCacheDir,
+            contextFor: (key) => this.fit.chosen(key),
+            slotsFor: (key) => this.fit.chosenSlots(key)
+        };
+    }
+    _createPool() {
+        const loadSdk = () => this.loadLifecycleSdk();
+        return createModelPool(loadSdk, (state) => this.notify(state), {
+            deviceConfig: this.deviceConfig(),
+            loads: this._loads,
+            onUnloadFailure: (modelId, error) => this.gate.recordModelUnloadFailure(modelId, error)
+        });
+    }
+    loadLifecycleSdk() {
+        return this.sdk.load();
+    }
+    notify(state) {
+        if (state.status === 'ready' || state.status === 'unloaded' || state.status === 'error') {
+            invalidateModelStatusCache(this._modelStatus);
+            this.fit.clearRows();
+        }
+        if (state.status === 'unloaded') {
+            for (const key of this._pinned) {
+                if (!isResident(this._models, key)) {
+                    this._pinned.delete(key);
+                }
+            }
+        }
+        this._emit({
+            ...state,
+            catalogChanged: state.catalogChanged === true,
+            loaded: this.loaded()
+        });
+    }
+    async _unloadIdleModels() {
+        if (!this.gate.opened || this.gate.closing || this.gate.suspended || this.gate.draining) {
+            return;
+        }
+        hlog('idle unload', { models: this.loaded().map((entry) => entry.model) });
+        const [pools, plugins] = await Promise.all([
+            Promise.allSettled([evictIdle(this._models), ...this._evictIdle()]),
+            this._unloadIdlePlugins()
+        ]);
+        for (const outcome of [...pools, ...plugins]) {
+            if (outcome.status !== 'rejected')
+                continue;
+            hlog('idle unload failed', { err: errorMessage(outcome.reason) });
+        }
+        invalidateModelStatusCache(this._modelStatus);
+        this.fit.clearRows();
+    }
+    async rowFits(rows) {
+        if (!rows.some((row) => row.type === 'llm')) {
+            return new Map();
+        }
+        return this.fit
+            .rows(() => this._rowQueries())
+            .catch((err) => {
+            hlog('fit estimate failed', { rows: rows.length, err: errorMessage(err) });
+            return new Map();
+        });
+    }
+    _rowQueries() {
+        return new Map(curatedListables()
+            .filter((listable) => listable.asset.addon === 'llm')
+            .map(({ name, asset }) => {
+            const load = {
+                opts: this.loadOptions(name),
+                deviceConfig: this.deviceConfig()
+            };
+            return [
+                asset.registryPath,
+                ModelFit.query(asset, contextSize(name, asset, load) * slotCount(name, load))
+            ];
+        }));
+    }
+    async warm({ model, agent, signal }) {
+        if (!this.gate.opened) {
+            await this.gate.ready();
+        }
+        this.gate.assertNotClosing();
+        if (this.gate.suspended) {
+            return;
+        }
+        const target = this._target(model, agent);
+        hlog('warm model', { model, resident: isResident(target.pool, target.key) });
+        await this._loadAndRelease(target, signal, async () => {
+            await this._embedRoom(model, target);
+            if (isResident(target.pool, target.key)) {
+                return true;
+            }
+            if (target.needsRoom) {
+                return this._roomForPlugin(signal, WARM_ROOM_WAIT_MS);
+            }
+            if (!target.loadOpts) {
+                return true;
+            }
+            return this.makeRoomForCompletion(model, {
+                loadOpts: target.loadOpts,
+                signal,
+                deadlineMs: WARM_ROOM_WAIT_MS
+            });
+        });
+    }
+    async load({ model, agent, signal }) {
+        if (!this.gate.opened) {
+            await this.gate.ready();
+        }
+        if (this.gate.suspended) {
+            throw new Error('harness is suspended');
+        }
+        const target = this._target(model, agent);
+        const resident = isResident(target.pool, target.key);
+        hlog('load model', { model, resident });
+        if (!target.loadOpts) {
+            await this._loadAndRelease(target, signal, async () => {
+                await this._embedRoom(model, target);
+                if (target.needsRoom && !isResident(target.pool, target.key)) {
+                    await this.makeRoomForPlugin(signal, LOAD_BUSY_MESSAGE);
+                }
+                return true;
+            });
+            return { loaded: true };
+        }
+        if (!resident) {
+            const choice = await this._loadDecision(model, target.loadOpts);
+            if (choice?.fits === false) {
+                return { loaded: false, reason: 'memory' };
+            }
+            if (choice && !target.loadOpts.ctxSize && !signal?.aborted) {
+                this.fit.keep(target.key, choice);
+            }
+            await evictIdleWhere(this._models, (key) => modelOf(key) === model && !this._replying.includes(key));
+            await this.unloadIdleGenerators();
+        }
+        this._pinned.add(target.key);
+        try {
+            await this._loadAndRelease(target, signal);
+        }
+        catch (err) {
+            this._pinned.delete(target.key);
+            throw err;
+        }
+        return { loaded: true };
+    }
+    async unload({ model }) {
+        if (!this.gate.opened) {
+            await this.gate.ready();
+        }
+        const target = this._target(model);
+        const name = modelOf(target.key);
+        const unloaded = await evictModel(target.pool, name, { deadlineMs: UNLOAD_LEASE_WAIT_MS });
+        hlog('unload model', { model, unloaded });
+        if (unloaded) {
+            for (const key of this._pinned) {
+                if (modelOf(key) === name) {
+                    this._pinned.delete(key);
+                }
+            }
+        }
+        return { unloaded };
+    }
+    async _loadAndRelease({ pool, key, open }, signal, prepare = async () => true) {
+        const lease = await this.acquireLease({ pool, key, open, signal, prepare });
+        lease?.release();
+    }
+    async unloadIdleGenerators() {
+        await this._unloadIdlePlugins();
+    }
+    async _fits(model, loadOpts, { native = false } = {}) {
+        const asset = curatedModelAsset(model, 'llm');
+        if (!asset) {
+            return true;
+        }
+        const load = { opts: loadOpts, deviceConfig: this.deviceConfig() };
+        const contextTokens = contextSize(model, asset, load) * slotCount(model, load);
+        const assessed = await this.fit.settle(ModelFit.query(asset, contextTokens, { native }));
+        return assessed?.verdict !== 'likely-too-large';
+    }
+    async _loadDecision(model, loadOpts) {
+        const asset = curatedModelAsset(model, 'llm');
+        if (!asset) {
+            return null;
+        }
+        const load = { opts: loadOpts, deviceConfig: this.deviceConfig() };
+        const tier = contextSize(model, asset, load);
+        const slots = slotCount(model, load);
+        if (loadOpts.ctxSize || this.fit.chosen(modelKey(model, loadOpts))) {
+            return { ctxSize: tier, slots, fits: await this._fits(model, loadOpts, { native: true }) };
+        }
+        return this.fit.ladder(asset, tier, slots);
+    }
+    async _yieldPins(model, loadOpts) {
+        for (const key of this._pinned) {
+            if (leaseCount(this._models, key) > 0 || this._replying.includes(key)) {
+                continue;
+            }
+            if (await this._fits(model, loadOpts))
+                return;
+            this._pinned.delete(key);
+            await evictModelWithin(this._models, key, { deadlineMs: WEDGED_EVICT_WAIT_MS });
+        }
+    }
+    _target(model, agent) {
+        const addon = modelAddonOf(model);
+        if (addon === 'llm') {
+            const loadOpts = this.loadOptions(model, agent);
+            const key = modelKey(model, loadOpts);
+            return {
+                pool: this._models,
+                key,
+                loadOpts,
+                open: () => this._models.open(key, model, loadOpts)
+            };
+        }
+        if (addon === 'embeddings' || addon === 'tts' || addon === 'parakeet') {
+            return this._poolFor(addon, model);
+        }
+        throw new Error(`${model} loads for each generation and is not kept in memory`);
+    }
+    loadOptions(model, agent) {
+        return resolveLoadOptions({
+            ctxSize: agent?.ctxSize ?? undefined,
+            kvCacheK: agent?.kvCacheK ?? undefined,
+            kvCacheV: agent?.kvCacheV ?? undefined,
+            projectionModel: this._projectionFor(model)
+        }, this.deviceConfig());
+    }
+    async acquireLease({ pool, key, open, signal, prepare }) {
+        const releaseWork = this.gate.enterWork();
+        let pendingLoad = null;
+        let opened = false;
+        let released = false;
+        const release = () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            try {
+                if (opened) {
+                    releaseModel(pool, key);
+                }
+            }
+            finally {
+                releaseWork();
+            }
+        };
+        try {
+            if (!(await prepare())) {
+                release();
+                return null;
+            }
+            if (signal?.aborted) {
+                throw new AbortedError();
+            }
+            if (this.gate.suspended || this.gate.draining) {
+                throw new Error('harness is suspended');
+            }
+            this.gate.assertNotClosing();
+            if (this.gate.unloadFailed) {
+                throw new Error('Runtime unload failed; close the harness before loading models again');
+            }
+            const handle = open();
+            opened = true;
+            const loading = handle.load();
+            pendingLoad = loading;
+            const loaded = await raceAbort(loading, signal);
+            return { modelId: loaded.modelId, ctxSize: loaded.ctxSize, release };
+        }
+        catch (error) {
+            if (pendingLoad) {
+                void pendingLoad.then(release, release).catch(noop);
+            }
+            else {
+                release();
+            }
+            throw error;
+        }
+    }
+    async completionRuntime(request) {
+        const releaseWork = this.gate.enterWork();
+        try {
+            return await prepareCompletionRuntime(this, request);
+        }
+        finally {
+            releaseWork();
+        }
+    }
+    async makeRoomForCompletion(model, { loadOpts, signal, deadlineMs = MODEL_ROOM_WAIT_MS }) {
+        const roomed = await awaitModelCapacity(this._models, {
+            cap: this._completionModelCap,
+            deadlineMs,
+            signal,
+            evictable: (key) => !this._pinned.has(key) || modelOf(key) === model
+        });
+        if (roomed) {
+            await this.unloadIdleGenerators();
+        }
+        else {
+            hlog('model room wait gave up', {
+                cap: this._completionModelCap,
+                loaded: loadedModels(this._models).length
+            });
+        }
+        await this._yieldPins(model, loadOpts);
+        const key = modelKey(model, loadOpts);
+        if (roomed && !signal?.aborted && !loadOpts.ctxSize && this.fit.chosen(key) === undefined) {
+            const choice = await this._loadDecision(model, loadOpts);
+            if (choice) {
+                this.fit.keep(key, choice);
+            }
+        }
+        return roomed;
+    }
+    async evictWedged(model, key) {
+        const faults = (this._modelFaults.get(model) ?? 0) + 1;
+        this._modelFaults.set(model, faults);
+        const leased = leaseCount(this._models, key) > 0;
+        const evicted = leased
+            ? false
+            : await evictModelWithin(this._models, key, { deadlineMs: WEDGED_EVICT_WAIT_MS });
+        hlog('wedged model evicted', { model, faults, evicted, leased });
+        if (leased) {
+            this._evictAfterLeases(model, key);
+        }
+        if (!evicted && !leased) {
+            return {
+                message: `${model} is stuck in device memory — restarting the model runtime`,
+                fatal: true
+            };
+        }
+        return {
+            message: faults > 1
+                ? `${model} keeps failing during inference on this device — it may need more memory than is available`
+                : `${model} failed during inference and was unloaded — try again`,
+            fatal: false
+        };
+    }
+    _evictAfterLeases(model, key) {
+        void evictModelWithin(this._models, key, { deadlineMs: WEDGED_EVICT_LEASED_MS })
+            .then((evicted) => hlog('wedged model evicted after leases', { model, evicted }))
+            .catch(noop);
+    }
+    async busy(run) {
+        await this._idle.enter();
+        try {
+            return await run();
+        }
+        finally {
+            this._idle.exit();
+        }
+    }
+    async *busyStream(run) {
+        await this._idle.enter();
+        try {
+            yield* run();
+        }
+        finally {
+            this._idle.exit();
+        }
+    }
+}
+function noop() { }

package/dist-lib/lib/run-log/boundary.d.ts

@@ -0,0 +1,17 @@
+import type { Operation } from '../contract/index.ts';
+import type { EngineBoot, EngineStep, RunRecord } from './protocol-types.ts';
+import { RunJournal } from './run-journal.ts';
+export declare const HOST_APPEND_TIMEOUT_MS = 5000;
+export interface RunLogBoundaryOptions {
+    boot?: EngineBoot;
+    onStep?: (step: EngineStep) => Promise<void>;
+    hostAppendTimeoutMs?: number;
+    redact?: <Value>(value: Value) => Value;
+    redactShared?: <Value>(value: Value) => Value;
+    redactOperationResult?: <Value>(operation: Operation, value: Value) => Value;
+    redactRecord?: (record: RunRecord) => RunRecord;
+    redactStep?: (step: EngineStep) => EngineStep;
+    onDetached?: (pending: Promise<void>, runId?: string) => void;
+}
+export declare function openBoundaryJournal(options: RunLogBoundaryOptions, runId: string): RunJournal;
+export declare function boundaryBoot(journal: RunJournal): EngineBoot;

package/dist-lib/lib/run-log/boundary.js

@@ -0,0 +1,58 @@
+import { didDrainTimeOut, raceDrain } from '../helpers/drain.js';
+import { applyEngineStep, captureEngineStep, captureRunRecord, createEngineStep, prepareEngineBoot } from './protocol.js';
+import { ENGINE_BOUNDARY_BOOT, RunJournal } from './run-journal.js';
+export const HOST_APPEND_TIMEOUT_MS = 5000;
+export function openBoundaryJournal(options, runId) {
+    const log = boundaryLog(options, runId);
+    return new RunJournal(log, {
+        boot: log[ENGINE_BOUNDARY_BOOT](),
+        redact: options.redact,
+        redactShared: options.redactShared,
+        redactOperationResult: options.redactOperationResult,
+        redactRecord: options.redactRecord
+    });
+}
+export function boundaryBoot(journal) {
+    return prepareEngineBoot(getCurrentBoot(journal.core, journal));
+}
+function boundaryLog(options, runId) {
+    let boot = prepareEngineBoot(options.boot);
+    const log = {
+        [ENGINE_BOUNDARY_BOOT]: () => boot,
+        get length() {
+            return boot.length;
+        },
+        ready: async () => { },
+        get: async () => {
+            return null;
+        },
+        async append(value) {
+            const step = createEngineStep(boot.nextSeq, boot.length, [captureRunRecord(value)]);
+            const prepared = options.redactStep ? captureEngineStep(options.redactStep(step)) : step;
+            const next = applyEngineStep(boot, prepared);
+            const append = options.onStep?.(prepared);
+            if (append) {
+                const configured = options.hostAppendTimeoutMs;
+                const timeoutMs = typeof configured === 'number' && Number.isFinite(configured) && configured > 0
+                    ? Math.min(configured, 2 ** 31 - 1)
+                    : HOST_APPEND_TIMEOUT_MS;
+                const acknowledged = await raceDrain(append, timeoutMs);
+                if (didDrainTimeOut(acknowledged)) {
+                    try {
+                        options.onDetached?.(append, runId);
+                    }
+                    catch {
+                    }
+                    throw new Error(`Host run-log append did not acknowledge within ${timeoutMs}ms`);
+                }
+            }
+            boot = next;
+            return boot;
+        }
+    };
+    return log;
+}
+function getCurrentBoot(log, journal) {
+    const readBoot = Reflect.get(log, ENGINE_BOUNDARY_BOOT);
+    return typeof readBoot === 'function' ? readBoot.call(log) : journal.exportBoot();
+}

package/dist-lib/lib/run-log/history-codec.d.ts

@@ -1,23 +1,24 @@
 import { type Patch } from './patch.ts';
+import type { HistoryReference } from './protocol-types.ts';
 export type { HistoryReference } from './protocol-types.ts';
 export interface HistoryProjectionOptions {
     base: readonly unknown[] | undefined;
     failureRefs?: ReadonlySet<string>;
-    validateFailureOutputs?: boolean;
     validate?: boolean;
 }
-export declare const FAILURE_RESULT_REF_MACHINE_VERSION = 8;
 export declare function requestMessages(request: unknown): readonly unknown[] | undefined;
-export declare function compactSnapshotHistory<Value>(snapshot: Value, base: readonly unknown[] | undefined): Value;
-export declare function materializeSnapshotHistory<Value>(snapshot: Value, base: readonly unknown[] | undefined, allowLegacyInlineFailureResults?: boolean): Value;
+export declare function compactRequestHistory(messages: readonly unknown[], base: readonly unknown[] | undefined): readonly unknown[] | HistoryReference;
+export declare function materializeRequestHistory(value: unknown, base: readonly unknown[] | undefined): readonly unknown[];
+export declare function validateRequestHistory(value: unknown, base: readonly unknown[] | undefined): void;
+export declare function compactSnapshotHistory<Value>(snapshot: Value, base: readonly unknown[] | undefined, previous?: unknown): Value;
+export declare function materializeSnapshotHistory<Value>(snapshot: Value, base: readonly unknown[] | undefined): Value;
 export declare function compactMachineEvent<Value>(event: Value, base: readonly unknown[] | undefined): Value;
 export declare function materializeMachineEvent<Value>(event: Value, base: readonly unknown[] | undefined): Value;
 export interface SnapshotHistoryValidationOptions {
-    allowLegacyInlineFailureResults?: boolean;
     validateMachineContext?: boolean;
 }
 export declare function validateSnapshotHistory(snapshot: unknown, base: readonly unknown[] | undefined, options?: SnapshotHistoryValidationOptions): void;
-export declare function snapshotFailureResultRefs(snapshot: unknown, allowLegacyInlineFailureResults?: boolean): ReadonlySet<string>;
+export declare function snapshotFailureResultRefs(snapshot: unknown): ReadonlySet<string>;
 export declare function validateMachineEventHistory(event: unknown, base: readonly unknown[] | undefined, failureRefs?: ReadonlySet<string>): void;
 export declare function foldMachineEventHistory(previous: unknown, patch: Patch, options: HistoryProjectionOptions): unknown;
 export declare function validateHistoryProjection(value: unknown, options: HistoryProjectionOptions): void;