rea-agents 6.2.0 → 6.4.0

package/dist/application/javascript/JavaScriptSemanticGraphValueProjection.js

@@ -1,4 +1,5 @@
 import { semanticContainer, semanticPropertyPointer, } from "../../domain/javascript/javascriptSemanticSlots.js";
+import { digestCanonicalValue } from "../../domain/canonicalDigest.js";
 import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { observedSemanticEvidence, unknownSemanticEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
@@ -72,17 +73,20 @@ const projectValue = (input) => {
                 detail: `Initializer container has unknown ${value.status === "object" ? "properties" : "items"}${container.coverage.omitted === null ? " with an unknown omitted count" : `; ${container.coverage.omitted} omitted`}.`,
                 candidate_node_ids: [target.node_id],
                 evidence: unknownSemanticEvidence(context.file, binding.definitions[0]?.location ?? null),
-            }));
+            }, context.state.evidenceContexts));
     }
-    else if (value.status === "unknown" && value.resourceLimit !== undefined) {
+    else if (value.status === "unknown" ||
+        value.status === "ambiguous" ||
+        value.status === "cycle") {
         const location = binding.definitions[0]?.location ?? null;
         const evidence = observedSemanticEvidence(context.file, location);
-        const isPropertyValue = role.startsWith("property:");
         addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
             node_id: target.node_id,
-            family: isPropertyValue ? "object-flow" : "data-flow",
-            relation_kinds: [isPropertyValue ? "writes-property" : "defines"],
-            reason: "resource-limit",
+            family: "data-flow",
+            relation_kinds: ["defines"],
+            reason: value.resourceLimit === undefined
+                ? "unknown-value"
+                : "resource-limit",
             detail: `${value.reason} Unknown value at ${role}.`,
             candidate_node_ids: [target.node_id],
             evidence: {
@@ -92,17 +96,27 @@ const projectValue = (input) => {
                 confidence: "unknown",
                 limitations: [value.reason],
             },
-        }));
+        }, context.state.evidenceContexts));
     }
 };
