@ikarmic/forge-core 5.1.1 → 5.3.0

package/dist/agent/retry.js

@@ -0,0 +1,192 @@
+/**
+ * When a failed model call is worth repeating, and how long to wait first. Patterns follow Kilo's
+ * session/retry.ts: status codes, the provider's own retry-after headers, and the wordings providers and
+ * Node use for overloads and dropped connections.
+ */
+export const DEFAULT_PROVIDER_RETRIES = 5;
+export const DEFAULT_RETRY_BASE_MS = 2000;
+const MAX_BACKOFF_MS = 30_000;
+/** A provider asking for a longer wait than this means a quota, not a hiccup: report it instead. */
+const MAX_HEADER_WAIT_MS = 5 * 60_000;
+const RETRYABLE_PATTERNS = [
+    /(?:^|\b(?:status|http|code|error)\b[^\d\n]{0,3})(?:408|409|425|429|500|502|503|504|520|522|524|529)\b/i,
+    /rate[ _-]?limit|too many requests|rate increased too quickly/i,
+    /overloaded|service[ _-]unavailable|internal[ _-](?:server[ _-])?error|server[ _-]error|bad gateway|gateway time-?out|provider returned error/i,
+    /fetch failed|failed to fetch|network[ _-]?error|socket hang up|socket connection was closed|connection (?:error|refused|reset|lost)|terminated|other side closed|upstream connect/i,
+    /econnreset|econnrefused|etimedout|enotfound|eai_again|epipe|und_err/i,
+    /\b(?:request|response|connection|network|stream|read) (?:timeout|timed out)\b/i,
+    /try (?:your request )?again|resource[ _-]exhausted|temporarily (?:unavailable|at capacity)/i,
+];
+const OVERFLOW_PATTERNS = [
+    /context[ _-]length[ _-]exceeded/i,
+    /maximum context length/i,
+    /prompt is too long/i,
+    /context window/i,
+    /too many (?:input )?tokens/i,
+    /input (?:is )?too long/i,
+    /exceeds? (?:the )?(?:model'?s? )?(?:maximum|max) (?:context|input|token)/i,
+];
+/** Status, headers and every message in the cause chain (an AI SDK RetryError's lastError included). */
+function factsOf(err) {
+    const facts = { status: undefined, sdkRetryable: undefined, headers: {}, text: '', aborted: false };
+    const texts = [];
+    let cur = err;
+    for (let depth = 0; cur && depth < 6; depth++) {
+        if (typeof cur !== 'object') {
+            texts.push(String(cur));
+            break;
+        }
+        const e = cur;
+        if (e.name === 'AbortError')
+            facts.aborted = true;
+        if (facts.status === undefined && typeof e.statusCode === 'number')
+            facts.status = e.statusCode;
+        if (facts.sdkRetryable === undefined && typeof e.isRetryable === 'boolean')
+            facts.sdkRetryable = e.isRetryable;
+        if (e.responseHeaders && typeof e.responseHeaders === 'object' && Object.keys(facts.headers).length === 0) {
+            for (const [k, v] of Object.entries(e.responseHeaders))
+                if (typeof v === 'string')
+                    facts.headers[k.toLowerCase()] = v;
+        }
+        for (const key of ['message', 'code', 'responseBody'])
+            if (typeof e[key] === 'string')
+                texts.push(e[key]);
+        cur = e.lastError ?? e.cause;
+    }
+    facts.text = texts.join('\n');
+    return facts;
+}
+/** The first line of the error a person should see. */
+export function errorSummary(err) {
+    return factsOf(err).text.split('\n')[0] || 'Unknown error';
+}
+export function isContextOverflowError(err) {
+    const f = factsOf(err);
+    if (f.status === 413)
+        return true;
+    return OVERFLOW_PATTERNS.some((p) => p.test(f.text));
+}
+function headerWaitMs(headers) {
+    const ms = Number.parseFloat(headers['retry-after-ms'] ?? '');
+    if (Number.isFinite(ms) && ms >= 0)
+        return Math.ceil(ms);
+    const raw = headers['retry-after'];
+    if (!raw)
+        return undefined;
+    const seconds = Number.parseFloat(raw);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.ceil(seconds * 1000);
+    const at = Date.parse(raw);
+    return Number.isNaN(at) ? undefined : Math.max(0, at - Date.now());
+}
+/**
+ * Whether to retry after failed attempt number `attempt` (1-based) and how long to wait.
+ * `random` in [0, 1) adds up to 25% jitter to the back-off.
+ */
+export function retryDecision(err, attempt, baseDelayMs = DEFAULT_RETRY_BASE_MS, random = Math.random()) {
+    const f = factsOf(err);
+    if (f.aborted || isContextOverflowError(err))
+        return { retry: false };
+    const serverSide = f.status !== undefined && (f.status >= 500 || f.status === 408 || f.status === 409 || f.status === 425 || f.status === 429);
+    const clientSide = f.status !== undefined && f.status >= 400 && !serverSide;
+    if (clientSide)
+        return { retry: false };
+    if (!serverSide && f.sdkRetryable !== true && !RETRYABLE_PATTERNS.some((p) => p.test(f.text)))
+        return { retry: false };
+    const message = errorSummary(err);
+    const asked = headerWaitMs(f.headers);
+    if (asked !== undefined)
+        return asked > MAX_HEADER_WAIT_MS ? { retry: false } : { retry: true, delayMs: asked, message };
+    const base = baseDelayMs * 2 ** (attempt - 1);
+    return { retry: true, delayMs: Math.min(MAX_BACKOFF_MS, Math.ceil(base + base * 0.25 * random)), message };
+}
+/** Error codes that mean this machine cannot reach the network at all (Kilo session/network.ts, minus resets). */
+const OFFLINE_CODES = new Set(['ENOTFOUND', 'EAI_AGAIN', 'ENETUNREACH', 'EHOSTUNREACH', 'ENETDOWN']);
+/** True when the failure looks like no network (DNS or route gone), not a busy or resetting server. */
+export function isDisconnected(err) {
+    let cur = err;
+    for (let depth = 0; cur && typeof cur === 'object' && depth < 6; depth++) {
+        const e = cur;
+        if (typeof e.code === 'string' && OFFLINE_CODES.has(e.code))
+            return true;
+        if (typeof e.message === 'string' && /\b(?:ENOTFOUND|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|ENETDOWN)\b|network is unreachable/i.test(e.message))
+            return true;
+        cur = e.lastError ?? e.cause;
+    }
+    return false;
+}
+/** Opens a TCP connection to a few well-known hosts by address (no DNS needed); true when any of them answers. */
+export async function defaultNetworkProbe() {
+    const { connect } = await import('node:net');
+    const dial = (host) => new Promise((resolve) => {
+        const socket = connect({ host, port: 443 });
+        const timer = setTimeout(() => {
+            socket.destroy();
+            resolve(false);
+        }, 5000);
+        socket.once('connect', () => {
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once('error', () => {
+            clearTimeout(timer);
+            resolve(false);
+        });
+    });
+    const results = await Promise.all(['1.1.1.1', '8.8.8.8', '9.9.9.9'].map(dial));
+    return results.some(Boolean);
+}
+/**
+ * Poll `probe` every `pollMs` until it reports a network, the signal fires, or `budgetMs` runs out.
+ * Returns how long it waited and why it stopped.
+ */
+export async function waitForNetwork(probe, opts) {
+    const started = Date.now();
+    for (;;) {
+        if ((await waitOrAbort(opts.pollMs, opts.abortSignal)) === 'aborted')
+            return { outcome: 'aborted', waitedMs: Date.now() - started };
+        if (await probe().catch(() => false))
+            return { outcome: 'online', waitedMs: Date.now() - started };
+        if (Date.now() - started >= opts.budgetMs)
+            return { outcome: 'gave_up', waitedMs: Date.now() - started };
+    }
+}
+/**
+ * Run a one-shot model call (generateText with `maxRetries: 0`) under the agent loop's retry policy.
+ * Throws the failure itself when it is not worth retrying, when the retries are used up, or on abort.
+ */
+export async function withModelRetry(call, opts = {}) {
+    const maxRetries = opts.maxRetries ?? DEFAULT_PROVIDER_RETRIES;
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await call();
+        }
+        catch (err) {
+            if (opts.abortSignal?.aborted || attempt > maxRetries)
+                throw err;
+            const decision = retryDecision(err, attempt, opts.baseDelayMs ?? DEFAULT_RETRY_BASE_MS);
+            if (!decision.retry)
+                throw err;
+            opts.onRetry?.(attempt, decision.delayMs, decision.message);
+            if ((await waitOrAbort(decision.delayMs, opts.abortSignal)) === 'aborted')
+                throw err;
+        }
+    }
+}
+/** Resolves after `ms`, or early (to 'aborted') when the signal fires; leaves no listener behind (RB-36). */
+export function waitOrAbort(ms, signal) {
+    if (signal?.aborted)
+        return Promise.resolve('aborted');
+    return new Promise((resolve) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve('aborted');
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve('waited');
+        }, ms);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}

