Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(javascript): stop replaying earlier writes for each object property write
Zeynel1ec490f36180
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.member_mutations.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.member_mutations.test.tsindex f28436eb1..3450060cb 100644--- a/src/domain/javascript/javascriptSemanticAnalysis.member_mutations.test.ts+++ b/src/domain/javascript/javascriptSemanticAnalysis.member_mutations.test.ts@@ -590,3 +590,24 @@ describe("property mutations through TypeScript satisfies aliases", () => {).toEqual({ status: "literal", value: "TOKEN" });});});++describe("property mutation collection on minified bundles", () => {+ it("records each write to one object without replaying earlier writes", () => {+ const writes = Array.from(+ { length: 2000 },+ (_, index) => `source.p${index} = ${index};`,+ ).join(" ");+ const start = performance.now();+ const value = resultValue(+ `const source = { token: "TOKEN" }; ${writes} return [source.token, source.p1999];`,+ );+ expect(performance.now() - start).toBeLessThan(2000);+ expect(value).toMatchObject({+ status: "array",+ items: [+ { value: { status: "literal", value: "TOKEN" } },+ { value: { status: "unknown" } },+ ],+ });+ }, 30000);+});diff --git a/src/domain/javascript/javascriptSemanticMemberMutations.ts b/src/domain/javascript/javascriptSemanticMemberMutations.tsindex 4e4ea7b8b..1414d407f 100644--- a/src/domain/javascript/javascriptSemanticMemberMutations.ts+++ b/src/domain/javascript/javascriptSemanticMemberMutations.ts@@ -194,8 +194,11 @@ export const collectSemanticMemberMutations = (current.originAt?.end,]);if (recordedEffects.has(identity)) continue;+ // A recorded write invalidates the binding to a non-primitive value, so+ // only its first write can target a primitive. Re-evaluating it would+ // replay every earlier write and make repeated writes superlinear.const value =- effect === "write"+ effect === "write" && binding.mutatedPaths.length === 0? evaluateSemanticBinding(binding, state): undefined;const primitiveWrite =diff --git a/src/domain/javascript/javascriptSemanticMutationValues.ts b/src/domain/javascript/javascriptSemanticMutationValues.tsindex dbbc9d457..bc2213da7 100644--- a/src/domain/javascript/javascriptSemanticMutationValues.ts+++ b/src/domain/javascript/javascriptSemanticMutationValues.ts@@ -33,49 +33,89 @@ export const invalidateSemanticEscapedPath = (: { ...value, items: value.items.map(invalidateChild) };};-/** Invalidate only slots that an explicit mutation can affect. */-export const invalidateSemanticMutationPath = (+/**+ * Invalidate only slots that explicit mutations can affect, as if applying each+ * path in order. Paths are grouped per slot so that many writes to one object+ * cost one pass over its slots rather than one pass per write.+ */+export const invalidateSemanticMutationPaths = (value: JavaScriptSemanticValue,- path: JavaScriptSemanticPropertyPath,+ paths: readonly JavaScriptSemanticPropertyPath[],): JavaScriptSemanticValue => {- const [key, ...remaining] = path;- const unknown: JavaScriptSemanticValue = {- status: "unknown",- reason: "This property may have been mutated.",+ if (paths.length === 0) return value;+ // An unknown key or a replaced value leaves nothing that a later path can+ // restore, wherever it occurs in the sequence.+ if (+ (value.status !== "object" && value.status !== "array") ||+ paths.some(([key]) => key === undefined || key === null)+ )+ return {+ status: "unknown",+ reason: "This property may have been mutated.",+ };+ // Writing an array length discards every item known before it.+ const reset =+ value.status === "array"+ ? paths.findLastIndex(([key]) => key === "length")+ : -1;+ const base: typeof value =+ reset < 0+ ? value+ : { status: "array", items: [], unknownItems: true, omittedItems: null };+ const slots = base.status === "object" ? base.properties : base.items;+ const slotsByName = new Map<string, number[]>();+ slots.forEach((property, index) => {+ const indexes = slotsByName.get(property.name) ?? [];+ indexes.push(index);+ slotsByName.set(property.name, indexes);+ });+ const slotPaths = new Map<number, JavaScriptSemanticPropertyPath[]>();+ const replacedSlots = new Set<number>();+ const select = (index: number, remaining: JavaScriptSemanticPropertyPath) => {+ const selected = slotPaths.get(index) ?? [];+ selected.push(remaining);+ slotPaths.set(index, selected);+ if (remaining.length === 0) replacedSlots.add(index);};- if (key === undefined || key === null) return unknown;- if (value.status === "object" || value.status === "array") {- if (value.status === "array" && key === "length")- return {- status: "array",- items: [],- unknownItems: true,- omittedItems: null,- };- const slots = value.status === "object" ? value.properties : value.items;- const observed = slots.some((property) =>- semanticPropertyPathKeyMatches(key, property.name),- );- const properties = slots.map((property) =>- semanticPropertyPathKeyMatches(key, property.name)- ? {+ // An added slot is already unknown, so later paths that select it are inert.+ const added = new Set<string>();+ for (const [key, ...remaining] of paths.slice(reset + 1)) {+ if (key === undefined || key === null) continue;+ if (typeof key === "object") {+ slots.forEach((property, index) => {+ if (semanticPropertyPathKeyMatches(key, property.name))+ select(index, remaining);+ });+ continue;+ }+ const indexes = slotsByName.get(String(key));+ if (indexes === undefined) added.add(String(key));+ else for (const index of indexes) select(index, remaining);+ }+ const properties: JavaScriptSemanticProperty[] = slots.map(+ (property, index) => {+ const selected = slotPaths.get(index);+ return selected === undefined+ ? property+ : {...property,- ...(remaining.length === 0+ ...(replacedSlots.has(index)? { presence: "unknown-coverage" as const }: {}),- value: invalidateSemanticMutationPath(property.value, remaining),- }- : property,- );- if (!observed && typeof key !== "object")- properties.push({- name: String(key),- value: unknown,- presence: "unknown-coverage",- });- return value.status === "object"- ? { ...value, properties }- : { ...value, items: properties };- }- return unknown;+ value: invalidateSemanticMutationPaths(property.value, selected),+ };+ },+ );+ for (const name of added)+ properties.push({+ name,+ value: {+ status: "unknown",+ reason: "This property may have been mutated.",+ },+ presence: "unknown-coverage",+ });+ return base.status === "object"+ ? { ...base, properties }+ : { ...base, items: properties };};diff --git a/src/domain/javascript/javascriptSemanticValues.ts b/src/domain/javascript/javascriptSemanticValues.tsindex 884915948..87f6ad540 100644--- a/src/domain/javascript/javascriptSemanticValues.ts+++ b/src/domain/javascript/javascriptSemanticValues.ts@@ -10,7 +10,7 @@ import { semanticSlotAtPath } from "./javascriptSemanticSlots.js";import {invalidateSemanticEscapedPath,- invalidateSemanticMutationPath,+ invalidateSemanticMutationPaths,} from "./javascriptSemanticMutationValues.js";import type { JavaScriptBindingProvenance } from "./javascriptSemanticIr.js";@@ -211,13 +211,7 @@ const evaluateBinding = (if (isPrimitive(captured)) value = captured;}}- let projected = value;- for (const path of binding.mutatedPaths) {- projected = invalidateSemanticMutationPath(projected, path);- // Every subsequent write returns this same root unknown. Replaying those- // paths at every newly collected effect otherwise becomes quadratic.- if (projected.status === "unknown") break;- }+ let projected = invalidateSemanticMutationPaths(value, binding.mutatedPaths);for (const escape of binding.escapedPaths) {// Escapes only invalidate object references; other lattice values survive.if (projected.status !== "object" && projected.status !== "array") break;