-const addLiteralNode = (context, binding, value, role) => retainSemanticGraphNode(context.state, context.file, {
-    kind: "literal",
-    roleKey: `literal:${binding.bindingId}:${role}:${JSON.stringify(value)}`,
-    location: binding.definitions[0]?.location ?? null,
-    label: JSON.stringify(value),
-    functionNodeId: context.bindingNodes.get(binding.bindingId)?.function_node_id ?? null,
-    properties: { value },
-});
+const addLiteralNode = (context, binding, value, role) => {
+    const encodedValue = JSON.stringify(value);
+    const valueDigest = `value-sha256:${digestCanonicalValue(value, "Semantic literal")}`;
+    const valueKey = encodedValue.length <= valueDigest.length ? encodedValue : valueDigest;
+    const stringLabel = "string literal";
+    return retainSemanticGraphNode(context.state, context.file, {
+        kind: "literal",
+        // Identity needs an exact value commitment, not another payload copy.
+        // Keep the complete literal in properties for queries and Evidence export.
+        roleKey: `literal:${binding.bindingId}:${role}:${valueKey}`,
+        location: binding.definitions[0]?.location ?? null,
+        label: typeof value === "string" && encodedValue.length > stringLabel.length
+            ? stringLabel
+            : encodedValue,
+        functionNodeId: context.bindingNodes.get(binding.bindingId)?.function_node_id ?? null,
+        properties: { value },
+    });
+};
 /** Create one canonical slot for a root binding and exact static property path. */
 export const semanticPropertySlot = (context, objectBindingId, path, fact) => retainSemanticGraphNode(context.state, context.file, {
     kind: "property-slot",

package/dist/application/javascript/JavaScriptSemanticTraceService.js

@@ -1,25 +1,30 @@
 import { z } from "zod";
 import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
 import {} from "../../domain/analysisErrorBase.js";
+import { applicationGraphEvidenceInputError, parseApplicationGraphEvidence, } from "./JavaScriptApplicationEvidenceGraph.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { queryJavaScriptSemanticGraph } from "../../domain/javascript/javascriptSemanticQuery.js";
 import { javaScriptSemanticTraceResultSchema, traceJavaScriptSemanticsInputSchema, } from "../../domain/javascript/javascriptSemanticTraceSchemas.js";
 import { err, ok } from "../../domain/result.js";
-import { parseApplicationGraphEvidence } from "./JavaScriptApplicationEvidenceGraph.js";
 import { createJavaScriptSemanticTraceEvidence } from "./JavaScriptApplicationWorkflowEvidence.js";
 const OPERATION = "trace_javascript_semantics";
 /** Trace semantic relations from input already parsed by a trusted adapter. */
 export const traceJavaScriptSemanticsEvidenceValidated = (input) => {
+    const sourceResult = parseApplicationGraphEvidence(input.application, [
+        "application",
+    ]);
+    if (!sourceResult.ok)
+        return err(applicationGraphEvidenceInputError(OPERATION, sourceResult.error));
+    const source = sourceResult.value;
+    if (source.semanticGraph === null)
+        return err(new AnalysisInputError(OPERATION, undefined, [
+            {
+                path: ["application"],
+                reason: "invalid_value",
+                expected: "inline Evidence from analyze_javascript_application with a semantic graph",
+            },
+        ]));
     try {
-        const source = parseApplicationGraphEvidence(input.application);
-        if (source.semanticGraph === null)
-            return err(new AnalysisInputError(OPERATION, undefined, [
-                {
-                    path: ["application"],
-                    reason: "invalid_value",
-                    expected: "inline Evidence from analyze_javascript_application with a semantic graph",
-                },
-            ]));
         const query = queryJavaScriptSemanticGraph(source.semanticGraph, input.query);
         const result = javaScriptSemanticTraceResultSchema.parse({
             ...query,

package/dist/application/jeb/JebAnalysisPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/jeb/JebAnalysisService.js

@@ -0,0 +1,13 @@
+import { jebRequestSchema, } from "../../domain/jeb/jebAnalysis.js";
+import { executeProviderOperation } from "../ProviderOperationExecution.js";
+/** Shared CLI/MCP admission, execution and Evidence composition for JEB. */
+export class JebAnalysisService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Run one caller-selected JEB request and retain engine provenance inline. */
+    async execute(operation, input, options) {
+        return executeProviderOperation(operation, input, options, jebRequestSchema, this.provider, operation === "decompile_jeb_item" ? "derived" : "observed");
+    }
+}

package/dist/application/managed/ManagedApplicationGraphService.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
 import {} from "../../domain/analysisErrorBase.js";
-import { createEvidence } from "../../domain/evidence.js";
+import { createEvidence, } from "../../domain/evidence.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { managedApplicationGraphResultSchema, projectManagedApplicationGraph, projectManagedApplicationGraphInputSchema, } from "../../domain/managed/managedApplicationGraph.js";
 import { err, ok } from "../../domain/result.js";

package/dist/application/native/NativeCallRoutes.js

@@ -3,16 +3,14 @@ import { parseRelatedAddresses, referenceKindSchema, } from "../../domain/hopper
 import { err, ok } from "../../domain/result.js";
 import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
 const referencesSchema = z.object({
-    reference_kinds_available: z.boolean().optional(),
+    reference_kinds_available: z.boolean(),
     references: z.array(z.object({
         source_address: z.string(),
         target_address: z.string(),
         target_procedure: z.object({ address: z.string() }).nullable(),
         kind: referenceKindSchema,
     })),
-    unresolved_calls: z
-        .array(z.object({ address: z.string(), reason: z.string() }))
-        .default([]),
+    unresolved_calls: z.array(z.object({ address: z.string(), reason: z.string() })),
 });
 /** Prefer typed static call references, preserving computed targets and targetless sites. */
 export const readNativeCallRoutes = async (analysis, procedure, signal) => {

package/dist/application/native/NativeUiActionTrace.js

@@ -35,14 +35,23 @@ export const traceNativeUiAction = async (analysis, input, signal) => {
         if (decoded.data.target_sha256 !== targetSha256)
             return err(new AnalysisOutputError("decode_interface_builder", "UI and native provider results refer to different target SHA-256 values"));
         graph = joinInterfaceBuilderDispatch(decoded.data.graph, metadata.result);
+        const archiveDecode = decoded.data.graph.coverage.find((facet) => facet.facet === "archive_decode");
+        const documentsFound = decoded.data.documents.length > 0;
         coverage.push({
             facet: "interface_builder_archives",
-            status: decoded.data.documents.length > 0 ? "complete" : "unsupported",
-            reason: decoded.data.documents.length > 0
-                ? null
-                : "no_compiled_interface_builder_archives_found",
-            examined: decoded.data.documents.length,
-            omitted: 0,
+            status: archiveDecode?.status === "partial" ||
+                archiveDecode?.status === "complete" ||
+                archiveDecode?.status === "unsupported"
+                ? archiveDecode.status
+                : documentsFound
+                    ? "complete"
+                    : "unsupported",
+            reason: archiveDecode?.reason ??
+                (documentsFound
+                    ? null
+                    : "no_compiled_interface_builder_archives_found"),
+            examined: archiveDecode?.examined ?? decoded.data.documents.length,
+            omitted: archiveDecode?.omitted ?? 0,
         });
         const bounded = boundUiGraph(graph, input.max_nodes, input.max_edges);
         graph = bounded.graph;
@@ -218,8 +227,7 @@ const resolveUiAction = (graph, query) => {
         };
     const objectMatches = graph.nodes.filter((node) => ["control", "view", "view_controller", "scene"].includes(node.kind) &&
         (node.id === query ||
-            node.attributes.interface_builder_object_id === query ||
-            node.id.endsWith(`:object:${query}`)));
+            node.attributes.interface_builder_object_id === query));
     const actionIds = new Set(graph.edges.flatMap((edge) => edge.resolution === "observed" &&
         edge.relation === "target_action" &&
         objectMatches.some(({ id }) => edge.from === id) &&

package/dist/application/native/NativeValueTrace.js

@@ -8,6 +8,7 @@ import { err, ok } from "../../domain/result.js";
 export const traceNativeValues = async (analysis, parameters, signal) => {
     const input = nativeValueTraceInputSchema.parse(parameters);
     const nodes = [];
+    const nodeIds = new Set();
     const edges = [];
     const procedures = [];
     const unknowns = [];
@@ -116,24 +117,27 @@ export const traceNativeValues = async (analysis, parameters, signal) => {
             bytes += size;
             ids.add(operation.id);
             nodes.push(node);
+            nodeIds.add(node.id);
         }
         for (const parameter of flow.parameters) {
             if (nodes.length >= input.max_nodes) {
                 truncated = true;
                 break;
             }
+            const id = `${address}/parameter:${parameter.ordinal}`;
             nodes.push({
-                id: `${address}/parameter:${parameter.ordinal}`,
+                id,
                 procedure: address,
                 evidence_id: evidenceId,
                 kind: "parameter",
                 operation: null,
                 parameter,
             });
+            nodeIds.add(id);
         }
         for (const use of flow.parameter_uses) {
             if (!ids.has(use.use) ||
-                !nodes.some((node) => node.id === `${address}/parameter:${use.ordinal}`))
+                !nodeIds.has(`${address}/parameter:${use.ordinal}`))
                 continue;
             if (edges.length >= input.max_edges) {
                 truncated = true;
@@ -243,8 +247,23 @@ export const traceNativeValues = async (analysis, parameters, signal) => {
     }
     if (targetSha256 === undefined)
         return err(new AnalysisOutputError("trace_native_values", "No seed function could be analyzed"));
+    const parametersByProcedure = new Map();
+    const returnsByProcedure = new Map();
+    for (const node of nodes) {
+        if (node.kind === "parameter") {
+            const parameters = parametersByProcedure.get(node.procedure) ?? [];
+            parameters.push(node);
+            parametersByProcedure.set(node.procedure, parameters);
+        }
+        else if (node.operation?.opcode === "RETURN" &&
+            node.operation.inputs.length > 1) {
+            const returns = returnsByProcedure.get(node.procedure) ?? [];
+            returns.push(node);
+            returnsByProcedure.set(node.procedure, returns);
+        }
+    }
     for (const binding of callBindings) {
-        const parameters = nodes.filter((node) => node.procedure === binding.callee && node.kind === "parameter");
+        const parameters = parametersByProcedure.get(binding.callee) ?? [];
         if (parameters.length === 0)
             unknowns.push({
                 procedure: binding.caller,
@@ -275,9 +294,7 @@ export const traceNativeValues = async (analysis, parameters, signal) => {
             });
         }
         if (binding.output)
-            for (const node of nodes.filter((node) => node.procedure === binding.callee &&
-                node.operation?.opcode === "RETURN" &&
-                node.operation.inputs.length > 1)) {
+            for (const node of returnsByProcedure.get(binding.callee) ?? []) {
                 if (edges.length >= input.max_edges) {
                     truncated = true;
                     break;

package/dist/application/process/ProcessCli.js

@@ -1,4 +1,3 @@
-import { readFile } from "node:fs/promises";
 import { z } from "zod";
 import { AnalysisError } from "../../domain/analysisErrorBase.js";
 import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
@@ -11,9 +10,12 @@ import { processTraceSpecificationSchema } from "../../domain/process/processTra
 import { processScenarioSchema } from "../../domain/process/processScenario.js";
 import { compareProcessCaptures } from "../../domain/process/processComparison.js";
 import { parseProcessCapture } from "../../domain/process/processCaptureParsing.js";
+import { createProgressReporter } from "../ProgressReporter.js";
 import { captureProcessScenario } from "../../process/capture/ProcessHarness.js";
+import { ProcessCaptureResourceScope } from "../../process/capture/ProcessCaptureLifecycle.js";
 import { PROCESS_PROVIDER } from "../../domain/process/processEvidenceProvider.js";
 import { createProcessCaptureEvidence } from "./ProcessEvidence.js";
+import { readJsonFile } from "../JsonFiles.js";
 /** Identify the process workflow's typed diagnostic result for CLI exit status. */
 export const isProcessCliFailure = (value) => typeof value === "object" &&
     value !== null &&
@@ -30,7 +32,19 @@ export const captureProcessScenarioFile = async (path, environment = process.env
         const parsed = processScenarioSchema.safeParse(input);
         if (!parsed.success)
             throw analysisInputErrorFromIssues("capture_process_scenario", parsed.error.issues, input, { cause: parsed.error });
-        const captured = await captureProcessScenario(parsed.data, signal, process.platform, environment);
+        const progress = createProgressReporter(async (update) => {
+            process.stderr.write(`${JSON.stringify({ rea_progress: update })}\n`);
+        }, { minimumIntervalMs: 100 });
+        const resourceScope = new ProcessCaptureResourceScope();
+        const captured = await captureProcessScenario(parsed.data, signal, process.platform, environment, undefined, undefined, progress, resourceScope);
+        try {
+            await resourceScope.close();
+        }
+        catch (cause) {
+            if (!captured.ok)
+                return cliAnalysisError(captured.error);
+            throw cause;
+        }
         if (!captured.ok)
             return cliAnalysisError(captured.error);
         return createProcessCaptureEvidence(parsed.data, captured.value);
@@ -115,24 +129,15 @@ const parseTraceSpecification = (input) => {
 };
 const invalidCaptureEvidence = (cause) => new ProcessCliFailure("invalid_input", `Capture evidence is malformed (${describeValidationFailure(cause)}). Create new capture evidence, then try again.`);
 const readJson = async (path) => {
-    let bytes;
-    try {
-        bytes = await readFile(path);
-    }
-    catch (cause) {
-        throw new ProcessCliFailure("invalid_input", `Process input file could not be read: ${path} (${describeValidationFailure(cause)}). Check the reported filesystem constraint and retry.`);
-    }
-    try {
-        const text = new TextDecoder("utf-8", {
-            fatal: true,
-            ignoreBOM: true,
-        }).decode(bytes);
-        const parsed = JSON.parse(text);
-        return parsed;
-    }
-    catch (cause) {
-        throw new ProcessCliFailure("invalid_input", `Process input file is not valid UTF-8 JSON: ${path} (${describeValidationFailure(cause)}). Repair the file, then try again.`);
-    }
+    const loaded = await readJsonFile(path);
+    if (loaded.ok)
+        return loaded.value;
+    if (loaded.error._tag !== "EvidenceFileError")
+        throw loaded.error;
+    const detail = describeValidationFailure(loaded.error.cause);
+    throw new ProcessCliFailure("invalid_input", loaded.error.reason === "invalid-json"
+        ? `Process input file is not valid UTF-8 JSON: ${path} (${detail}). Repair the file, then try again.`
+        : `Process input file could not be read: ${path} (${detail}). Check the reported filesystem constraint and retry.`);
 };
 class ProcessCliFailure extends Error {
     category;

package/dist/artifacts/ArtifactPaths.js

@@ -1,6 +1,17 @@
 import { posix } from "node:path";
+import { logicalPathNfc } from "../domain/artifactIdentity.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 import { ArtifactReaderFailure } from "./ArtifactReader.js";
 const DRIVE_OR_UNC = /^(?:[A-Za-z]:|\\|\/\/)/u;
+/**
+ * English Unicode case folding used only to describe logical names a
+ * case-insensitive destination might collapse. It is not a filesystem case table.
+ */
+const ENGLISH_UNICODE_CASE_NOTE = "This comparison is not a filesystem observation.";
+/** Inventory limitation when logical names collide under English Unicode case folding. */
+export const ENGLISH_UNICODE_CASE_INVENTORY_LIMITATION = `Logical archive names collide under English (en-US) Unicode case folding; a case-insensitive destination cannot store both spellings. ${ENGLISH_UNICODE_CASE_NOTE}`;
+/** User-facing prefix for a destination that cannot keep two logical spellings. */
+export const DESTINATION_CASE_COLLISION_PREFIX = "Destination filesystem cannot store both ";
 /** Normalize an untrusted logical archive path without touching filesystem. */
 export const normalizeArtifactPath = (input) => {
     if (input.includes("\0") ||
@@ -8,7 +19,7 @@ export const normalizeArtifactPath = (input) => {
         input.startsWith("/") ||
         DRIVE_OR_UNC.test(input))
         throw new ArtifactReaderFailure("path", `Artifact path is absolute or unsafe: ${JSON.stringify(input)}`);
-    const normalized = input.normalize("NFC").replace(/\/+$/u, "");
+    const normalized = logicalPathNfc(input).replace(/\/+$/u, "");
     const parts = normalized.split("/");
     if (normalized.length === 0 ||
         parts.some((part) => part === "" || part === "." || part === "..") ||
@@ -16,7 +27,7 @@ export const normalizeArtifactPath = (input) => {
         throw new ArtifactReaderFailure("path", `Artifact path is not normalized: ${JSON.stringify(input)}`);
     return normalized;
 };
-/** Reject exact, Unicode-normalized, case-folded, and prefix collisions. */
+/** Reject exact and same-spelling prefix collisions. Case-distinct names stay distinct. */
 export class ArtifactPathRegistry {
     #root = { kind: undefined, children: new Map() };
     add(path, kind) {
@@ -25,13 +36,10 @@ export class ArtifactPathRegistry {
         for (const [index, part] of parts.entries()) {
             if (node.kind !== undefined && node.kind !== "directory")
                 throw new ArtifactReaderFailure("path", `Artifact prefix conflict: ${path}`);
-            const foldedPart = part.toLocaleLowerCase("en-US");
-            let child = node.children.get(foldedPart);
-            if (child !== undefined && child.spelling !== part)
-                throw new ArtifactReaderFailure("path", `Artifact path collision: ${path} differs only in case from ${[...parts.slice(0, index), child.spelling].join("/")}`);
+            let child = node.children.get(part);
             if (child === undefined) {
-                child = { spelling: part, kind: undefined, children: new Map() };
-                node.children.set(foldedPart, child);
+                child = { kind: undefined, children: new Map() };
+                node.children.set(part, child);
             }
             node = child;
             if (index === parts.length - 1) {
@@ -44,3 +52,116 @@ export class ArtifactPathRegistry {
         node.kind = kind;
     }
 }
+const emptyCaseNode = () => ({
+    bySpelling: new Map(),
+    spellingsByFold: new Map(),
+    terminals: [],
+});
+const englishCaseFold = (part) => part.toLocaleLowerCase("en-US");
+/**
+ * Record English (en-US) Unicode case collisions on each affected occurrence.
+ * Returns the inventory limitation when any logical names collide.
+ */
+export const annotateEnglishUnicodeCaseCollisions = (occurrences) => {
+    const collisions = englishUnicodeCaseCollisions(occurrences.map(({ logical_path }) => logical_path));
+    if (collisions.size === 0)
+        return undefined;
+    for (const occurrence of occurrences)
+        for (const collision of collisions.get(occurrence.logical_path) ?? [])
+            occurrence.limitations.push(caseCollisionLimitation(occurrence.logical_path, collision));
+    return ENGLISH_UNICODE_CASE_INVENTORY_LIMITATION;
+};
+const caseCollisionLimitation = (path, { prefix, other, additional }) => {
+    const others = additional === 0
+        ? other
+        : `${other} and ${String(additional)} other spelling${additional === 1 ? "" : "s"}`;
+    const subject = prefix === path
+        ? `Logical path ${path} collides`
+        : `Logical path ${path} is under ${prefix}, which collides`;
+    return `${subject} under English (en-US) Unicode case folding with ${others}; a case-insensitive destination cannot store both. ${ENGLISH_UNICODE_CASE_NOTE}`;
+};
+/**
+ * Name the directory-listing spelling that differs from the requested segment
+ * only by English (en-US) Unicode case. Exact matches are the same logical name.
+ */
+export const destinationCaseCollisionMessage = (requestedPath, existingNames) => {
+    const slash = requestedPath.lastIndexOf("/");
+    const segment = slash < 0 ? requestedPath : requestedPath.slice(slash + 1);
+    if (existingNames.includes(segment))
+        return undefined;
+    const folded = englishCaseFold(segment);
+    const existing = existingNames
+        .filter((name) => englishCaseFold(name) === folded)
+        .sort(compareUnicodeCodePoints)[0];
+    if (existing === undefined)
+        return undefined;
+    const parent = slash < 0 ? "" : requestedPath.slice(0, slash + 1);
+    return `${DESTINATION_CASE_COLLISION_PREFIX}${requestedPath} and ${parent}${existing}; inventory retains both logical names.`;
+};
+const englishUnicodeCaseCollisions = (paths) => {
+    const root = emptyCaseNode();
+    for (const path of paths) {
+        if (path.length === 0 || path === ".")
+            continue;
+        let node = root;
+        for (const part of path.split("/")) {
+            let child = node.bySpelling.get(part);
+            if (child === undefined) {
+                const folded = englishCaseFold(part);
+                const spellings = node.spellingsByFold.get(folded);
+                if (spellings === undefined)
+                    node.spellingsByFold.set(folded, [part]);
+                else
+                    spellings.push(part);
+                child = emptyCaseNode();
+                node.bySpelling.set(part, child);
+            }
+            node = child;
+        }
+        node.terminals.push(path);
+    }
+    // A collision is recorded once, at the segment where spellings diverge, and
+    // shared down the subtree. Pairing every descendant of one spelling with
+    // every descendant of another grew quadratically with the subtree sizes.
+    // The walk is iterative because a ZIP name can hold more components than
+    // the call stack allows.
+    const collisions = new Map();
+    const pending = [{ node: root, prefix: undefined, chain: undefined }];
+    for (let item = pending.pop(); item !== undefined; item = pending.pop()) {
+        const { node, prefix, chain } = item;
+        if (chain !== undefined)
+            for (const path of node.terminals)
+                collisions.set(path, collisionsAlong(chain));
+        for (const spellings of node.spellingsByFold.values())
+            spellings.sort(compareUnicodeCodePoints);
+        for (const [spelling, child] of node.bySpelling) {
+            const childPrefix = prefix === undefined ? spelling : `${prefix}/${spelling}`;
+            const spellings = node.spellingsByFold.get(englishCaseFold(spelling)) ?? [];
+            const other = spellings[0] === spelling ? spellings[1] : spellings[0];
+            pending.push({
+                node: child,
+                prefix: childPrefix,
+                chain: other === undefined
+                    ? chain
+                    : {
+                        collision: {
+                            prefix: childPrefix,
+                            other: prefix === undefined ? other : `${prefix}/${other}`,
+                            additional: spellings.length - 2,
+                        },
+                        parent: chain,
+                    },
+            });
+        }
+    }
+    return collisions;
+};
+const collisionsAlong = (chain) => {
+    const collisions = [];
+    let link = chain;
+    while (link !== undefined) {
+        collisions.push(link.collision);
+        link = link.parent;
+    }
+    return collisions.reverse();
+};