Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

refactor(runtime): retain complete reconciliation outputs

morluto79ea571512a1
diff --git a/docs/javascript-runtime-reconciliation.md b/docs/javascript-runtime-reconciliation.md
index f43b50472..75b3455ba 100644
--- a/docs/javascript-runtime-reconciliation.md
+++ b/docs/javascript-runtime-reconciliation.md
@@ -156,16 +156,18 @@ silently equated with the generated bytes observed by CDP.
## Bounds and determinism
-Inputs allow up to eight static layers and 32 passive captures. Runtime entity,
-reconciliation item, and static load-state projections have caller-visible
-limits and report omitted counts when reached. The merged application graph
-retains all selected roots, nodes, edges, and observations from those inputs;
-it adds no second aggregate prefix cap. Reaching an input projection limit
-reports exact omitted counts and `coverage.status: truncated`.
+The workflow does not impose aggregate count caps on static layers, passive
+captures, runtime entities, reconciliation items, static load states, runtime
+mapping declarations, or candidate references. These collections remain
+subject to the structural validation applied to each Evidence record and
+application graph; passive capture collection limits are committed by the
+observation operation that produced that Evidence. Reconciliation reports zero
+omitted items when it projects the complete supplied inputs. Static JavaScript
+analysis can still report its own bounded AST coverage as partial or truncated.
Layers, captures, nodes, edges, matches, and evidence links are canonically
-ordered. Repeating the same verified Evidence, mappings, and limits produces
-the same reconciliation, graph, and Evidence identifiers.
+ordered. Repeating the same verified Evidence and mappings produces the same
+reconciliation, graph, and Evidence identifiers.
## Non-goals
diff --git a/src/application/JavaScriptReturnShapeProjection.ts b/src/application/JavaScriptReturnShapeProjection.ts
index dc0fe9023..da4e6b5d0 100644
--- a/src/application/JavaScriptReturnShapeProjection.ts
+++ b/src/application/JavaScriptReturnShapeProjection.ts
@@ -12,10 +12,6 @@ import { flattenSemanticReturnValue } from "../domain/javascriptSemanticReturns.
import type { JavaScriptSourceRange } from "../domain/javascriptStaticAnalysisTypes.js";
import type { JavaScriptArtifactGraphCoverage } from "./JavaScriptArtifactGraphContext.js";
-const MAX_PROJECTED_RETURN_SHAPES = 32;
-const MAX_PROJECTED_RETURN_FIELDS = 64;
-const MAX_PROJECTED_PROPERTY_COVERAGE = 64;
-
export interface JavaScriptReturnShapeProjection {
readonly properties: ReturnType<typeof jsonObjectSchema.parse>;
readonly range: JavaScriptSourceRange;
@@ -46,24 +42,7 @@ export const projectJavaScriptExportReturnShapes = (input: {
input.baseCoverage.status === "complete" &&
callable.returnCoverage.status === "complete" &&
projectionOmitted === 0;
- const limits = [
- ...input.baseCoverage.limits,
- {
- name: "return-shape-sites",
- value: MAX_PROJECTED_RETURN_SHAPES,
- unit: "items" as const,
- },
- {
- name: "return-shape-fields",
- value: MAX_PROJECTED_RETURN_FIELDS,
- unit: "items" as const,
- },
- {
- name: "return-shape-property-coverage",
- value: MAX_PROJECTED_PROPERTY_COVERAGE,
- unit: "items" as const,
- },
- ];
+ const limits = input.baseCoverage.limits;
const omitted =
semanticOmitted === null ? null : semanticOmitted + projectionOmitted;
const coverage = complete
@@ -79,9 +58,6 @@ export const projectJavaScriptExportReturnShapes = (input: {
"No direct return value was retained; runtime return behavior remains unknown.",
]
: []),
- ...(projectionOmitted > 0
- ? ["Return-shape graph projection reached explicit retention limits."]
- : []),
];
return {
properties: jsonObjectSchema.parse({
@@ -110,37 +86,14 @@ export const projectJavaScriptExportReturnShapes = (input: {
};
const projectReturnSites = (callable: JavaScriptSemanticCallable) => {
- let retainedFields = 0;
- let retainedCoverage = 0;
- let omittedFields = 0;
- let omittedCoverage = 0;
- const retainedSites = callable.returnSites.slice(
- 0,
- MAX_PROJECTED_RETURN_SHAPES,
- );
+ const retainedSites = callable.returnSites;
const shapes = retainedSites.map((site) => {
const flattened = flattenSemanticReturnValue(site.value);
- const remainingFields = Math.max(
- 0,
- MAX_PROJECTED_RETURN_FIELDS - retainedFields,
- );
- const fields = flattened.fields.slice(0, remainingFields).map((field) => ({
+ const fields = flattened.fields.map((field) => ({
...field,
value: jsonValueSchema.parse(field.value),
}));
- retainedFields += fields.length;
- omittedFields += flattened.fields.length - fields.length;
- const remainingCoverage = Math.max(
- 0,
- MAX_PROJECTED_PROPERTY_COVERAGE - retainedCoverage,
- );
- const propertyCoverage = flattened.propertyCoverage.slice(
- 0,
- remainingCoverage,
- );
- retainedCoverage += propertyCoverage.length;
- omittedCoverage +=
- flattened.propertyCoverage.length - propertyCoverage.length;
+ const propertyCoverage = flattened.propertyCoverage;
return {
source_range: site.location,
value_status: site.value.status,
@@ -150,8 +103,8 @@ const projectReturnSites = (callable: JavaScriptSemanticCallable) => {
});
return {
shapes,
- omittedSites: callable.returnSites.length - retainedSites.length,
- omittedFields,
- omittedCoverage,
+ omittedSites: 0,
+ omittedFields: 0,
+ omittedCoverage: 0,
};
};
diff --git a/src/application/JavaScriptRuntimeReconciliationEvidence.ts b/src/application/JavaScriptRuntimeReconciliationEvidence.ts
index 23bb3f7b3..1dc8a6529 100644
--- a/src/application/JavaScriptRuntimeReconciliationEvidence.ts
+++ b/src/application/JavaScriptRuntimeReconciliationEvidence.ts
@@ -39,5 +39,4 @@ const parameters = (
runtime_evidence_ids: input.runtime_observations.map(
({ evidence_id: id }) => id,
),
- limits: input.limits,
});
diff --git a/src/contracts/javascriptApplicationWorkflowExamples.ts b/src/contracts/javascriptApplicationWorkflowExamples.ts
index 087536aa3..8874ed614 100644
--- a/src/contracts/javascriptApplicationWorkflowExamples.ts
+++ b/src/contracts/javascriptApplicationWorkflowExamples.ts
@@ -32,11 +32,6 @@ const reconciliationEvidence = createEvidence(
JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE.runtime_observations.map(
({ evidence_id: id }) => id,
),
- limits: {
- max_runtime_entities: 10_000,
- max_reconciliation_items: 20_000,
- max_static_load_states: 20_000,
- },
},
result: reconciliation,
confidence: "inferred",
diff --git a/src/domain/javascriptApplicationVersionComparisonSchemas.ts b/src/domain/javascriptApplicationVersionComparisonSchemas.ts
index 5f98ab1f0..28337019a 100644
--- a/src/domain/javascriptApplicationVersionComparisonSchemas.ts
+++ b/src/domain/javascriptApplicationVersionComparisonSchemas.ts
@@ -208,9 +208,6 @@ export const applicationVersionComparisonResultSchema = z
});
});
-export type CompareApplicationVersionsInput = z.infer<
- typeof compareApplicationVersionsInputSchema
->;
export type ApplicationVersionComparisonItem = z.infer<
typeof comparisonItemSchema
>;
diff --git a/src/domain/javascriptRuntimeLoadState.ts b/src/domain/javascriptRuntimeLoadState.ts
index c08d7c3bf..e6a17b0ea 100644
--- a/src/domain/javascriptRuntimeLoadState.ts
+++ b/src/domain/javascriptRuntimeLoadState.ts
@@ -25,21 +25,17 @@ export const classifyStaticLoadStates = (
runtimeEntities: readonly RuntimeReconciliationEntity[],
matches: readonly JavaScriptRuntimeReconciliationItem[],
options: {
- readonly maximumStates: number;
readonly reconciliationComplete: boolean;
},
): StaticLoadStateProjection => {
const states: JavaScriptStaticLoadState[] = [];
- let totalStates = 0;
for (const layer of layers) {
const projection = classifyLayer(layer, runtimeEntities, matches, {
reconciliationComplete: options.reconciliationComplete,
- maximumStates: Math.max(0, options.maximumStates - states.length),
});
- totalStates += projection.total;
states.push(...projection.states);
}
- return { states, omittedStates: totalStates - states.length };
+ return { states, omittedStates: 0 };
};
const classifyLayer = (
@@ -48,11 +44,9 @@ const classifyLayer = (
matches: readonly JavaScriptRuntimeReconciliationItem[],
options: {
readonly reconciliationComplete: boolean;
- readonly maximumStates: number;
},
-): { readonly states: JavaScriptStaticLoadState[]; readonly total: number } => {
+): { readonly states: JavaScriptStaticLoadState[] } => {
const nodes = layer.graph.nodes.filter(isLoadStateNode);
- if (options.maximumStates === 0) return { states: [], total: nodes.length };
const direct = new Map<string, string[]>();
for (const match of matches)
if (
@@ -73,7 +67,7 @@ const classifyLayer = (
scopedEntities.every(({ capture }) =>
captureScriptsComplete(capture.evidence.evidence_id, runtimeEntities),
);
- const states = nodes.slice(0, options.maximumStates).map((node) => {
+ const states = nodes.map((node) => {
const runtimeNodeIds = uniqueSorted(direct.get(node.node_id) ?? []);
if (runtimeNodeIds.length > 0)
return state(layer, node, {
@@ -102,7 +96,7 @@ const classifyLayer = (
: "static-or-runtime-coverage-incomplete",
});
});
- return { states, total: nodes.length };
+ return { states };
};
const residentNodes = (
diff --git a/src/domain/javascriptRuntimeReconciliation.ts b/src/domain/javascriptRuntimeReconciliation.ts
index b772a71c0..20bdf50cc 100644
--- a/src/domain/javascriptRuntimeReconciliation.ts
+++ b/src/domain/javascriptRuntimeReconciliation.ts
@@ -18,23 +18,18 @@ export const reconcileJavaScriptRuntime = (
const parsed = reconcileJavaScriptRuntimeInputSchema.parse(input);
const layers = parseStaticLayers(parsed.static_layers);
const captures = parseRuntimeCaptures(parsed.runtime_observations);
- const runtime = projectRuntimeCaptures(
- captures,
- parsed.limits.max_runtime_entities,
- );
+ const runtime = projectRuntimeCaptures(captures);
const candidates = collectStaticRuntimeCandidates(layers);
const matching = reconcileRuntimeEntities({
entities: runtime.entities,
candidates,
layers,
- maximumItems: parsed.limits.max_reconciliation_items,
});
const loadStates = classifyStaticLoadStates(
layers,
runtime.entities,
matching.items,
{
- maximumStates: parsed.limits.max_static_load_states,
reconciliationComplete:
runtime.omittedEntities === 0 && matching.omittedItems === 0,
},
diff --git a/src/domain/javascriptRuntimeReconciliationGraph.ts b/src/domain/javascriptRuntimeReconciliationGraph.ts
index 6a16a88ab..30efec7c8 100644
--- a/src/domain/javascriptRuntimeReconciliationGraph.ts
+++ b/src/domain/javascriptRuntimeReconciliationGraph.ts
@@ -67,7 +67,7 @@ export const buildReconciledApplicationGraph = (
: []),
...(facts.outputTruncated
? [
- "The reconciled graph omitted entities or classifications at caller limits.",
+ "The reconciled graph omitted entities or classifications during projection.",
]
: []),
]),
diff --git a/src/domain/javascriptRuntimeReconciliationMatching.ts b/src/domain/javascriptRuntimeReconciliationMatching.ts
index 908a0f0a6..13a5466bd 100644
--- a/src/domain/javascriptRuntimeReconciliationMatching.ts
+++ b/src/domain/javascriptRuntimeReconciliationMatching.ts
@@ -27,24 +27,21 @@ export const reconcileRuntimeEntities = (input: {
readonly entities: readonly RuntimeReconciliationEntity[];
readonly candidates: readonly StaticRuntimeCandidate[];
readonly layers: readonly ParsedStaticLayer[];
- readonly maximumItems: number;
}): RuntimeMatchingProjection => {
const index = indexCandidates(input.candidates);
const evaluated = input.entities.map((entity) =>
reconcileEntity(entity, index, input.layers),
);
- const retained = evaluated
- .sort((left, right) =>
- compareCodePoints(
- left.item.reconciliation_id,
- right.item.reconciliation_id,
- ),
- )
- .slice(0, input.maximumItems);
+ const retained = evaluated.sort((left, right) =>
+ compareCodePoints(
+ left.item.reconciliation_id,
+ right.item.reconciliation_id,
+ ),
+ );
return {
items: retained.map(({ item }) => item),
edges: retained.flatMap(({ edge }) => (edge === null ? [] : [edge])),
- omittedItems: evaluated.length - retained.length,
+ omittedItems: 0,
};
};
@@ -419,11 +416,10 @@ const uniqueCandidateReferences = (
if (seen.has(key)) continue;
seen.add(key);
count += 1;
- if (items.length < 1_000)
- items.push({
- static_layer_id: layer.layerId,
- static_node_id: node.node_id,
- });
+ items.push({
+ static_layer_id: layer.layerId,
+ static_node_id: node.node_id,
+ });
}
return { count, items };
};
diff --git a/src/domain/javascriptRuntimeReconciliationResult.ts b/src/domain/javascriptRuntimeReconciliationResult.ts
index bb62ede7f..e1fbfcd74 100644
--- a/src/domain/javascriptRuntimeReconciliationResult.ts
+++ b/src/domain/javascriptRuntimeReconciliationResult.ts
@@ -198,7 +198,7 @@ const reconciliationLimitations = (completion: CompletionFlags): string[] =>
: []),
...(completion.outputTruncated
? [
- "Caller limits omitted runtime entities or reconciliation classifications.",
+ "Runtime reconciliation omitted entities or classifications during projection.",
]
: []),
]);
diff --git a/src/domain/javascriptRuntimeReconciliationRuntime.ts b/src/domain/javascriptRuntimeReconciliationRuntime.ts
index bfebc8406..b57e06e65 100644
--- a/src/domain/javascriptRuntimeReconciliationRuntime.ts
+++ b/src/domain/javascriptRuntimeReconciliationRuntime.ts
@@ -31,16 +31,9 @@ export interface RuntimeProjection {
/** Project authorized passive capture metadata into capture-scoped JAG nodes. */
export const projectRuntimeCaptures = (
captures: readonly ParsedRuntimeCapture[],
- maximumEntities: number,
): RuntimeProjection => {
- if (maximumEntities < captures.length)
- throw new TypeError(
- "Runtime entity limit must admit one target for every capture",
- );
const all = captures.flatMap(projectCapture);
- const targets = all.filter(({ kind }) => kind === "target");
- const nonTargets = all.filter(({ kind }) => kind !== "target");
- const retained = [...targets, ...nonTargets].slice(0, maximumEntities);
+ const retained = all;
const retainedIds = new Set(retained.map(({ node }) => node.node_id));
const nodes = retained.map(({ node }) => node);
const edges = captures
@@ -59,7 +52,7 @@ export const projectRuntimeCaptures = (
nodes,
edges,
targetNodeByEvidenceId,
- omittedEntities: all.length - retained.length,
+ omittedEntities: 0,
};
};
diff --git a/src/domain/javascriptRuntimeReconciliationSchemas.ts b/src/domain/javascriptRuntimeReconciliationSchemas.ts
index 2f589da6f..c405d2a6b 100644
--- a/src/domain/javascriptRuntimeReconciliationSchemas.ts
+++ b/src/domain/javascriptRuntimeReconciliationSchemas.ts
@@ -80,7 +80,6 @@ const staticLayerSchema = z.strictObject({
analysis: evidenceSchema,
runtime_mappings: z
.array(runtimeLocationMappingSchema)
- .max(32)
.overwrite(normalizeRuntimeMappings)
.default([]),
});
@@ -103,22 +102,11 @@ function runtimeMappingKey(mapping: RuntimeLocationMapping): string {
: `url-prefix\0${mapping.prefix}\0${mapping.artifact_prefix}`;
}
-const reconciliationLimitsSchema = z.strictObject({
- max_runtime_entities: z.number().int().min(1).max(50_000).default(10_000),
- max_reconciliation_items: z.number().int().min(1).max(50_000).default(20_000),
- max_static_load_states: z.number().int().min(1).max(50_000).default(20_000),
-});
-
/** Evidence-backed static layers and passive captures to reconcile. */
export const reconcileJavaScriptRuntimeInputSchema = z
.strictObject({
- static_layers: z.array(staticLayerSchema).min(1).max(8),
- runtime_observations: z.array(evidenceSchema).min(1).max(32),
- limits: reconciliationLimitsSchema.default({
- max_runtime_entities: 10_000,
- max_reconciliation_items: 20_000,
- max_static_load_states: 20_000,
- }),
+ static_layers: z.array(staticLayerSchema).min(1),
+ runtime_observations: z.array(evidenceSchema).min(1),
})
.superRefine((input, context) => {
if (
@@ -148,12 +136,6 @@ export const reconcileJavaScriptRuntimeInputSchema = z
path: ["runtime_observations"],
message: "Runtime observation Evidence must be unique",
});
- if (input.limits.max_runtime_entities < input.runtime_observations.length)
- context.addIssue({
- code: "custom",
- path: ["limits", "max_runtime_entities"],
- message: "Runtime entity limit must retain one target per observation",
- });
});
const layerSummarySchema = z.strictObject({
@@ -164,7 +146,7 @@ const layerSummarySchema = z.strictObject({
root_artifact_sha256: digestSchema,
input_path: z.string().min(1).max(16_384),
format: z.enum(["asar", "directory"]),
- runtime_mappings: z.array(runtimeLocationMappingSchema).max(32),
+ runtime_mappings: z.array(runtimeLocationMappingSchema),
});
const captureSummarySchema = z.strictObject({
@@ -209,15 +191,13 @@ const reconciliationItemShape = {
]),
confidence: z.enum(["exact", "high", "medium", "low", "unknown"]),
reason: reconciliationReasonSchema,
- candidate_static_count: z.number().int().min(0).max(800_000),
- candidate_static_nodes: z
- .array(
- z.strictObject({
- static_layer_id: z.string().regex(/^jrl_[a-f0-9]{64}$/u),
- static_node_id: nodeIdSchema,
- }),
- )
- .max(1_000),
+ candidate_static_count: z.number().int().min(0),
+ candidate_static_nodes: z.array(
+ z.strictObject({
+ static_layer_id: z.string().regex(/^jrl_[a-f0-9]{64}$/u),
+ static_node_id: nodeIdSchema,
+ }),
+ ),
};
const reconciliationItemSchema = z.union([
z.strictObject({
@@ -244,7 +224,7 @@ const staticLoadStateSchema = z.strictObject({
"not-observed-in-capture",
"unknown",
]),
- runtime_node_ids: z.array(nodeIdSchema).max(10_000),
+ runtime_node_ids: z.array(nodeIdSchema),
reason: z.enum([
"runtime-script-correspondence",
"containing-asset-was-loaded",
@@ -257,8 +237,8 @@ const staticLoadStateSchema = z.strictObject({
/** Deterministic static/passive-runtime reconciliation with a combined JAG. */
export const javascriptRuntimeReconciliationResultSchema = z.strictObject({
reconciliation_id: z.string().regex(/^jrr_[a-f0-9]{64}$/u),
- static_layers: z.array(layerSummarySchema).min(1).max(8),
- runtime_captures: z.array(captureSummarySchema).min(1).max(32),
+ static_layers: z.array(layerSummarySchema).min(1),
+ runtime_captures: z.array(captureSummarySchema).min(1),
graph: javascriptApplicationGraphSchema,
summary: z.strictObject({
runtime_targets: z.number().int().min(0),
@@ -274,8 +254,8 @@ export const javascriptRuntimeReconciliationResultSchema = z.strictObject({
static_not_observed: z.number().int().min(0),
static_unknown: z.number().int().min(0),
}),
- reconciliations: z.array(reconciliationItemSchema).max(50_000),
- static_load_states: z.array(staticLoadStateSchema).max(50_000),
+ reconciliations: z.array(reconciliationItemSchema),
+ static_load_states: z.array(staticLoadStateSchema),
source_map_authority: z.strictObject({
used_for_primary_matching: z.literal(false),
static_layer_count: z.number().int().min(0),
@@ -290,8 +270,8 @@ export const javascriptRuntimeReconciliationResultSchema = z.strictObject({
omitted_static_load_states: z.number().int().min(0),
omitted_graph_items: z.number().int().min(0),
}),
- evidence_links: z.array(evidenceIdSchema).min(2).max(40),
- limitations: z.array(boundedTextSchema).max(1_000),
+ evidence_links: z.array(evidenceIdSchema).min(2),
+ limitations: z.array(boundedTextSchema),
});
export type ReconcileJavaScriptRuntimeInput = z.infer<
diff --git a/src/domain/sourceToBundleComparisonSchemas.ts b/src/domain/sourceToBundleComparisonSchemas.ts
index 041c2295b..55d37748c 100644
--- a/src/domain/sourceToBundleComparisonSchemas.ts
+++ b/src/domain/sourceToBundleComparisonSchemas.ts
@@ -118,9 +118,6 @@ export const sourceToBundleComparisonResultSchema = z.strictObject({
limitations: z.array(boundedTextSchema).max(1_000),
});
-export type CompareSourceToBundleInput = z.infer<
- typeof compareSourceToBundleInputSchema
->;
export type SourceToBundleComparisonResult = z.infer<
typeof sourceToBundleComparisonResultSchema
>;
diff --git a/tests/boundary/filesystem/javascriptExportShapeComparison.test.ts b/tests/boundary/filesystem/javascriptExportShapeComparison.test.ts
index 635f63d13..e86b865c4 100644
--- a/tests/boundary/filesystem/javascriptExportShapeComparison.test.ts
+++ b/tests/boundary/filesystem/javascriptExportShapeComparison.test.ts
@@ -205,7 +205,42 @@ describe("JavaScript export return-shape selection", () => {
});
describe("JavaScript export return-shape projection", () => {
- it("marks graph field projection omissions as truncated", async () => {
+ it("retains more than 64 inferred return fields", async () => {
+ const properties = Array.from(
+ { length: 70 },
+ (_, index) => `field${String(index)}: ${String(index)}`,
+ ).join(",");
+ const root = await temporaryRoot();
+ await writeFile(
+ join(root, "parser.mjs"),
+ `export const parse = () => ({ ${properties} });`,
+ );
+ const analyzed = await analyzeGraph(root);
+ const returnShape = analyzed.graph.nodes
+ .flatMap(({ observations }) => observations)
+ .find(
+ ({ properties: value }) =>
+ value.semantic_role === "export-return-shapes",
+ );
+
+ const shapes = returnShape?.properties.static_return_shapes;
+ expect(Array.isArray(shapes)).toBe(true);
+ if (!Array.isArray(shapes)) throw new TypeError("Missing return shapes");
+ const firstShape = shapes[0];
+ if (
+ firstShape === null ||
+ typeof firstShape !== "object" ||
+ Array.isArray(firstShape)
+ )
+ throw new TypeError("Missing first return shape");
+ expect(firstShape.fields).toHaveLength(70);
+ expect(returnShape?.properties.return_shape_coverage).toMatchObject({
+ omitted_fields: 0,
+ projection_complete: true,
+ });
+ });
+
+ it("keeps incomplete source property coverage partial", async () => {
const properties = [
'a_type: "item"',
...Array.from(
@@ -219,9 +254,9 @@ describe("JavaScript export return-shape projection", () => {
});
const result = compare(left, right);
- expect(result.coverage.status).toBe("truncated");
- expect(result.coverage.left_omitted_fields).toBeGreaterThan(0);
- expect(result.coverage.right_omitted_fields).toBeGreaterThan(0);
+ expect(result.coverage.status).toBe("partial");
+ expect(result.coverage.left_omitted_fields).toBe(0);
+ expect(result.coverage.right_omitted_fields).toBe(0);
});
});
diff --git a/tests/boundary/process/javascriptRuntimeReconciliationAmbiguity.test.ts b/tests/boundary/process/javascriptRuntimeReconciliationAmbiguity.test.ts
index 3ffc441a6..ac7bc1f45 100644
--- a/tests/boundary/process/javascriptRuntimeReconciliationAmbiguity.test.ts
+++ b/tests/boundary/process/javascriptRuntimeReconciliationAmbiguity.test.ts
@@ -67,7 +67,7 @@ it("keeps byte-identical cross-layer candidates explicitly ambiguous", async ()
).toBe(2);
});
-it("retains one target per capture and keeps load-state absence unknown when output is bounded", async () => {
+it("retains all runtime entities and static load states without projection caps", async () => {
const fixture = await applicationFixture();
temporary.push(fixture);
const staticEvidence = await analyzeFixture(fixture);
@@ -85,11 +85,6 @@ it("retains one target per capture and keeps load-state absence unknown when out
const result = reconcileJavaScriptRuntime({
static_layers: [{ role: "application", analysis: staticEvidence }],
runtime_observations: runtimeObservations,
- limits: {
- max_runtime_entities: 2,
- max_reconciliation_items: 2,
- max_static_load_states: 20_000,
- },
});
expect(result.runtime_captures).toHaveLength(2);
@@ -98,19 +93,22 @@ it("retains one target per capture and keeps load-state absence unknown when out
).toBe(2);
expect(result.summary).toMatchObject({
runtime_targets: 2,
- runtime_frames: 0,
- runtime_scripts: 0,
+ runtime_frames: 2,
+ runtime_scripts: 2,
runtime_workers: 0,
- static_not_observed: 0,
+ static_not_observed: 2,
});
expect(result.coverage).toMatchObject({
- status: "truncated",
- truncated: true,
- omitted_runtime_entities: 4,
+ omitted_runtime_entities: 0,
+ omitted_reconciliation_items: 0,
+ omitted_static_load_states: 0,
});
- expect(
- result.static_load_states.every(({ status }) => status === "unknown"),
- ).toBe(true);
+ expect(result.static_load_states).toHaveLength(
+ result.summary.static_loaded +
+ result.summary.static_resident +
+ result.summary.static_not_observed +
+ result.summary.static_unknown,
+ );
});
it("rejects runtime source bytes whose Evidence omits source-capture approval", async () => {
@@ -233,15 +231,6 @@ const electronRuntimeEvidence = (
target_id: targetId,
observation_ms: 100,
include_script_sources: sourceIncluded,
- limits: {
- max_frames: 200,
- max_dom_nodes: 2_000,
- max_scripts: 500,
- max_resources: 2_000,
- max_workers: 500,
- max_script_source_bytes: 1_048_576,
- max_total_script_source_bytes: 4_194_304,
- },
});
return createElectronEvidence(
"inspect_electron_page",
diff --git a/tests/composition/runtime-observation/javascriptRuntimeReconciliation.test.ts b/tests/composition/runtime-observation/javascriptRuntimeReconciliation.test.ts
index 878db7325..b5ee56cf9 100644
--- a/tests/composition/runtime-observation/javascriptRuntimeReconciliation.test.ts
+++ b/tests/composition/runtime-observation/javascriptRuntimeReconciliation.test.ts
@@ -354,15 +354,6 @@ const electronRuntimeEvidence = (
target_id: targetId,
observation_ms: 100,
include_script_sources: sourceIncluded,
- limits: {
- max_frames: 200,
- max_dom_nodes: 2_000,
- max_scripts: 500,
- max_resources: 2_000,
- max_workers: 500,
- max_script_source_bytes: 1_048_576,
- max_total_script_source_bytes: 4_194_304,
- },
});
return createElectronEvidence(
"inspect_electron_page",