Files
reverse-engineering-anything/src/domain/analysisView/analysisView.test.ts
T
morluto b138f52e12 refactor: prune internal seams and preserve configuration ownership (#10430)
* refactor: prune internal seams and preserve configuration ownership

* fix(setup): keep YAML aliases and inherited registration settings on refresh

- Reuse an unchanged YAML collection only while every alias in it still
  resolves after the edit; otherwise rebuild it so the alias becomes its
  value. A sibling anchor replaced or moved in the same refresh no longer
  leaves an unresolved alias in Hermes or Goose output.
- Keep a connection selector whose existing value already chooses stdio
  (for example an inherited Hermes transport: stdio) instead of superseding
  it; remote selectors are still replaced. Explicit stdio selectors are
  therefore no longer rewritten (Kimi expectation updated).
- When the whole Hermes registration is inherited through a merge,
  override it with that merge and write only the changed fields.

* fix(setup): edit registration fields whose YAML key is an alias

A key written as an alias to a string scalar (for example *field with
field: &field env) was treated as a source-only key, so any change to
its value was refused in Hermes and Goose. Resolve such keys to their
string, keep the aliased spelling while its anchor survives the edit,
and write the plain key when the same edit rebuilds the anchor.

* test(process): bound cleanup-boundary waits and always release gates

Both cancellation tests awaited a bare started promise and released
their gates only on success, so a missed boundary waited for the outer
deadline and could leave cleanup parked. Use awaitAcknowledgement and
release and join the cleanup in finally.

* fix(setup): repair only aliases an edit leaves unresolved

Replace the pre-edit alias survival guess, which expanded aliases to
sibling anchors that survive unchanged, with an exact repair: record
what each alias in the replaced value resolves to, write the edit, then
replace only aliases left without a preceding anchor by that value.

- Keep an aliased key's source position, so its anchor stays ahead of
  later aliases.
- Treat an aliased key as its string only when no other key in the map
  resolves to the same string; an ambiguous one stays guarded.
- Override an inherited Hermes registration only when the requested
  entry keeps every inherited field, so an explicit replacement can drop
  remote selectors.

* fix(setup): repair aliases whose binding an edit changes, keeping comments

An alias whose own anchor was removed could resolve to an earlier anchor
with the same name and silently change value. Record the node each alias
resolved to and repair any alias that no longer resolves to that node.
Carry the alias's comments and spacing onto the repaired value.

* test(setup): split the Hermes anchor and merge refresh cases

* fix(setup): refuse removing an overridden key its merge would restore

The merge-retention check skipped keys the mapping also overrides, so
dropping such a key (for example a remote url during an explicit stdio
replacement) let the retained merge restore it. Check removal before
skipping overridden keys, so the edit is refused with the existing
message instead of producing a registration that cannot be applied.
2026-11-14 04:08:37 -05:00

1808 lines
56 KiB
TypeScript

import {
boundedViewMessages,
completeWithinViewCoverage,
pageViewCoverage,
} from "./analysisViewCoverage.js";
import { expect, it } from "vitest";
import { functionDossierSchema } from "../native/functionDossier.js";
import { ghidraFunctionDossier } from "../ghidraValues.fixture.js";
import { JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE } from "../../contracts/javascript/javascriptRuntimeReconciliationExample.js";
import { ARTIFACT_COMPARISON_EXAMPLE } from "../../contracts/artifactComparisonExample.js";
import {
analysisViewBindJavaScriptGraphs,
analysisViewJavaScriptAnalysis,
analysisViewJavaScriptAnalysisWithSource,
analysisViewLayoutEvidence,
analysisViewLayoutFixture,
} from "../../../tests/fixtures/analysisView.js";
import {
createJavaScriptApplicationGraph,
createJavaScriptApplicationNode,
createImmutableJavaScriptApplicationGraphSteps,
} from "../javascript/javascriptApplicationGraph.js";
import {
createJavaScriptSemanticGraph,
sealTransferredJavaScriptSemanticGraphSteps,
} from "../javascript/javascriptSemanticGraph.js";
import { sourceMapReference } from "../javascript/javascriptApplicationGraph.fixture.js";
import { createArtifactInspection } from "../artifactInspection.js";
import { inspectAnalysisViewInputSchema } from "./analysisViewRequest.js";
import { projectAnalysisView } from "./analysisView.js";
import type { AnalysisViewParent } from "./analysisViewParent.js";
import { analysisViewResultSchema } from "./analysisViewResult.js";
const layoutParent = (): AnalysisViewParent => {
const evidence = analysisViewLayoutEvidence();
return {
predicateType: evidence.predicate_type,
evidenceId: evidence.evidence_id,
operation: evidence.operation,
normalizedResult: evidence.normalized_result,
limitations: evidence.limitations,
};
};
const javascriptParent = (
analysis = analysisViewJavaScriptAnalysis(),
): AnalysisViewParent => ({
predicateType: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE.predicate_type,
evidenceId: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE.evidence_id,
operation: "analyze_javascript_application",
normalizedResult: analysis,
limitations: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE.limitations,
});
const nativeParent = (
result: unknown = ghidraFunctionDossier(),
): AnalysisViewParent => ({
predicateType: "rea.analysis",
evidenceId: "ev_" + "b".repeat(64),
operation: "analyze_function",
normalizedResult: result,
limitations: ["Retained provider limitation"],
artifact: { path: "/fixtures/example.exe", sha256: "a".repeat(64) },
});
it("returns input errors for malformed parent Evidence identifiers before projection", () => {
for (const evidenceId of [`xx_${"a".repeat(64)}`, "ev_bad"])
expect(
projectAnalysisView(
{ ...nativeParent(), evidenceId },
{ kind: "summary" },
),
).toMatchObject({ ok: false, error: { _tag: "AnalysisInputError" } });
expect(projectAnalysisView(nativeParent(), { kind: "summary" }).ok).toBe(
true,
);
});
it("projects native procedure and bounded assembly and high-pcode with exact parent identity", () => {
const parent = nativeParent();
const procedure = projectAnalysisView(parent, {
kind: "native",
facet: "procedure",
offset: 0,
limit: 64,
});
if (!procedure.ok) throw procedure.error;
expect(procedure.value).toMatchObject({
kind: "native",
parent_operation: "analyze_function",
artifact: parent.artifact,
item: { address: "0x401000" },
});
expect(procedure.value.view_digest).not.toBe(parent.evidenceId.slice(3));
const assembly = projectAnalysisView(parent, {
kind: "native",
facet: "assembly",
offset: 0,
limit: 1,
});
if (!assembly.ok) throw assembly.error;
expect(assembly.value).toMatchObject({
coverage: { examined: 1, total: 2, next_offset: 1 },
item: ["0x401000: CALL 0x401020"],
});
const flow = projectAnalysisView(parent, {
kind: "native",
facet: "value_flow_operations",
offset: 0,
limit: 1,
});
if (!flow.ok) throw flow.error;
expect(flow.value).toMatchObject({ item: [{ opcode: "COPY" }] });
});
it("projects a compact analyze_function summary that validates and retains the dossier", () => {
const parent = nativeParent();
const summary = projectAnalysisView(parent, { kind: "summary" });
if (!summary.ok) throw summary.error;
const validated = analysisViewResultSchema.parse(summary.value);
expect(validated).toMatchObject({
kind: "summary",
parent_operation: "analyze_function",
parent_evidence_id: parent.evidenceId,
artifact: parent.artifact,
summary: {
procedure: { address: "0x401000" },
pseudocode: { available: true },
value_flow: { available: true },
facet_availability: { references: { available: true } },
counts: { assembly: 2, incoming_references: 0 },
},
});
});
it("keeps omitted optional dossier records unknown in the analyze_function summary", () => {
const dossier = functionDossierSchema.parse(ghidraFunctionDossier());
// The fixture omits unresolved_calls and Swift literals, as IDA and Kuna
// dossiers and non-Swift targets do: their counts are unknown, not zero.
const omitted = projectAnalysisView(nativeParent(dossier), {
kind: "summary",
});
if (!omitted.ok) throw omitted.error;
expect(analysisViewResultSchema.parse(omitted.value)).toMatchObject({
summary: {
counts: {
unresolved_calls: null,
swift_string_literals: null,
swift_string_literal_omissions: null,
},
},
unknowns: expect.arrayContaining([
"unresolved_calls not recorded",
"swift_string_literals not recorded",
"swift_string_literal_omissions not recorded",
]),
});
const recorded = projectAnalysisView(
nativeParent({
...dossier,
unresolved_calls: [{ address: "0x401010", reason: "indirect call" }],
swift_string_literals: [],
swift_string_literal_omissions: [],
}),
{ kind: "summary" },
);
if (!recorded.ok) throw recorded.error;
expect(analysisViewResultSchema.parse(recorded.value)).toMatchObject({
summary: {
counts: {
unresolved_calls: 1,
swift_string_literals: 0,
swift_string_literal_omissions: 0,
},
},
});
expect(recorded.value.unknowns).not.toContain(
"unresolved_calls not recorded",
);
expect(recorded.value.unknowns).not.toContain(
"swift_string_literals not recorded",
);
});
it("keeps value-flow counts unknown when value flow is unrecorded or unavailable", () => {
const dossier = functionDossierSchema.parse(ghidraFunctionDossier());
const flowCounts = {
value_flow_operations: null,
value_flow_def_use: null,
value_flow_effects: null,
value_flow_parameters: null,
value_flow_parameter_uses: null,
};
// IDA and Kuna dossiers record no value flow at all.
const unrecorded = projectAnalysisView(
nativeParent({ ...dossier, native_value_flow: null }),
{ kind: "summary" },
);
if (!unrecorded.ok) throw unrecorded.error;
expect(analysisViewResultSchema.parse(unrecorded.value)).toMatchObject({
summary: {
value_flow: { available: false, truncated: false },
counts: flowCounts,
},
unknowns: expect.arrayContaining(["native_value_flow was not recorded"]),
});
// A Ghidra dossier can declare value flow unavailable with a reason.
const unavailable = projectAnalysisView(
nativeParent({
...dossier,
native_value_flow: {
available: false,
reason: "High p-code was not produced.",
limitations: [],
},
}),
{ kind: "summary" },
);
if (!unavailable.ok) throw unavailable.error;
expect(analysisViewResultSchema.parse(unavailable.value)).toMatchObject({
summary: { value_flow: { available: false }, counts: flowCounts },
unknowns: expect.arrayContaining([
"native_value_flow unavailable: High p-code was not produced.",
]),
});
// Available value flow keeps its observed counts, including empty ones.
const available = projectAnalysisView(nativeParent(dossier), {
kind: "summary",
});
if (!available.ok) throw available.error;
const flow = dossier.native_value_flow;
if (flow === null || !flow.available) throw new Error("fixture value flow");
expect(available.value).toMatchObject({
summary: {
value_flow: { available: true },
counts: {
value_flow_operations: flow.operations.length,
value_flow_def_use: flow.def_use.length,
value_flow_effects: flow.effects.length,
value_flow_parameters: flow.parameters.length,
value_flow_parameter_uses: flow.parameter_uses.length,
},
},
});
expect(flow.operations.length).toBeGreaterThan(0);
expect(available.value.unknowns).not.toContain(
"native_value_flow was not recorded",
);
});
it("keeps provider-unavailable facets unknown in the analyze_function summary", () => {
// A Kuna-style dossier: empty rows with explicit unavailability for several facets.
const dossier = functionDossierSchema.parse(ghidraFunctionDossier());
const unsupported = {
...dossier,
comments: [],
incoming_references: [],
outgoing_references: [],
basic_blocks: [],
facet_availability: {
...dossier.facet_availability,
comments: {
available: false,
reason: "Kuna exports no analyst comments.",
},
references: {
available: false,
reason: "This provider does not report typed references.",
},
cfg: { available: false, reason: "Kuna exports no basic blocks." },
},
};
const summary = projectAnalysisView(nativeParent(unsupported), {
kind: "summary",
});
if (!summary.ok) throw summary.error;
const validated = analysisViewResultSchema.parse(summary.value);
expect(validated).toMatchObject({
kind: "summary",
summary: {
facet_availability: unsupported.facet_availability,
counts: {
comments: null,
incoming_references: null,
outgoing_references: null,
basic_blocks: null,
// Declared-available facets keep their observed counts.
assembly: 2,
callers: 0,
referenced_strings: dossier.referenced_strings.length,
},
},
unknowns: expect.arrayContaining([
"comments unavailable: Kuna exports no analyst comments.",
"references unavailable: This provider does not report typed references.",
"cfg unavailable: Kuna exports no basic blocks.",
]),
});
// A dossier that declares nothing reports null availability and plain counts.
const { facet_availability: _declared, ...undeclared } = dossier;
const silent = projectAnalysisView(nativeParent(undeclared), {
kind: "summary",
});
if (!silent.ok) throw silent.error;
expect(silent.value).toMatchObject({
summary: { facet_availability: null, counts: { comments: 0 } },
});
});
it("rejects invalid native parents, unsupported source operations and singleton offsets", () => {
const view = {
kind: "native",
facet: "assembly",
offset: 0,
limit: 4,
} as const;
expect(projectAnalysisView(nativeParent({}), view)).toMatchObject({
ok: false,
error: { _tag: "AnalysisInputError" },
});
expect(
projectAnalysisView({ ...nativeParent(), artifact: null }, view),
).toMatchObject({
ok: false,
error: { _tag: "AnalysisInputError" },
});
expect(projectAnalysisView(layoutParent(), view)).toMatchObject({
ok: false,
error: { _tag: "AnalysisInputError" },
});
expect(projectAnalysisView(javascriptParent(), view)).toMatchObject({
ok: false,
error: { _tag: "AnalysisInputError" },
});
expect(
projectAnalysisView(nativeParent(), {
kind: "native",
facet: "procedure",
offset: 1,
limit: 2,
}),
).toMatchObject({ ok: false, error: { _tag: "AnalysisInputError" } });
});
it("preserves native API limitations and unavailable residual unknowns", () => {
const original = functionDossierSchema.parse(ghidraFunctionDossier());
const view = {
kind: "native",
facet: "procedure",
offset: 0,
limit: 64,
} as const;
const unavailable = projectAnalysisView(
nativeParent({
...original,
native_api: {
available: false,
reason: "No decompiler",
residual_unknowns: ["Calling convention unresolved"],
},
}),
view,
);
if (!unavailable.ok) throw unavailable.error;
expect(unavailable.value.unknowns).toContain("Calling convention unresolved");
const available = projectAnalysisView(nativeParent(), view);
if (!available.ok) throw available.error;
if (!original.native_api?.available) throw new Error("expected API fixture");
expect(available.value.limitations).toEqual(
expect.arrayContaining(original.native_api.limitations),
);
});
it("rejects artifact summary views when inspection substep coverage count disagrees", () => {
const source = ARTIFACT_COMPARISON_EXAMPLE.left;
const inspection = createArtifactInspection(source);
const parent: AnalysisViewParent = {
predicateType: "rea.analysis",
evidenceId: `ev_${"a".repeat(64)}`,
operation: "inspect_artifact",
normalizedResult: {
...inspection,
coverage: {
...inspection.coverage,
substeps_completed: inspection.substeps.length + 1,
},
},
subject: source.subject,
limitations: [],
};
expect(projectAnalysisView(parent, { kind: "summary" })).toMatchObject({
ok: false,
error: { _tag: "AnalysisInputError" },
});
});
it("pages every retained dossier collection and the native API record", () => {
const original = functionDossierSchema.parse(ghidraFunctionDossier());
const page = (
facet:
| "basic_blocks"
| "comments"
| "unresolved_calls"
| "referenced_strings"
| "referenced_names"
| "swift_string_literals",
result: unknown = original,
) => {
const view = projectAnalysisView(nativeParent(result), {
kind: "native",
facet,
offset: 0,
limit: 64,
});
if (!view.ok) throw view.error;
return view.value;
};
expect(page("basic_blocks")).toMatchObject({
item: original.basic_blocks,
coverage: { total: original.basic_blocks.length, exhausted: true },
});
expect(page("referenced_strings")).toMatchObject({
item: original.referenced_strings,
});
expect(
page("comments", {
...original,
comments: [{ address: "0x401000", kind: "comment", text: "entry" }],
}),
).toMatchObject({ item: [{ text: "entry" }] });
expect(page("referenced_names")).toMatchObject({ coverage: { total: 0 } });
const literal = {
source_address: "0x401004",
value: "SleepDisabled",
representation: "small",
address: null,
registers: ["x0", "x1"],
words: ["0x7369447065656c53", "0xed000064656c6261"],
};
expect(
page("swift_string_literals", {
...original,
swift_string_literals: [literal],
swift_string_literal_omissions: [],
}),
).toMatchObject({ item: [literal], coverage: { total: 1 } });
expect(page("swift_string_literals")).toMatchObject({
item: { available: false, reason: "not recorded" },
});
const { unresolved_calls: _omitted, ...withoutUnresolved } = original;
expect(
page("unresolved_calls", {
...withoutUnresolved,
native_value_flow: {
available: false,
reason: "No high p-code",
limitations: [],
},
}),
).toMatchObject({ item: { available: false, reason: "not recorded" } });
const api = projectAnalysisView(nativeParent(), {
kind: "native",
facet: "native_api",
offset: 0,
limit: 64,
});
if (!api.ok) throw api.error;
expect(api.value).toMatchObject({
item: original.native_api,
coverage: { status: "complete-within-view" },
});
});
it("reports the malformed native dossier field", () => {
const result = projectAnalysisView(
nativeParent({
...functionDossierSchema.parse(ghidraFunctionDossier()),
pseudocode: 12,
}),
{
kind: "native",
facet: "pseudocode",
offset: 0,
limit: 64,
},
);
expect(result).toMatchObject({
ok: false,
error: {
issues: expect.arrayContaining([
expect.objectContaining({
path: ["source", "normalized_result", "pseudocode"],
}),
]),
},
});
});
it.each(["inspect_binary_layout", "inspect_byte_entropy"] as const)(
"retains owning field correction paths for empty %s parents",
(operation) => {
expect(
projectAnalysisView(
{ ...layoutParent(), operation, normalizedResult: {} },
{ kind: "summary" },
),
).toMatchObject({
ok: false,
error: {
issues: expect.arrayContaining([
expect.objectContaining({
path: ["source", "normalized_result", "artifact"],
reason: "missing_argument",
}),
]),
},
});
},
);
it("native pseudocode pages do not split surrogate pairs", () => {
const original = functionDossierSchema.parse(ghidraFunctionDossier());
const parent = nativeParent({ ...original, pseudocode: "ab😀cd" });
expect(
projectAnalysisView(parent, {
kind: "native",
facet: "pseudocode",
offset: 3,
limit: 2,
}),
).toMatchObject({ ok: false, error: { _tag: "AnalysisInputError" } });
const safe = projectAnalysisView(parent, {
kind: "native",
facet: "pseudocode",
offset: 2,
limit: 3,
});
if (!safe.ok) throw safe.error;
expect(safe.value).toMatchObject({
item: { text: "😀c", unit: "utf16-code-units" },
coverage: { examined: 3, next_offset: 5 },
});
});
it.each([
{ kind: "page", collection: "sections", offset: 0, limit: 500 },
{ kind: "native", facet: "assembly", offset: 0, limit: 500 },
])(
"accepts caller-selected page sizes and rejects malformed bounds: $kind",
(view) => {
const input = {
source: {
kind: "retained-evidence",
evidence_id: `ev_${"a".repeat(64)}`,
},
view,
};
expect(inspectAnalysisViewInputSchema.safeParse(input).success).toBe(true);
for (const limit of [0, -1, 0.5, Infinity, Number.MAX_SAFE_INTEGER + 1])
expect(
inspectAnalysisViewInputSchema.safeParse({
...input,
view: { ...input.view, limit },
}).success,
).toBe(false);
},
);
it("projects layout summary, facet, item, and stable pages", () => {
const parent = layoutParent();
const layout = analysisViewLayoutFixture();
const summary = projectAnalysisView(parent, { kind: "summary" });
if (!summary.ok) throw summary.error;
expect(summary.value).toMatchObject({
kind: "summary",
parent_operation: "inspect_binary_layout",
summary: {
format: "elf",
counts: { sections: 3, symbols: 3, segments: 0, relocations: 0 },
},
coverage: completeWithinViewCoverage(6, 6),
});
const mitigations = projectAnalysisView(parent, {
kind: "facet",
facet: "mitigations",
});
if (!mitigations.ok) throw mitigations.error;
if (mitigations.value.kind !== "facet")
throw new Error("expected facet view");
expect(mitigations.value.facet).toEqual(layout.mitigations);
const data = projectAnalysisView(parent, {
kind: "item",
collection: "sections",
selector: { name: ".data" },
});
if (!data.ok) throw data.error;
if (data.value.kind !== "item") throw new Error("expected item view");
expect(data.value.item).toMatchObject({
index: 2,
name: { display: ".data" },
});
const indexed = projectAnalysisView(parent, {
kind: "item",
collection: "sections",
selector: { index: 0 },
});
if (!indexed.ok) throw indexed.error;
expect(indexed.value.view_digest).not.toBe(data.value.view_digest);
expect(indexed.value.view_digest).not.toBe(parent.evidenceId.slice(3));
const page = projectAnalysisView(parent, {
kind: "page",
collection: "sections",
offset: 0,
limit: 2,
});
if (!page.ok) throw page.error;
expect(page.value).toMatchObject({
kind: "page",
coverage: {
status: "page",
examined: 2,
total: 3,
next_offset: 2,
exhausted: false,
},
});
if (page.value.kind !== "page") throw new Error("expected page view");
expect(page.value.items).toHaveLength(2);
const exhausted = projectAnalysisView(parent, {
kind: "page",
collection: "symbols",
offset: 3,
limit: 8,
});
if (!exhausted.ok) throw exhausted.error;
expect(exhausted.value).toMatchObject({
items: [],
coverage: pageViewCoverage(3, 0, 3),
});
});
it.each(["sections", "symbols"] as const)(
"selects %s by exact source bytes and preserves opaque names by index",
(collection) => {
const layout = analysisViewLayoutFixture();
const rows = layout[collection];
const original = rows[0];
if (original === undefined) throw new Error("missing layout row");
const opaque = {
...original,
name: {
...original.name,
display: "�name",
bytes_base64: Buffer.from([0xff, ...Buffer.from("name")]).toString(
"base64",
),
},
};
const valid = {
...rows[1],
name: {
...original.name,
display: "provider-formatted-name",
bytes_base64: Buffer.from("�name").toString("base64"),
},
};
const parent = {
...layoutParent(),
normalizedResult: {
...layout,
[collection]: [opaque, valid],
},
};
const selected = projectAnalysisView(parent, {
kind: "item",
collection,
selector: { name: "�name" },
});
expect(selected).toMatchObject({ ok: true, value: { item: valid } });
expect(
projectAnalysisView(parent, {
kind: "item",
collection,
selector: { name: "\ud800name" },
}).ok,
).toBe(false);
expect(
projectAnalysisView(parent, {
kind: "item",
collection,
selector: { name: "provider-formatted-name" },
}).ok,
).toBe(false);
expect(
projectAnalysisView(parent, {
kind: "item",
collection,
selector: { index: 0 },
}),
).toMatchObject({ ok: true, value: { item: opaque } });
expect(parent.normalizedResult[collection]).toEqual([opaque, valid]);
},
);
it("rejects ambiguous layout names with candidate indexes", () => {
const parent = layoutParent();
const result = projectAnalysisView(parent, {
kind: "item",
collection: "sections",
selector: { name: ".text" },
});
expect(result).toMatchObject({
ok: false,
error: {
_tag: "AnalysisInputError",
issues: [
{
path: ["view", "selector", "name"],
expected: [{ index: 0 }, { index: 1 }],
},
],
},
});
});
it("counts JavaScript summary coverage in module units", () => {
const analysis = analysisViewJavaScriptAnalysisWithSource();
const moduleNode = analysis.graph.nodes[0];
const observation = moduleNode?.observations[0];
if (moduleNode === undefined || observation === undefined)
throw new Error("missing module observation");
const packageNode = createJavaScriptApplicationNode({
kind: "artifact",
identity: moduleNode.identity,
observations: moduleNode.observations.map((item) => ({
label: item.label,
properties: item.properties,
evidence: item.evidence,
...(item.source_map_reference === null
? {}
: { source_map_reference: item.source_map_reference }),
})),
});
const graph = createJavaScriptApplicationGraph({
schema: "JavaScriptApplicationGraph",
root_node_ids: [moduleNode.node_id],
nodes: [moduleNode, packageNode],
edges: [],
coverage: analysis.graph.coverage,
limitations: analysis.graph.limitations,
});
const parent = javascriptParent(
analysisViewBindJavaScriptGraphs(analysis, graph),
);
const summary = projectAnalysisView(parent, { kind: "summary" });
if (!summary.ok) throw summary.error;
expect(summary.value.coverage).toEqual({
status: "complete-within-view",
examined: 1,
total: 1,
next_offset: null,
exhausted: true,
});
const page = projectAnalysisView(parent, {
kind: "page",
collection: "modules",
offset: 0,
limit: 8,
});
if (!page.ok) throw page.error;
expect(page.value.coverage).toMatchObject({ examined: 1, total: 1 });
});
it("projects JavaScript summary and preserves selected module observations", () => {
const analysis = analysisViewJavaScriptAnalysisWithSource();
const parent = javascriptParent(analysis);
const summary = projectAnalysisView(parent, { kind: "summary" });
if (!summary.ok) throw summary.error;
if (summary.value.kind !== "summary") throw new Error("expected summary");
expect(summary.value.summary).toMatchObject({
format: "directory",
limitation_count: summary.value.limitations.length,
});
expect(JSON.stringify(summary.value)).not.toMatch(/"graph"/);
expect(summary.value.summary).not.toHaveProperty("semantic_graph");
const item = projectAnalysisView(parent, {
kind: "item",
collection: "modules",
selector: { path: "renderer.js" },
});
if (!item.ok) throw item.error;
if (item.value.kind !== "item") throw new Error("expected item view");
expect(item.value.item).toMatchObject({
path: "renderer.js",
kind: "javascript-asset",
observations: expect.arrayContaining([
expect.objectContaining({
properties: expect.objectContaining({
source: "export const secret = 1;\n",
text: "should not leak",
}),
}),
]),
});
const page = projectAnalysisView(parent, {
kind: "page",
collection: "modules",
offset: 0,
limit: 8,
});
if (!page.ok) throw page.error;
if (page.value.kind !== "page") throw new Error("expected page view");
expect(page.value.items).toEqual([
{
node_id: analysis.graph.nodes[0]?.node_id,
kind: "javascript-asset",
path: "renderer.js",
},
]);
expect(page.value.coverage).toMatchObject({
status: "page",
examined: 1,
total: 1,
next_offset: null,
exhausted: true,
});
});
it("projects typed module facts without source bodies and keeps source coverage independent of paging", () => {
const analysis = analysisViewJavaScriptAnalysisWithSource();
const parent = javascriptParent(analysis);
const input = inspectAnalysisViewInputSchema.parse({
source: { kind: "retained-evidence", evidence_id: parent.evidenceId },
view: {
kind: "javascript",
collection: "modules",
projection: "references",
where: { path: "renderer.js" },
limit: 1,
},
});
const projected = projectAnalysisView(parent, input.view);
if (!projected.ok) throw projected.error;
if (projected.value.kind !== "javascript")
throw new Error("expected JavaScript view");
const node = analysis.graph.nodes[0];
if (!node) throw new Error("missing module");
expect(projected.value.rows).toEqual([
{
node_id: node.node_id,
kind: node.kind,
path: "renderer.js",
identity: node.identity,
retained_source_range_count: 0,
basis: [
{ authority: "artifact-bytes", state: "observed", confidence: "exact" },
],
},
]);
expect(projected.value.coverage).toMatchObject({ total: 1, exhausted: true });
expect(projected.value.source_coverage).toMatchObject({
application: analysis.graph.coverage,
semantic: { status: analysis.semantic_graph.coverage.status },
});
expect(JSON.stringify(projected.value.rows)).not.toMatch(
/secret|should not leak|observations/,
);
const row = projected.value.rows[0];
if (!row) throw new Error("missing reference");
const retainedIdentity = structuredClone(node.identity);
if (row.identity.strategy !== "content-digest")
throw new Error("expected digest identity");
row.identity.sha256 = "e".repeat(64);
expect(node.identity).toEqual(retainedIdentity);
const empty = projectAnalysisView(parent, {
...input.view,
kind: "javascript",
collection: "modules",
projection: "references",
where: { kind: "javascript-module" },
offset: 0,
limit: 1,
});
if (!empty.ok) throw empty.error;
expect(empty.value).toMatchObject({
rows: [],
coverage: { total: 0, exhausted: true },
});
});
it("counts retained range observations including repeats and skips unavailable locations", () => {
const analysis = analysisViewJavaScriptAnalysis();
const original = analysis.graph.nodes.find(
({ kind }) => kind === "javascript-asset",
);
const observed = original?.observations[0];
if (!original || !observed) throw new Error("missing module observation");
const range = {
kind: "source-range",
source: "renderer.js",
start: { line: 1, column: 0 },
end: { line: 1, column: 8 },
};
const node = createJavaScriptApplicationNode({
kind: original.kind,
identity: original.identity,
observations: [
...["first retained observation", "second retained observation"].map(
(label) => ({
label,
properties: {},
evidence: {
...observed.evidence,
location: { available: true, value: range },
},
}),
),
{
label: "unavailable location",
properties: {},
evidence: {
...observed.evidence,
authority: "unknown",
state: "unavailable",
confidence: "unknown",
location: {
available: false,
reason: "not-observed",
detail: "Location was not recorded.",
},
limitations: ["Location was not recorded."],
},
},
],
});
const { graph_id: _graphId, ...application } = analysis.graph;
const graph = createJavaScriptApplicationGraph({
...application,
nodes: [node],
root_node_ids: [node.node_id],
edges: [],
});
const parent = javascriptParent(
analysisViewBindJavaScriptGraphs(analysis, graph),
);
const references = projectAnalysisView(parent, {
kind: "javascript",
collection: "modules",
projection: "references",
where: {},
offset: 0,
limit: 1,
});
const item = projectAnalysisView(parent, {
kind: "item",
collection: "modules",
selector: { node_id: node.node_id },
});
if (!references.ok) throw references.error;
if (!item.ok) throw item.error;
expect(references.value).toMatchObject({
rows: [{ node_id: node.node_id, retained_source_range_count: 2 }],
});
expect(item.value).toMatchObject({ item: { source_ranges: [range, range] } });
});
it("validates typed module selectors without coercing null or empty paths", () => {
const source = {
kind: "retained-evidence",
evidence_id: javascriptParent().evidenceId,
};
const view = {
kind: "javascript",
collection: "modules",
projection: "references",
};
for (const path of [null, "", "renderer.js"])
expect(
inspectAnalysisViewInputSchema.safeParse({
source,
view: { ...view, where: { path } },
}).success,
).toBe(true);
for (const where of [
{ path: 1 },
{ kind: "electron-main" },
{ glob: "*.js" },
])
expect(
inspectAnalysisViewInputSchema.safeParse({
source,
view: { ...view, where },
}).success,
).toBe(false);
expect(
projectAnalysisView(layoutParent(), {
...view,
kind: "javascript",
collection: "modules",
projection: "references",
where: {},
offset: 0,
limit: 1,
}).ok,
).toBe(false);
});
it("keeps mixed observation support distinct instead of promoting a module to observed", () => {
const analysis = analysisViewJavaScriptAnalysis();
const original = analysis.graph.nodes.find(
({ kind }) => kind === "javascript-asset",
);
const observed = original?.observations[0];
if (!original || !observed) throw new Error("missing module observation");
const inferred = {
...observed.evidence,
authority: "static-relationship-inference" as const,
state: "inferred" as const,
confidence: "low" as const,
limitations: ["Static candidate; runtime loading is unknown."],
};
const node = createJavaScriptApplicationNode({
kind: original.kind,
identity: original.identity,
observations: [
{
label: observed.label,
properties: observed.properties,
evidence: observed.evidence,
},
{ label: "candidate one", properties: {}, evidence: inferred },
{ label: "candidate two", properties: {}, evidence: inferred },
],
});
const { graph_id: _graphId, ...application } = analysis.graph;
const graph = createJavaScriptApplicationGraph({
...application,
nodes: [node],
root_node_ids: [node.node_id],
edges: [],
});
const result = projectAnalysisView(
javascriptParent(analysisViewBindJavaScriptGraphs(analysis, graph)),
{
kind: "javascript",
collection: "modules",
projection: "references",
where: {},
offset: 0,
limit: 1,
},
);
if (!result.ok) throw result.error;
if (result.value.kind !== "javascript")
throw new Error("expected references");
expect(result.value.rows[0]?.basis).toHaveLength(2);
expect(result.value.rows[0]?.basis).toEqual(
expect.arrayContaining([
{ authority: "artifact-bytes", state: "observed", confidence: "exact" },
{
authority: "static-relationship-inference",
state: "inferred",
confidence: "low",
},
]),
);
});
it("rejects ambiguous JavaScript module paths with candidate node ids", () => {
const analysis = analysisViewJavaScriptAnalysis();
const first = analysis.graph.nodes[0];
if (first === undefined) throw new Error("missing module");
const duplicate = createJavaScriptApplicationNode({
kind: first.kind,
identity: {
strategy: "content-digest",
stability: "global-exact",
sha256: "c".repeat(64),
},
observations: first.observations.map((observation) => ({
label: observation.label,
properties: observation.properties,
evidence: {
...observation.evidence,
artifact: {
...observation.evidence.artifact,
sha256: "c".repeat(64),
artifact_id: `art_${"c".repeat(64)}`,
},
},
})),
});
const graph = createJavaScriptApplicationGraph({
schema: "JavaScriptApplicationGraph",
root_node_ids: [first.node_id, duplicate.node_id],
nodes: [first, duplicate],
edges: [],
coverage: analysis.graph.coverage,
limitations: analysis.graph.limitations,
});
const parent = javascriptParent(
analysisViewBindJavaScriptGraphs(analysis, graph),
);
const result = projectAnalysisView(parent, {
kind: "item",
collection: "modules",
selector: { path: "renderer.js" },
});
if (result.ok) throw new Error("expected ambiguous path");
expect(result.error).toMatchObject({
_tag: "AnalysisInputError",
issues: [
{
path: ["view", "selector", "path"],
expected: expect.arrayContaining([
{ node_id: first.node_id },
{ node_id: duplicate.node_id },
]),
},
],
});
const view = {
kind: "javascript",
collection: "modules",
projection: "references",
where: { path: "renderer.js" },
offset: 0,
limit: 1,
} as const;
const ids: string[] = [];
for (const offset of [0, 1, 2, Number.MAX_SAFE_INTEGER]) {
const page = projectAnalysisView(parent, { ...view, offset });
if (!page.ok) throw page.error;
if (page.value.kind !== "javascript")
throw new Error("expected references");
ids.push(...page.value.rows.map(({ node_id }) => node_id));
expect(page.value.coverage).toMatchObject({
total: 2,
next_offset: offset === 0 ? 1 : null,
exhausted: offset !== 0,
});
}
expect(ids).toEqual(graph.nodes.map(({ node_id }) => node_id));
});
it("keeps export bindings out of module pages and path selection", () => {
const analysis = analysisViewJavaScriptAnalysis();
const original = analysis.graph.nodes[0];
const observation = original?.observations[0];
if (original === undefined || observation === undefined)
throw new Error("missing module observation");
const exportBinding = createJavaScriptApplicationNode({
kind: "javascript-module",
identity: {
strategy: "artifact-local-key",
stability: "artifact-version",
artifact_sha256: "c".repeat(64),
namespace: "module-export",
key: "renderer.js:alpha",
},
observations: [
{
label: "renderer.js:alpha",
properties: {
semantic_role: "export-binding",
module_path: "renderer.js",
exported_name: "alpha",
},
evidence: {
...observation.evidence,
artifact: {
...observation.evidence.artifact,
sha256: "c".repeat(64),
artifact_id: `art_${"c".repeat(64)}`,
},
},
},
],
});
const graph = createJavaScriptApplicationGraph({
schema: "JavaScriptApplicationGraph",
root_node_ids: [original.node_id, exportBinding.node_id],
nodes: [original, exportBinding],
edges: [],
coverage: analysis.graph.coverage,
limitations: analysis.graph.limitations,
});
const parent = javascriptParent(
analysisViewBindJavaScriptGraphs(analysis, graph),
);
const page = projectAnalysisView(parent, {
kind: "page",
collection: "modules",
offset: 0,
limit: 10,
});
if (!page.ok) throw page.error;
if (page.value.kind !== "page") throw new Error("expected page");
expect(page.value.items).toEqual([
{
node_id: original.node_id,
kind: original.kind,
path: "renderer.js",
},
]);
expect(page.value.coverage).toMatchObject({
total: 1,
examined: 1,
exhausted: true,
});
const item = projectAnalysisView(parent, {
kind: "item",
collection: "modules",
selector: { path: "renderer.js" },
});
if (!item.ok) throw item.error;
if (item.value.kind !== "item") throw new Error("expected item view");
expect(item.value.item).toMatchObject({ node_id: original.node_id });
const summary = projectAnalysisView(parent, { kind: "summary" });
if (!summary.ok) throw summary.error;
expect(summary.value.coverage).toMatchObject({ total: 1, examined: 1 });
});
it("pages actual modules, including unknown and empty paths, without unrelated roles", () => {
const analysis = analysisViewJavaScriptAnalysis();
const original = analysis.graph.nodes[0];
if (original === undefined) throw new Error("missing module");
const nodes = [
original,
...(
[
"asar-entry",
"electron-renderer",
"javascript-module",
"source-module",
] as const
).map((kind) =>
createJavaScriptApplicationNode({
kind,
identity:
kind === "source-module"
? {
strategy: "source-map-original",
source_root: null,
stability: "source-map-exact",
original_source: "",
source_map_sha256: "c".repeat(64),
source_sha256: null,
}
: kind === "javascript-module"
? {
strategy: "artifact-local-key",
stability: "artifact-version",
artifact_sha256: "c".repeat(64),
namespace: kind,
key: "module",
}
: original.identity,
observations: original.observations.map((observation) => ({
...(kind === "source-module"
? {
source_map_reference: sourceMapReference(
"",
null,
"renderer.js",
),
}
: {}),
label: observation.label,
properties: {},
evidence:
kind === "javascript-module" || kind === "source-module"
? {
...observation.evidence,
artifact: {
...observation.evidence.artifact,
sha256: "c".repeat(64),
artifact_id: `art_${"c".repeat(64)}`,
},
...(kind === "javascript-module"
? {
state: "unknown",
confidence: "unknown",
limitations: ["Source location unavailable"],
location: {
available: false,
reason: "unknown",
detail: "Source location unavailable",
},
}
: {}),
}
: observation.evidence,
})),
}),
),
];
const graph = createJavaScriptApplicationGraph({
schema: "JavaScriptApplicationGraph",
root_node_ids: nodes.map((node) => node.node_id),
nodes,
edges: [],
coverage: analysis.graph.coverage,
limitations: [],
});
const parent = javascriptParent(
analysisViewBindJavaScriptGraphs(analysis, graph),
);
const page = projectAnalysisView(parent, {
kind: "page",
collection: "modules",
offset: 0,
limit: 1000,
});
if (!page.ok) throw page.error;
expect(page.value).toMatchObject({
coverage: { total: 3, examined: 3, exhausted: true },
});
if (page.value.kind !== "page") throw new Error("expected page");
expect(page.value.items).toEqual(
expect.arrayContaining([
expect.objectContaining({ kind: "javascript-module", path: null }),
expect.objectContaining({ kind: "source-module", path: "" }),
]),
);
const emptyPath = projectAnalysisView(parent, {
kind: "item",
collection: "modules",
selector: { path: "" },
});
for (const [path, kind] of [
[null, "javascript-module"],
["", "source-module"],
] as const) {
const references = projectAnalysisView(parent, {
kind: "javascript",
collection: "modules",
projection: "references",
where: { path },
offset: 0,
limit: 1,
});
if (!references.ok) throw references.error;
expect(references.value).toMatchObject({
rows: [{ path, kind }],
coverage: { total: 1, exhausted: true },
});
}
expect(emptyPath.ok).toBe(true);
const role = nodes.find((node) => node.kind === "electron-renderer");
if (role === undefined) throw new Error("missing role");
expect(
projectAnalysisView(parent, {
kind: "item",
collection: "modules",
selector: { node_id: role.node_id },
}).ok,
).toBe(false);
});
const complete = <Value>(steps: Generator<void, Value>): Value => {
let step = steps.next();
while (!step.done) step = steps.next();
return step.value;
};
it("reuses authenticated graphs while rejecting malformed metadata and imported companions", () => {
const analysis = analysisViewJavaScriptAnalysis();
const { graph_id: _applicationId, ...application } = analysis.graph;
const graph = complete(
createImmutableJavaScriptApplicationGraphSteps(application),
);
const { graph_id: _semanticId, ...semantic } = analysis.semantic_graph;
const semanticGraph = complete(
sealTransferredJavaScriptSemanticGraphSteps({
...semantic,
application_graph_id: graph.graph_id,
}),
);
const owned = { ...analysis, graph, semantic_graph: semanticGraph };
expect(
projectAnalysisView(javascriptParent(owned), { kind: "summary" }).ok,
).toBe(true);
for (const malformed of [
{ ...owned, root_artifact_sha256: "d".repeat(64) },
{
...owned,
statistics: { ...owned.statistics, parsed_javascript_files: -1 },
},
{
...owned,
semantic_graph: Object.freeze({
...semanticGraph,
application_graph_id: "jag_" + "d".repeat(64),
}),
},
]) {
const result = projectAnalysisView(
{ ...javascriptParent(owned), normalizedResult: malformed },
{ kind: "summary" },
);
expect(result).toMatchObject({
ok: false,
error: {
_tag: "AnalysisInputError",
issues: expect.arrayContaining([
expect.objectContaining({
path: expect.arrayContaining(["source", "normalized_result"]),
}),
]),
},
});
}
});
it("retains semantic coverage and limitations in a summary", () => {
const analysis = analysisViewJavaScriptAnalysis();
const { graph_id: _graphId, ...semantic } = analysis.semantic_graph;
const semanticGraph = createJavaScriptSemanticGraph({
...semantic,
coverage: {
...semantic.coverage,
status: "partial",
truncated: true,
omitted_nodes: null,
omitted_relations: null,
limits: [
{ name: "semantic_graph_node_ceiling", value: 100000, unit: "items" },
],
},
limitations: ["Some semantic nodes could not be retained."],
});
const result = projectAnalysisView(
javascriptParent({ ...analysis, semantic_graph: semanticGraph }),
{ kind: "summary" },
);
if (!result.ok) throw result.error;
expect(result.value).toMatchObject({
summary: {
limitation_count: 1,
coverage: { semantic: { status: "partial", truncated: true } },
},
limitations: ["Some semantic nodes could not be retained."],
unknowns: expect.arrayContaining([
"semantic_graph.coverage.status is partial",
]),
});
});
it.each([63, 64, 65, 10_000])(
"bounds and deduplicates %i messages in JavaScript and layout views",
(count) => {
const messages = Array.from(
{ length: count },
(_, index) => `Module ${String(index).padStart(5, "0")} was not parsed.`,
);
const analysis = analysisViewJavaScriptAnalysis();
const { graph_id: _graphId, ...semantic } = analysis.semantic_graph;
const parent = javascriptParent({
...analysis,
limitations: messages,
semantic_graph: createJavaScriptSemanticGraph({
...semantic,
limitations: messages.slice(0, 1),
}),
});
const duplicatedParent = { ...parent, limitations: messages };
const notice = (
omitted: number,
field: "limitations" | "unknowns",
evidenceId: string,
) =>
`${String(omitted)} additional ${field} omitted from this view; consult source parent Evidence ${evidenceId} for the complete list (the caller-supplied record, or its retaining session).`;
for (const view of [
{ kind: "summary" },
{ kind: "page", collection: "modules", offset: 0, limit: 1 },
] as const) {
const result = projectAnalysisView(duplicatedParent, view);
if (!result.ok) throw result.error;
if (
result.value.kind === "summary" &&
result.value.parent_operation === "analyze_javascript_application"
)
expect(result.value.summary.limitation_count).toBe(count);
if (count <= 65) {
expect(result.value.limitations).toEqual(messages);
expect(result.value.unknowns).toEqual(
[...messages, "semantic_graph.coverage.status is unknown"].sort(),
);
} else {
const limitations = result.value.limitations;
const unknowns = result.value.unknowns;
expect(limitations.length).toBeGreaterThan(65);
expect(limitations.at(-1)).toBe(
notice(
count - limitations.length + 1,
"limitations",
parent.evidenceId,
),
);
expect(unknowns.length).toBeGreaterThan(65);
expect(unknowns.at(-1)).toBe(
notice(
count + 1 - unknowns.length + 1,
"unknowns",
parent.evidenceId,
),
);
}
}
const layout = layoutParent();
const layoutWithMessages = {
...layout,
limitations: messages,
normalizedResult: {
...analysisViewLayoutFixture(),
limitations: messages,
},
};
for (const view of [
{ kind: "summary" },
{ kind: "page", collection: "sections", offset: 0, limit: 1 },
] as const) {
const result = projectAnalysisView(layoutWithMessages, view);
if (!result.ok) throw result.error;
if (count <= 65) expect(result.value.limitations).toEqual(messages);
else {
expect(result.value.limitations.length).toBeGreaterThan(65);
expect(result.value.limitations.at(-1)).toBe(
notice(
count - result.value.limitations.length + 1,
"limitations",
layout.evidenceId,
),
);
}
}
},
);
it.each(["partial", "unknown"] as const)(
"preserves %s parent graph completeness when a module page is exhausted",
(status) => {
const analysis = analysisViewJavaScriptAnalysis();
const first = analysis.graph.nodes[0];
if (first === undefined) throw new Error("missing module");
const unknown = createJavaScriptApplicationNode({
kind: "unknown",
identity: {
strategy: "observation-fingerprint",
stability: "observation-only",
observation_sha256: "8".repeat(64),
scope: "unclassified module",
},
observations: first.observations.map((observation) => ({
label: "unclassified module",
properties: {},
evidence: observation.evidence,
})),
});
const messages = [
...Array.from(
{ length: 65 },
(_, index) =>
`Module ${String(index).padStart(5, "0")} was not parsed.`,
),
"z".repeat(300_000),
];
const { graph_id: _applicationId, ...application } = analysis.graph;
const graph = createJavaScriptApplicationGraph({
...application,
nodes: [...application.nodes, unknown],
limitations: messages.slice(0, 1),
coverage: { ...application.coverage, status, omitted_count: null },
});
const bound = analysisViewBindJavaScriptGraphs(analysis, graph);
const { graph_id: _semanticId, ...semantic } = bound.semantic_graph;
const parent = javascriptParent({
...bound,
limitations: messages,
semantic_graph: createJavaScriptSemanticGraph({
...semantic,
limitations: messages.slice(0, 1),
}),
});
for (const view of [
{ kind: "page", collection: "modules", offset: 0, limit: 10 },
{
kind: "javascript",
collection: "modules",
projection: "references",
where: {},
offset: 0,
limit: 10,
},
{
kind: "javascript",
collection: "modules",
projection: "references",
where: { path: "not-retained.js" },
offset: 0,
limit: 10,
},
{
kind: "item",
collection: "modules",
selector: { path: "renderer.js" },
},
] as const) {
const result = projectAnalysisView(parent, view);
if (!result.ok) throw result.error;
if (result.value.coverage === null)
throw new Error("Expected known coverage");
expect(result.value.coverage.exhausted).toBe(true);
if (result.value.kind === "javascript")
expect(result.value.source_coverage).toMatchObject({
application: { status, omitted_count: null },
semantic: { status: "unknown" },
application_unknown_count: 1,
});
expect(result.value.unknowns).toEqual([
"1 application graph unknowns remain in the parent Evidence.",
...messages.slice(0, 65),
`graph.coverage.status is ${status}`,
"semantic_graph.coverage.status is unknown",
`1 additional unknowns omitted from this view; consult source parent Evidence ${parent.evidenceId} for the complete list (the caller-supplied record, or its retaining session).`,
]);
}
},
);
it("does not match unavailable layout names using a display placeholder", () => {
const layout = analysisViewLayoutFixture();
const section = layout.sections[2];
if (section === undefined) throw new Error("missing section");
const result = projectAnalysisView(
{
...layoutParent(),
normalizedResult: {
...layout,
sections: [
...layout.sections.slice(0, 2),
{
...section,
name: {
...section.name,
display: "<unavailable>",
unknown_reason: "Name bytes unavailable",
bytes_base64: null,
location: null,
},
},
],
},
},
{
kind: "item",
collection: "sections",
selector: { name: "<unavailable>" },
},
);
expect(result.ok).toBe(false);
});
it("rejects unsupported parent operations and incompatible collections", () => {
expect(
projectAnalysisView(layoutParent(), {
kind: "managed",
collection: "attributes",
offset: 0,
limit: 1,
}),
).toMatchObject({ ok: false, error: { _tag: "AnalysisInputError" } });
const unsupported = projectAnalysisView(
{
predicateType: "rea.analysis",
evidenceId: `ev_${"d".repeat(64)}`,
operation: "inspect_recorded_crash",
normalizedResult: { path: "/artifacts/crash.core" },
limitations: [],
},
{ kind: "summary" },
);
expect(unsupported).toMatchObject({
ok: false,
error: { _tag: "AnalysisUnsupportedTargetError" },
});
const modulesOnLayout = projectAnalysisView(layoutParent(), {
kind: "page",
collection: "modules",
offset: 0,
limit: 1,
});
expect(modulesOnLayout).toMatchObject({
ok: false,
error: { _tag: "AnalysisInputError" },
});
const sectionsOnJs = projectAnalysisView(javascriptParent(), {
kind: "item",
collection: "sections",
selector: { name: ".text" },
});
expect(sectionsOnJs).toMatchObject({
ok: false,
error: { _tag: "AnalysisInputError" },
});
});
it("keeps the complete unique set when it fits the byte budget", () => {
const messages = ["a".repeat(2_400), "b".repeat(2_400)];
expect(
boundedViewMessages(messages, `ev_${"a".repeat(64)}`, "limitations"),
).toEqual(messages);
});
it("does not impose a message-count cutoff below the byte budget", () => {
const messages = Array.from(
{ length: 100 },
(_, index) => `message ${String(index).padStart(2, "0")}`,
);
expect(
boundedViewMessages(messages, `ev_${"a".repeat(64)}`, "limitations"),
).toEqual(messages.toSorted());
});
it("bounds repeated view messages even when fewer than 64 source strings are huge", () => {
const oversized = ["\u0000".repeat(300_000), "\\".repeat(300_000)];
const projected = boundedViewMessages(
oversized,
`ev_${"a".repeat(64)}`,
"limitations",
);
expect(projected).toHaveLength(1);
expect(projected[0]).toContain("2 additional limitations omitted");
expect(Buffer.byteLength(JSON.stringify(projected))).toBeLessThan(256 * 1024);
});
it("preserves selected native facet unavailability instead of an exhausted empty page", () => {
const parent = nativeParent({
...functionDossierSchema.parse(ghidraFunctionDossier()),
facet_availability: {
comments: { available: false, reason: "Typed comments unavailable" },
references: { available: false, reason: "Typed references unavailable" },
},
});
for (const [facet, reason] of [
["comments", "Typed comments unavailable"],
["incoming_references", "Typed references unavailable"],
] as const) {
const result = projectAnalysisView(parent, {
kind: "native",
facet,
offset: 0,
limit: 8,
});
if (!result.ok) throw result.error;
expect(result.value).toMatchObject({
item: { available: false, reason },
unknowns: expect.arrayContaining([reason]),
});
}
});
it("selects a unique content-deduplicated module by any retained path", () => {
const source = analysisViewJavaScriptAnalysisWithSource();
const original = source.graph.nodes[0];
const observation = original?.observations[0];
if (original === undefined || observation === undefined)
throw new Error("Missing module fixture");
const node = createJavaScriptApplicationNode({
kind: original.kind,
identity: original.identity,
observations: [
...original.observations.map(({ label, properties, evidence }) => ({
label,
properties,
evidence,
})),
{
evidence: observation.evidence,
label: "renderer-alias.js",
properties: { ...observation.properties, path: "renderer-alias.js" },
},
],
});
const { graph_id: _graphId, ...graphFacts } = source.graph;
const graph = createJavaScriptApplicationGraph({
...graphFacts,
nodes: [node],
});
const parent = javascriptParent(
analysisViewBindJavaScriptGraphs(source, graph),
);
for (const path of ["renderer.js", "renderer-alias.js"]) {
const selected = projectAnalysisView(parent, {
kind: "item",
collection: "modules",
selector: { path },
});
if (!selected.ok) throw selected.error;
expect(selected.value).toMatchObject({
kind: "item",
item: { node_id: node.node_id, path },
});
}
});