Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
import type { JavaScriptSemanticPropertyPath } from "./javascriptSemanticPropertyPaths.js";
import { SEMANTIC_ALIAS_SELECTION_LIMIT } from "./javascriptSemanticResourceLimits.js";
type PropertyKey = JavaScriptSemanticPropertyPath[number];
/** Finite alternatives retain selected keys without admitting unrelated slots. */
export type SemanticAliasSelection =
| PropertyKey
| { readonly alternatives: readonly PropertyKey[] };
export type SemanticAliasSelectionPath = readonly SemanticAliasSelection[];
export const semanticAliasSelectionChoices = (
key: SemanticAliasSelection,
): readonly PropertyKey[] =>
key !== null && typeof key === "object" && "alternatives" in key
? key.alternatives
: [key];
const selection = (choices: readonly PropertyKey[]): SemanticAliasSelection => {
if (choices.includes(null)) return null;
const alternatives = [
...new Map(choices.map((choice) => [JSON.stringify(choice), choice])),
]
.sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
.map(([, choice]) => choice);
return alternatives.length === 1 ? alternatives[0]! : { alternatives };
};
const selectionCovers = (
prior: SemanticAliasSelection,
next: SemanticAliasSelection,
): boolean => {
if (prior === null) return true;
const choices = new Set(
semanticAliasSelectionChoices(prior).map((key) => JSON.stringify(key)),
);
return semanticAliasSelectionChoices(next).every((key) =>
choices.has(JSON.stringify(key)),
);
};
const pathCovers = (
prior: SemanticAliasSelectionPath,
next: SemanticAliasSelectionPath,
): boolean =>
prior.every(
(key, index) =>
next[index] !== undefined && selectionCovers(key, next[index]!),
);
/** Only one differing selector can be joined without inventing crossed paths. */
const joinSelections = (
prior: SemanticAliasSelectionPath,
next: SemanticAliasSelectionPath,
): SemanticAliasSelectionPath | undefined => {
let changed = -1;
for (let index = 0; index < prior.length; index++) {
if (JSON.stringify(prior[index]) === JSON.stringify(next[index])) continue;
if (changed !== -1) return undefined;
changed = index;
}
return prior.map((key, index) =>
index === changed
? selection([
...semanticAliasSelectionChoices(key),
...semanticAliasSelectionChoices(next[index]!),
])
: key,
);
};
/** Preserve correlated selector alternatives while coalescing complete grids. */
export class SemanticAliasSelections {
#paths = new WeakMap<object, Map<number, SemanticAliasSelectionPath[]>>();
#calls = 0;
#limited = false;
constructor(readonly onLimit: () => void) {}
get limited(): boolean {
return this.#limited;
}
normalize(
node: object,
next: SemanticAliasSelectionPath,
): SemanticAliasSelectionPath {
if (this.#limited) return next.map(() => null);
const existing = this.#paths.get(node);
const byDepth = existing ?? new Map<number, SemanticAliasSelectionPath[]>();
const paths = [...(byDepth.get(next.length) ?? [])];
let candidate = next.map((key) =>
selection(semanticAliasSelectionChoices(key)),
);
const covered = paths.find((prior) => pathCovers(prior, candidate));
if (covered !== undefined) return covered;
if (
existing !== undefined &&
++this.#calls > SEMANTIC_ALIAS_SELECTION_LIMIT
) {
this.#limited = true;
this.#paths = new WeakMap();
this.onLimit();
return next.map(() => null);
}
for (let index = 0; index < paths.length;) {
const prior = paths[index]!;
if (pathCovers(prior, candidate)) return prior;
const joined = pathCovers(candidate, prior)
? candidate
: joinSelections(prior, candidate);
if (joined === undefined) {
index++;
continue;
}
candidate = [...joined];
paths.splice(index, 1);
index = 0;
}
paths.push(candidate);
byDepth.set(candidate.length, paths);
this.#paths.set(node, byDepth);
return candidate;
}
}