package/dist/agent/shell-command.d.ts

@@ -0,0 +1,23 @@
+import type { LanguageModel } from 'ai';
+import type { ModelConfig } from '../types.js';
+export type ShellKind = 'powershell' | 'cmd' | 'bash' | 'zsh' | 'fish' | 'sh';
+/** Which shell an executable path is, by its file name; an unknown one is PowerShell on Windows and bash elsewhere. */
+export declare function shellKindOf(shellPath: string | undefined, platform: NodeJS.Platform): ShellKind;
+/**
+ * Reduce a model reply to the bare command: no think block (RB-1), no fence, quotes, prompt symbol or explanation.
+ * Returns '' when nothing is left.
+ */
+export declare function cleanShellCommand(text: string): string;
+/** Turn a plain request into one command for `shell`. Never throws: any failure or an unusable reply is `{ error: 'empty' }`. */
+export declare function generateShellCommand(request: string, opts: {
+    model: ModelConfig;
+    shell: ShellKind;
+    platform: NodeJS.Platform;
+    modelFactory?: (cfg: ModelConfig) => LanguageModel;
+}): Promise<{
+    command: string;
+} | {
+    error: 'empty';
+}>;
+/** Why a command deserves a second look, or undefined. The first matching reason wins, in the order of RISKS. */
+export declare function commandRisk(command: string): string | undefined;

