@myagentroam/agent 0.10.7 → 0.10.9

package/dist/agent-core/session/tool-result-resources.js

@@ -0,0 +1,285 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, mkdir, open, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { MarAgentError } from '../error.js';
+import { parseToolResultExtensions } from '../tools/result-extensions.js';
+const REF = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/u;
+const MAX_BYTES = 16 * 1024 * 1024;
+export async function writeToolResultResource(directory, text) {
+    const bytes = Buffer.from(text);
+    if (bytes.length > MAX_BYTES)
+        throw resourceError('LIMIT', 'Tool result resource exceeds its limit.');
+    const resourceRef = randomUUID();
+    const folder = join(directory, 'tool_results');
+    await mkdir(folder, { recursive: true, mode: 0o700 });
+    const temporary = join(folder, `.${resourceRef}.tmp`);
+    await writeFile(join(folder, `.${resourceRef}.pending`), '', {
+        flag: 'wx',
+        mode: 0o600,
+        flush: true
+    });
+    try {
+        await writeFile(temporary, bytes, { flag: 'wx', mode: 0o600, flush: true });
+        await rename(temporary, join(folder, `${resourceRef}.diff`));
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return {
+        status: 'available',
+        resourceRef,
+        format: 'unified-diff',
+        byteSize: bytes.length,
+        sha256: createHash('sha256').update(bytes).digest('hex')
+    };
+}
+export function recordToolResources(record) {
+    if (!['tool.completed', 'tool.failed'].includes(record.type))
+        return [];
+    const payload = record.payload;
+    const sources = [
+        payload?.resultExtensions,
+        ...(Array.isArray(payload?.data?.calls)
+            ? payload.data.calls.map((call) => call.resultExtensions)
+            : [])
+    ];
+    return sources.flatMap((source) => (parseToolResultExtensions(source) ?? []).flatMap((extension) => extension.entries.flatMap((entry) => (entry.diff.status === 'available' ? [entry.diff] : []))));
+}
+/** A locator is only a hint: reads must verify its exact committed record identity. */
+export async function bindToolResultResources(directory, record, readRecord, degrade = false) {
+    for (const resource of recordToolResources(record)) {
+        try {
+            await bindToolResultResource(directory, record, resource, readRecord);
+        }
+        catch (error) {
+            if (!degrade)
+                throw error;
+            // Shared descriptors are downgraded before persistence and live publication, never the tool outcome.
+            const payload = record.payload;
+            for (const extensions of [
+                payload.resultExtensions,
+                ...(payload.data?.calls ?? []).map((call) => call.resultExtensions)
+            ]) {
+                for (const extension of extensions ?? [])
+                    for (const entry of extension.entries) {
+                        if (entry.diff.status === 'available' &&
+                            entry.diff.resourceRef === resource.resourceRef)
+                            entry.diff = { status: 'unavailable', reason: 'storage-failed' };
+                    }
+            }
+        }
+    }
+}
+async function bindToolResultResource(directory, record, resource, readRecord) {
+    const path = join(directory, 'tool_results', `${resource.resourceRef}.json`);
+    try {
+        await writeFile(path, JSON.stringify({ sequence: record.sequence, recordId: record.recordId }), { flag: 'wx', mode: 0o600, flush: true });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+        const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const info = await handle.stat();
+            if (!info.isFile() || info.size > 1024)
+                throw resourceError('CORRUPT', 'Invalid tool resource locator.');
+            const locator = JSON.parse(await handle.readFile('utf8'));
+            const existing = locator.sequence === record.sequence && locator.recordId === record.recordId
+                ? record
+                : Number.isSafeInteger(locator.sequence)
+                    ? await readRecord?.(locator.sequence)
+                    : undefined;
+            if (!existing ||
+                existing.recordId !== locator.recordId ||
+                !recordToolResources(existing).some((entry) => entry.resourceRef === resource.resourceRef && entry.sha256 === resource.sha256))
+                throw resourceError('CORRUPT', 'Tool resource locator conflicts with committed history.');
+        }
+        catch (cause) {
+            throw normalizedResourceError(cause);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+}
+export function toolResultResourceFiles(records) {
+    return new Set(records.flatMap((record) => recordToolResources(record).flatMap((resource) => [
+        `${resource.resourceRef}.diff`,
+        `${resource.resourceRef}.json`
+    ])));
+}
+export async function copyToolResultResources(source, target, records) {
+    const copied = new Set();
+    for (const record of records) {
+        for (const resource of recordToolResources(record)) {
+            if (copied.has(resource.resourceRef))
+                continue;
+            copied.add(resource.resourceRef);
+            try {
+                const bytes = await readResourceBytes(source, resource);
+                const directory = join(target, 'tool_results');
+                await mkdir(directory, { recursive: true, mode: 0o700 });
+                await writeFile(join(directory, `${resource.resourceRef}.diff`), bytes, {
+                    flag: 'wx',
+                    mode: 0o600,
+                    flush: true
+                });
+            }
+            catch (error) {
+                if (error instanceof MarAgentError && error.code === 'MAR_AGENT_TOOL_RESOURCE_NOT_FOUND')
+                    continue;
+                throw error;
+            }
+        }
+        if (recordToolResources(record).length) {
+            await mkdir(join(target, 'tool_results'), { recursive: true, mode: 0o700 });
+            await bindToolResultResources(target, record, async (sequence) => records.find((item) => item.sequence === sequence));
+        }
+    }
+}
+export async function completeToolResultResources(directory, record) {
+    await Promise.all(recordToolResources(record).map((resource) => rm(join(directory, 'tool_results', `.${resource.resourceRef}.pending`), {
+        force: true
+    }).catch(() => undefined)));
+}
+export async function cleanupUnreferencedToolResources(directory, readRecords) {
+    const folder = join(directory, 'tool_results');
+    let names;
+    try {
+        names = await readdir(folder);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    const pending = names.filter((name) => name.startsWith('.') && name.endsWith('.pending') && REF.test(name.slice(1, -8)));
+    if (!pending.length)
+        return;
+    const retained = toolResultResourceFiles(await readRecords());
+    for (const marker of pending) {
+        const ref = marker.slice(1, -8);
+        for (const name of [`${ref}.diff`, `${ref}.json`, `.${ref}.tmp`]) {
+            if (retained.has(name))
+                continue;
+            const path = join(folder, name);
+            try {
+                if ((await lstat(path)).isFile())
+                    await rm(path);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        await rm(join(folder, marker), { force: true });
+    }
+}
+export async function readToolResultResource(directory, sessionId, input, readRecord) {
+    if (!REF.test(input.resourceRef) ||
+        (input.maxBytes !== undefined &&
+            (!Number.isSafeInteger(input.maxBytes) || input.maxBytes < 4 || input.maxBytes > 256 * 1024)))
+        throw resourceError('INPUT_INVALID', 'Invalid tool resource request.');
+    let locator;
+    try {
+        const file = join(directory, 'tool_results', `${input.resourceRef}.json`);
+        const handle = await open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const info = await handle.stat();
+            if (!info.isFile() || info.size > 1024)
+                throw resourceError('CORRUPT', 'Invalid tool resource locator.');
+            locator = JSON.parse(await handle.readFile('utf8'));
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        throw normalizedResourceError(error);
+    }
+    if (!Number.isSafeInteger(locator.sequence) ||
+        locator.sequence < 1 ||
+        typeof locator.recordId !== 'string')
+        throw resourceError('CORRUPT', 'Invalid tool resource locator.');
+    const record = await readRecord(locator.sequence);
+    const resource = record?.recordId === locator.recordId
+        ? recordToolResources(record).find((entry) => entry.resourceRef === input.resourceRef)
+        : undefined;
+    if (!resource)
+        throw resourceError('NOT_FOUND', 'Tool resource is not part of this session history.');
+    let offset = 0;
+    if (input.cursor !== undefined) {
+        try {
+            if (input.cursor.length > 1024)
+                throw new Error('cursor');
+            const cursor = JSON.parse(Buffer.from(input.cursor, 'base64url').toString('utf8'));
+            if (cursor.sessionId !== sessionId ||
+                cursor.ref !== resource.resourceRef ||
+                cursor.sha256 !== resource.sha256 ||
+                !Number.isSafeInteger(cursor.offset) ||
+                cursor.offset < 0 ||
+                cursor.offset >= resource.byteSize)
+                throw new Error('cursor');
+            offset = cursor.offset;
+        }
+        catch {
+            throw resourceError('INPUT_INVALID', 'Invalid tool resource cursor.');
+        }
+    }
+    const bytes = await readResourceBytes(directory, resource);
+    if (offset > 0 && (bytes[offset] & 0xc0) === 0x80)
+        throw resourceError('INPUT_INVALID', 'Invalid tool resource cursor boundary.');
+    let end = Math.min(bytes.length, offset + (input.maxBytes ?? 256 * 1024));
+    while (end < bytes.length && (bytes[end] & 0xc0) === 0x80)
+        end--;
+    if ((await readRecord(locator.sequence))?.recordId !== locator.recordId)
+        throw resourceError('NOT_FOUND', 'Tool resource history has changed.');
+    return {
+        type: 'file_changes',
+        version: 1,
+        format: resource.format,
+        resourceRef: resource.resourceRef,
+        byteSize: resource.byteSize,
+        sha256: resource.sha256,
+        content: bytes.subarray(offset, end).toString('utf8'),
+        ...(end < bytes.length
+            ? {
+                nextCursor: Buffer.from(JSON.stringify({
+                    sessionId,
+                    ref: resource.resourceRef,
+                    sha256: resource.sha256,
+                    offset: end
+                })).toString('base64url')
+            }
+            : {})
+    };
+}
+async function readResourceBytes(directory, resource) {
+    try {
+        const handle = await open(join(directory, 'tool_results', `${resource.resourceRef}.diff`), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const stat = await handle.stat();
+            if (!stat.isFile() || stat.size !== resource.byteSize || stat.size > MAX_BYTES)
+                throw resourceError('CORRUPT', 'Tool resource size does not match its history.');
+            const bytes = await handle.readFile();
+            if (createHash('sha256').update(bytes).digest('hex') !== resource.sha256)
+                throw resourceError('CORRUPT', 'Tool resource checksum does not match its history.');
+            return bytes;
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        throw normalizedResourceError(error);
+    }
+}
+function resourceError(suffix, message) {
+    return new MarAgentError(`MAR_AGENT_TOOL_RESOURCE_${suffix}`, message);
+}
+function normalizedResourceError(error) {
+    if (error instanceof MarAgentError)
+        return error;
+    return resourceError(error?.code === 'ENOENT' ? 'NOT_FOUND' : 'CORRUPT', 'Tool result resource is unavailable.');
+}

package/dist/agent-core/session/transaction-recovery.js

@@ -92,7 +92,7 @@ export async function recoverSessionStorageTransaction(directory, committedTrans
             await rename(backup, sidecar);
         }
     }
-    for (const folder of ['input_images', 'generated_images']) {
+    for (const folder of ['input_images', 'generated_images', 'tool_results']) {
         const path = join(directory, folder);
         let names;
         try {

package/dist/agent-core/tools/code-mode/dispatch.js

@@ -4,6 +4,7 @@ import { AGENT_EXECUTION_POLICY } from '../../runtime/execution-policy.js';
 import { allowsToolCaller } from '../callers.js';
 import { boundedModelToolOutput, structuredToolEventData, structuredToolFailureData } from '../output-projection.js';
 import { executeRegisteredTool } from '../runtime.js';
+import { failedToolResultExtensions } from '../result-extensions.js';
 /** Capture only the cell's immutable dispatch identity, never the model loop or its AbortSignal. */
 export function createCodeToolDispatch(input) {
     const definitions = new Map(input.tools.map((tool) => [tool.name, tool]));
@@ -33,6 +34,7 @@ export function createCodeToolDispatch(input) {
                 input.assertLive();
                 await input.emit({
                     type: 'tool.completed',
+                    ...(result.resultExtensions ? { resultExtensions: result.resultExtensions } : {}),
                     ...identity,
                     summary,
                     ...(data === undefined ? {} : { data }),
@@ -59,6 +61,9 @@ export function createCodeToolDispatch(input) {
                 const data = structuredToolFailureData(call.name, error);
                 await input.emit({
                     type: 'tool.failed',
+                    ...(failedToolResultExtensions(error)
+                        ? { resultExtensions: failedToolResultExtensions(error) }
+                        : {}),
                     ...identity,
                     code: diagnostic.code,
                     message: diagnostic.message,

package/dist/agent-core/tools/code-mode/index.js

@@ -16,6 +16,7 @@ import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
 import { createToolCallScheduler } from '../scheduler.js';
 import { detectImageMime } from '../local/view-image.js';
 import { structuredToolFailureData } from '../output-projection.js';
+import { failedToolResultExtensions } from '../result-extensions.js';
 export const codeModeToolDefinition = {
     name: 'code_exec',
     description: `Run JavaScript to orchestrate or compose tool calls.
@@ -25,7 +26,7 @@ export const codeModeToolDefinition = {
 - Observe only evidence needed for the next decision or verification: use observe.result for original results, observe.text for derived values, and observe.image for image values. Preserve source and failure details needed for reasoning; keep other intermediate data in the cell.
 - Single-tool cells are valid. Keep loops and retries bounded, and do not blindly replay operations with side effects.
 - Evaluates source in a fresh restricted ECMAScript runtime with top-level await and Promise.all. It is not Node.js or a browser. JavaScript globals do not survive between cells; bounded JSON state is available through state.
-- Accepts raw JavaScript source text, not JSON, quoted strings, or markdown code fences. Responses uses the source directly; Anthropic uses the code field of its tool input object. In either case, do not quote or fence the source again.
+- Accepts JavaScript source text. When exposed as a freeform tool, send the source directly; when exposed with a JSON input schema, put the source in its code field. Do not add another JSON wrapper, quoted string, or markdown code fence inside the source.
 - Use only standard ECMAScript built-ins and the explicitly documented tools, observe, state, catalog and cell namespaces. Do not use Node.js, browser or Web APIs. Module imports, filesystem and network APIs are unavailable. Obtain external capabilities only through available tools. Use tools.exec to start managed processes when permitted; use tools.exec_wait afterward to wait, write stdin or cancel.
 
 Tool calls:
@@ -474,15 +475,17 @@ export class CodeModeTool {
                     try {
                         if (frame.name === 'code_exec' || !available.has(frame.name))
                             throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'The requested nested tool is unavailable.');
-                        const output = await invoke({
+                        const rawOutput = await invoke({
                             name: frame.name,
                             arguments: frame.arguments,
                             callId: source.callId
                         });
+                        const { resultExtensions, ...output } = rawOutput;
                         toolResults.set(operationId, { source, outcome: 'completed', result: output });
                         recordCall({
                             ...source,
                             status: 'completed',
+                            ...(resultExtensions ? { resultExtensions } : {}),
                             result: {
                                 content: '',
                                 truncated: output.truncated === true,
@@ -516,6 +519,9 @@ export class CodeModeTool {
                         recordCall({
                             ...source,
                             status: 'failed',
+                            ...(failedToolResultExtensions(error)
+                                ? { resultExtensions: failedToolResultExtensions(error) }
+                                : {}),
                             error: { code: diagnostic.code, message: diagnostic.message }
                         });
                         toolResults.set(operationId, {

package/dist/agent-core/tools/code-mode/observations.d.ts

@@ -4,6 +4,7 @@ export interface CodeToolCallRecord {
     toolName: string;
     input: unknown;
     status: 'running' | 'completed' | 'failed';
+    resultExtensions?: readonly import('../result-extensions.js').ToolResultExtension[];
     result?: {
         content: string;
         data?: unknown;

package/dist/agent-core/tools/contracts.d.ts

@@ -95,6 +95,8 @@ export interface ToolExecutionResult {
         dataBase64: string;
     }[];
     artifacts?: readonly MarAgentToolArtifact[];
+    /** Host-facing evidence, excluded from model and programmatic guest results. */
+    resultExtensions?: readonly import('./result-extensions.js').ToolResultExtension[];
 }
 export interface CodeCellEventData {
     calls?: readonly import('./code-mode/observations.js').CodeToolCallRecord[];

package/dist/agent-core/tools/execution.js

@@ -5,6 +5,7 @@ import { CodeCellExecutionError } from './code-mode/cells.js';
 import { createCodeToolDispatch } from './code-mode/dispatch.js';
 import { boundedModelToolOutput, structuredToolArtifacts, structuredToolEventData, structuredToolFailureData } from './output-projection.js';
 import { executeRegisteredTool } from './runtime.js';
+import { failedToolResultExtensions } from './result-extensions.js';
 import { scheduleToolCallBatch } from './scheduler.js';
 /** Shared raw context construction for physical tools and native calls in a real model round. */
 export async function createRoundToolRuntimeContext(scope, call, signal) {
@@ -91,6 +92,7 @@ export async function executeRoundTools(calls, scope) {
             const artifacts = structuredToolArtifacts(output.artifacts);
             await scope.emit({
                 type: 'tool.completed',
+                ...(output.resultExtensions ? { resultExtensions: output.resultExtensions } : {}),
                 toolName: call.name,
                 callId: call.callId,
                 ...(parentCallId === undefined ? {} : { parentCallId }),
@@ -105,7 +107,9 @@ export async function executeRoundTools(calls, scope) {
                 call,
                 output,
                 content: modelOutput.content,
-                ...(output.calls ? { calls: output.calls } : {}),
+                ...(output.calls
+                    ? { calls: output.calls.map(({ resultExtensions: _evidence, ...call }) => call) }
+                    : {}),
                 ...(output.observations ? { observations: output.observations } : {}),
                 ...(output.images?.length ? { images: output.images } : {}),
                 failed: false
@@ -121,6 +125,9 @@ export async function executeRoundTools(calls, scope) {
                     : structuredToolEventData(call.name, partial.data));
             await scope.emit({
                 type: 'tool.failed',
+                ...(failedToolResultExtensions(error)
+                    ? { resultExtensions: failedToolResultExtensions(error) }
+                    : {}),
                 toolName: call.name,
                 callId: call.callId,
                 ...(parentCallId === undefined ? {} : { parentCallId }),
@@ -140,7 +147,9 @@ export async function executeRoundTools(calls, scope) {
                     : boundedModelToolOutput(call.name, partial.content, partial.data).content,
                 ...(partial?.images?.length ? { images: partial.images } : {}),
                 failed: true,
-                ...(partial?.calls ? { calls: partial.calls } : {}),
+                ...(partial?.calls
+                    ? { calls: partial.calls.map(({ resultExtensions: _evidence, ...call }) => call) }
+                    : {}),
                 ...(partial?.observations ? { observations: partial.observations } : {}),
                 error
             };

package/dist/agent-core/tools/file-change-diff.d.ts

@@ -0,0 +1,10 @@
+/** Bounded line comparison for immutable, per-operation file evidence. */
+export interface FileDiff {
+    text: string;
+    additions: number;
+    deletions: number;
+}
+export declare const MAX_FILE_DIFF_BYTES: number;
+export declare class FileDiffLimitError extends Error {
+}
+export declare function createFileDiff(path: string, before?: Buffer, after?: Buffer): FileDiff | undefined;

package/dist/agent-core/tools/file-change-diff.js

@@ -0,0 +1,139 @@
+const MAX_WORK = 2_000_000;
+export const MAX_FILE_DIFF_BYTES = 16 * 1024 * 1024;
+export class FileDiffLimitError extends Error {
+}
+export function createFileDiff(path, before, after) {
+    let oldText;
+    let newText;
+    try {
+        const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+        oldText = decoder.decode(before ?? Buffer.alloc(0));
+        newText = decoder.decode(after ?? Buffer.alloc(0));
+    }
+    catch {
+        return undefined;
+    }
+    if (oldText.includes('\0') || newText.includes('\0'))
+        return undefined;
+    const lines = (value) => value.match(/[^\n]*\n|[^\n]+$/gu) ?? [];
+    const a = lines(oldText);
+    const b = lines(newText);
+    if (a.length + b.length > 200_000)
+        throw new FileDiffLimitError();
+    const edits = compare(a, b);
+    if (!edits)
+        throw new FileDiffLimitError();
+    const output = [
+        `--- ${before === undefined ? '/dev/null' : JSON.stringify(`a/${path}`)}`,
+        `+++ ${after === undefined ? '/dev/null' : JSON.stringify(`b/${path}`)}`
+    ];
+    const positions = [];
+    const ranges = [];
+    let old = 1;
+    let next = 1;
+    let additions = 0;
+    let deletions = 0;
+    edits.forEach((edit, index) => {
+        positions.push({ old, next });
+        if (edit.kind !== '+')
+            old++;
+        if (edit.kind !== '-')
+            next++;
+        if (edit.kind === '+')
+            additions++;
+        if (edit.kind === '-')
+            deletions++;
+        if (edit.kind === ' ')
+            return;
+        const start = Math.max(0, index - 3);
+        const end = Math.min(edits.length, index + 4);
+        const last = ranges.at(-1);
+        if (last && start <= last.end)
+            last.end = end;
+        else
+            ranges.push({ start, end });
+    });
+    for (const range of ranges) {
+        const block = edits.slice(range.start, range.end);
+        const oldCount = block.filter((edit) => edit.kind !== '+').length;
+        const newCount = block.filter((edit) => edit.kind !== '-').length;
+        const position = positions[range.start];
+        output.push(`@@ -${position.old - (oldCount === 0 ? 1 : 0)},${oldCount} +${position.next - (newCount === 0 ? 1 : 0)},${newCount} @@`);
+        for (const edit of block) {
+            output.push(`${edit.kind}${edit.text.endsWith('\n') ? edit.text.slice(0, -1) : edit.text}`);
+            if (!edit.text.endsWith('\n'))
+                output.push('\');
+        }
+    }
+    const text = `${output.join('\n')}\n`;
+    if (Buffer.byteLength(text) > MAX_FILE_DIFF_BYTES)
+        throw new FileDiffLimitError();
+    return { text, additions, deletions };
+}
+function compare(a, b) {
+    let prefix = 0;
+    while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix])
+        prefix++;
+    let suffix = 0;
+    while (suffix < a.length - prefix &&
+        suffix < b.length - prefix &&
+        a[a.length - suffix - 1] === b[b.length - suffix - 1])
+        suffix++;
+    const left = a.slice(prefix, a.length - suffix);
+    const right = b.slice(prefix, b.length - suffix);
+    if (!left.length || !right.length)
+        return [
+            ...a.slice(0, prefix).map((text) => ({ kind: ' ', text })),
+            ...left.map((text) => ({ kind: '-', text })),
+            ...right.map((text) => ({ kind: '+', text })),
+            ...a.slice(a.length - suffix).map((text) => ({ kind: ' ', text }))
+        ];
+    const trace = [];
+    const frontier = new Map([[1, 0]]);
+    let work = 0;
+    for (let distance = 0; distance <= left.length + right.length; distance++) {
+        trace.push(new Map(frontier));
+        for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
+            if (++work > MAX_WORK)
+                return undefined;
+            const down = diagonal === -distance ||
+                (diagonal !== distance &&
+                    (frontier.get(diagonal - 1) ?? -1) < (frontier.get(diagonal + 1) ?? -1));
+            let x = down ? (frontier.get(diagonal + 1) ?? 0) : (frontier.get(diagonal - 1) ?? 0) + 1;
+            let y = x - diagonal;
+            while (x < left.length && y < right.length && left[x] === right[y]) {
+                if (++work > MAX_WORK)
+                    return undefined;
+                x++;
+                y++;
+            }
+            frontier.set(diagonal, x);
+            if (x < left.length || y < right.length)
+                continue;
+            const reversed = [];
+            for (let d = distance; d >= 0; d--) {
+                const previous = trace[d];
+                const k = x - y;
+                const previousK = k === -d || (k !== d && (previous.get(k - 1) ?? -1) < (previous.get(k + 1) ?? -1))
+                    ? k + 1
+                    : k - 1;
+                const previousX = previous.get(previousK) ?? 0;
+                const previousY = previousX - previousK;
+                while (x > previousX && y > previousY)
+                    (reversed.push({ kind: ' ', text: left[--x] }), y--);
+                if (d === 0)
+                    break;
+                if (x === previousX)
+                    reversed.push({ kind: '+', text: right[--y] });
+                else
+                    reversed.push({ kind: '-', text: left[--x] });
+            }
+            return [
+                ...a.slice(0, prefix).map((text) => ({ kind: ' ', text })),
+                ...reversed.reverse(),
+                ...a.slice(a.length - suffix).map((text) => ({ kind: ' ', text }))
+            ];
+        }
+    }
+    return undefined;
+}