package/dist/agent/shell-command.js

@@ -0,0 +1,93 @@
+import { generateText } from 'ai';
+import { createLanguageModel } from '../providers.js';
+import { withModelRetry } from './retry.js';
+import { stripThinkTags } from './think-tags.js';
+/** Which shell an executable path is, by its file name; an unknown one is PowerShell on Windows and bash elsewhere. */
+export function shellKindOf(shellPath, platform) {
+    const base = (shellPath ?? '').split(/[\\/]/).pop()?.toLowerCase().replace(/\.(exe|cmd|bat)$/, '') ?? '';
+    if (base === 'pwsh' || base === 'powershell')
+        return 'powershell';
+    if (base === 'cmd')
+        return 'cmd';
+    if (base === 'bash' || base === 'zsh' || base === 'fish' || base === 'sh')
+        return base;
+    return platform === 'win32' ? 'powershell' : 'bash';
+}
+const SHELL_NAMES = {
+    powershell: 'PowerShell',
+    cmd: 'cmd.exe (Windows Command Prompt)',
+    bash: 'bash',
+    zsh: 'zsh',
+    fish: 'fish',
+    sh: 'POSIX sh',
+};
+function osName(platform) {
+    if (platform === 'win32')
+        return 'Windows';
+    if (platform === 'darwin')
+        return 'macOS';
+    return 'Linux';
+}
+function shellCommandPrompt(request, shell, platform) {
+    return (`Write exactly one command for ${SHELL_NAMES[shell]} on ${osName(platform)} that does what the request below asks. ` +
+        'Use only tools that ship with that shell and system. Reply with the command only: no explanation, no quotes, no code fences, no prompt symbol.\n\n' +
+        `Request:\n${request}`);
+}
+const SHELL_OPERATORS = /[|&;<>$()=\\/]|\s-{1,2}[A-Za-z]/;
+/** A line of explanation rather than a command: it ends in a colon, or reads as a sentence with no shell syntax in it. */
+function isProse(line) {
+    const t = line.trim();
+    if (t.endsWith(':'))
+        return true;
+    const words = t.split(/\s+/);
+    return /^[A-Z][a-z']*[,!.]?$/.test(words[0] ?? '') && words.length > 6 && !SHELL_OPERATORS.test(t);
+}
+/**
+ * Reduce a model reply to the bare command: no think block (RB-1), no fence, quotes, prompt symbol or explanation.
+ * Returns '' when nothing is left.
+ */
+export function cleanShellCommand(text) {
+    let body = stripThinkTags(text).trim();
+    const fence = /```[^\n]*\n?([\s\S]*?)(?:```|$)/.exec(body);
+    if (fence)
+        body = fence[1].trim();
+    const lines = body.split(/\r?\n/).filter((l) => l.trim() && !isProse(l));
+    if (lines.length === 0)
+        return '';
+    lines[0] = lines[0].replace(/^\s*(?:PS [^>\n]*>|PS>|\$|>)\s+/, '');
+    let command = lines.join('\n').trim();
+    for (const q of ['"', "'", '`']) {
+        if (command.length > 1 && command.startsWith(q) && command.endsWith(q) && !command.slice(1, -1).includes(q)) {
+            command = command.slice(1, -1).trim();
+            break;
+        }
+    }
+    return command;
+}
+/** Turn a plain request into one command for `shell`. Never throws: any failure or an unusable reply is `{ error: 'empty' }`. */
+export async function generateShellCommand(request, opts) {
+    try {
+        const factory = opts.modelFactory ?? createLanguageModel;
+        const result = await withModelRetry(() => generateText({ model: factory(opts.model), prompt: shellCommandPrompt(request, opts.shell, opts.platform), maxRetries: 0 }), { maxRetries: 2 });
+        const command = cleanShellCommand(result.text);
+        return command ? { command } : { error: 'empty' };
+    }
+    catch {
+        return { error: 'empty' };
+    }
+}
+const RISKS = [
+    [
+        'deletes files',
+        /\brm\s+(?:-\w+\s+)*-(?:\w*[rR]\w*|-recursive)\b|\b(?:remove-item|ri)\b[^|;&\n]*\s-r\w*\b|\bdel\b[^|;&\n]*\/s\b|\b(?:rmdir|rd)\b[^|;&\n]*\/s\b|\bfind\b[^|;&\n]*\s-delete\b/i,
+    ],
+    ['forces', /(?:^|\s)--force\b|\bpush\b[^|;&\n]*\s-f\b/i],
+    ['runs as administrator', /(?:^|[\s;&|(])sudo\b|\brunas\b|\bstart-process\b[^|;&\n]*-verb\s+runas\b/i],
+    ['rewrites git history', /\bgit\s+(?:-\S+\s+)*(?:reset\b[^|;&\n]*--hard\b|rebase\b|push\b[^|;&\n]*--force\b)/i],
+    ['drops data', /\bdrop\s+table\b|\btruncate\b/i],
+    ['formats a disk', /\bmkfs(?:\.\w+)?\b|(?:^|[;&|]\s*)format(?:\.com|\.exe)?\s+[a-z]:|\bdiskpart\b/i],
+];
+/** Why a command deserves a second look, or undefined. The first matching reason wins, in the order of RISKS. */
+export function commandRisk(command) {
+    return RISKS.find(([, re]) => re.test(command))?.[0];
+}

package/dist/agent/stack-facts.d.ts

@@ -0,0 +1,23 @@
+export declare const MAX_STACK_LIBRARIES = 25;
+export interface StackFacts {
+    runtimes: {
+        name: string;
+        version: string;
+        source: string;
+    }[];
+    libraries: {
+        name: string;
+        version: string;
+        range: boolean;
+    }[];
+    tools: {
+        test?: string;
+        lint?: string;
+        format?: string;
+    };
+}
+/** JSON with comments and trailing commas (tsconfig.json): comments outside strings removed, then trailing commas. */
+export declare function parseJsonc(text: string): Record<string, unknown> | undefined;
+export declare function detectStackFacts(cwd: string): Promise<StackFacts>;
+/** The facts as a block for the system prompt; '' when there are none. */
+export declare function stackBlock(facts: StackFacts): string;

package/dist/agent/stack-facts.js

@@ -0,0 +1,150 @@
+/**
+ * The `<stack>` block: the language, runtime and library versions the workspace's own files state, so an
+ * agent writes code for the versions in use instead of the ones it saw most in training. File reads only,
+ * no model and no tree walk (the journey survey's rule: a missing fact costs less than a wrong one). Every
+ * source is read on its own; one that is missing or unreadable leaves its facts out and never fails a run.
+ * Only the workspace root's files are read.
+ */
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+export const MAX_STACK_LIBRARIES = 25;
+const TEST_TOOLS = { vitest: 'vitest', jest: 'jest', mocha: 'mocha', ava: 'ava', pytest: 'pytest' };
+const LINT_TOOLS = { eslint: 'eslint', '@biomejs/biome': 'biome', ruff: 'ruff', flake8: 'flake8', pylint: 'pylint' };
+const FORMAT_TOOLS = { prettier: 'prettier', '@biomejs/biome': 'biome', black: 'black', ruff: 'ruff' };
+async function read(cwd, rel) {
+    try {
+        return await readFile(path.join(cwd, rel), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function json(text) {
+    if (text === undefined)
+        return undefined;
+    try {
+        const v = JSON.parse(text);
+        return v && typeof v === 'object' && !Array.isArray(v) ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** JSON with comments and trailing commas (tsconfig.json): comments outside strings removed, then trailing commas. */
+export function parseJsonc(text) {
+    let out = '';
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (inString) {
+            out += c;
+            if (c === '\\')
+                out += text[++i] ?? '';
+            else if (c === '"')
+                inString = false;
+        }
+        else if (c === '"') {
+            inString = true;
+            out += c;
+        }
+        else if (c === '/' && text[i + 1] === '/') {
+            while (i < text.length && text[i] !== '\n')
+                i++;
+            out += '\n';
+        }
+        else if (c === '/' && text[i + 1] === '*') {
+            const end = text.indexOf('*/', i + 2);
+            i = end < 0 ? text.length : end + 1;
+        }
+        else
+            out += c;
+    }
+    return json(out.replace(/,(\s*[}\]])/g, '$1'));
+}
+const strings = (v) => Object.fromEntries(Object.entries(v && typeof v === 'object' ? v : {}).filter((e) => typeof e[1] === 'string'));
+async function installedVersion(cwd, name, lock) {
+    const own = json(await read(cwd, path.join('node_modules', name, 'package.json')));
+    if (typeof own?.version === 'string')
+        return own.version;
+    const entry = lock?.packages?.[`node_modules/${name}`];
+    if (typeof entry?.version === 'string')
+        return entry.version;
+    const legacy = lock?.dependencies?.[name];
+    return typeof legacy?.version === 'string' ? legacy.version : undefined;
+}
+function firstMatch(text, re) {
+    return text?.match(re)?.[1]?.trim() || undefined;
+}
+export async function detectStackFacts(cwd) {
+    const facts = { runtimes: [], libraries: [], tools: {} };
+    const runtime = (name, version, source) => {
+        if (version)
+            facts.runtimes.push({ name, version, source });
+    };
+    const noteTool = (dep) => {
+        facts.tools.test ??= TEST_TOOLS[dep];
+        facts.tools.lint ??= LINT_TOOLS[dep];
+        facts.tools.format ??= FORMAT_TOOLS[dep];
+    };
+    // Node and npm-style libraries.
+    const manifest = json(await read(cwd, 'package.json'));
+    const engines = strings(manifest?.engines);
+    runtime('node', engines.node, 'package.json engines');
+    runtime('node', firstMatch(await read(cwd, '.nvmrc'), /^\s*(\S+)/), '.nvmrc');
+    runtime('node', firstMatch(await read(cwd, '.node-version'), /^\s*(\S+)/), '.node-version');
+    if (manifest) {
+        const lock = json(await read(cwd, 'package-lock.json'));
+        const deps = Object.entries({ ...strings(manifest.dependencies) });
+        const dev = Object.entries(strings(manifest.devDependencies)).filter(([n]) => !deps.some(([d]) => d === n));
+        for (const [name] of [...deps, ...dev])
+            noteTool(name);
+        for (const [name, range] of [...deps, ...dev].slice(0, MAX_STACK_LIBRARIES)) {
+            const exact = await installedVersion(cwd, name, lock);
+            facts.libraries.push(exact ? { name, version: exact, range: false } : { name, version: range, range: true });
+        }
+    }
+    const tsconfig = await read(cwd, 'tsconfig.json');
+    const target = tsconfig === undefined ? undefined : parseJsonc(tsconfig)?.compilerOptions?.target;
+    if (typeof target === 'string')
+        runtime('tsconfig target', target, 'tsconfig.json');
+    // Python.
+    runtime('python', firstMatch(await read(cwd, 'pyproject.toml'), /^\s*requires-python\s*=\s*["']([^"']+)["']/m), 'pyproject.toml');
+    runtime('python', firstMatch(await read(cwd, '.python-version'), /^\s*(\S+)/), '.python-version');
+    const requirements = await read(cwd, 'requirements.txt');
+    for (const line of requirements?.split(/\r?\n/) ?? []) {
+        const m = line.match(/^\s*([A-Za-z0-9._-]+)\s*==\s*([^\s;#]+)/);
+        if (!m)
+            continue;
+        noteTool(m[1].toLowerCase());
+        if (facts.libraries.length < MAX_STACK_LIBRARIES)
+            facts.libraries.push({ name: m[1], version: m[2], range: false });
+    }
+    // Go, Rust, Java.
+    runtime('go', firstMatch(await read(cwd, 'go.mod'), /^\s*go\s+(\d[\w.]*)\s*$/m), 'go.mod');
+    runtime('rust edition', firstMatch(await read(cwd, 'Cargo.toml'), /^\s*edition\s*=\s*["']([^"']+)["']/m), 'Cargo.toml');
+    runtime('rust', firstMatch(await read(cwd, 'rust-toolchain.toml'), /^\s*channel\s*=\s*["']([^"']+)["']/m), 'rust-toolchain.toml');
+    runtime('rust', firstMatch(await read(cwd, 'rust-toolchain'), /^\s*(\S+)/), 'rust-toolchain');
+    const pom = await read(cwd, 'pom.xml');
+    runtime('java', firstMatch(pom, /<maven\.compiler\.release>\s*([^<\s]+)\s*</) ?? firstMatch(pom, /<java\.version>\s*([^<\s]+)\s*</), 'pom.xml');
+    for (const gradle of ['build.gradle.kts', 'build.gradle']) {
+        const text = await read(cwd, gradle);
+        runtime('java', firstMatch(text, /JavaLanguageVersion\.of\(\s*(\d+)\s*\)/) ?? firstMatch(text, /JavaVersion\.VERSION_(\d+(?:_\d+)?)/), gradle);
+    }
+    for (const k of Object.keys(facts.tools))
+        if (facts.tools[k] === undefined)
+            delete facts.tools[k];
+    return facts;
+}
+/** The facts as a block for the system prompt; '' when there are none. */
+export function stackBlock(facts) {
+    const lines = [
+        ...facts.runtimes.map((r) => `${r.name} ${r.version} (${r.source})`),
+        ...facts.libraries.map((l) => (l.range ? `${l.name} ${l.version} (range in the manifest; installed version unknown)` : `${l.name} ${l.version}`)),
+        ...(facts.tools.test ? [`test runner: ${facts.tools.test}`] : []),
+        ...(facts.tools.lint ? [`linter: ${facts.tools.lint}`] : []),
+        ...(facts.tools.format ? [`formatter: ${facts.tools.format}`] : []),
+    ];
+    if (lines.length === 0)
+        return '';
+    return ['<stack>', "Versions this workspace's files state (read from the files, not guessed):", ...lines, '</stack>'].join('\n');
+}

package/dist/catalog/models-dev-snapshot.d.ts

@@ -0,0 +1 @@
+export declare const MODELS_DEV_SNAPSHOT: Record<string, Record<string, ReadonlyArray<number | null>>>;