From 5510b27d7f863a3df26212fba4a59f8df0da3712 Mon Sep 17 00:00:00 2001 From: morluto <76467478+morluto@users.noreply.github.com> Date: Fri, 9 Oct 2026 20:03:47 +0800 Subject: [PATCH] refactor(domain)!: remove obsolete comparison representations Compare complete function dossiers directly, remove unreachable truncation and collection wrappers, and preserve deterministic Unicode ordering. Require real external reference targets instead of display placeholders. BREAKING CHANGE: function comparison results no longer advertise the unreachable truncated state or counter. --- src/domain/callPath.ts | 16 +- src/domain/changedBehavior.ts | 2 +- src/domain/functionComparison.test.ts | 33 +- src/domain/functionComparison.ts | 8 +- src/domain/functionComparisonDimensions.ts | 448 ++++++------------ src/domain/functionComparisonNormalization.ts | 82 ++-- src/domain/functionComparisonResults.ts | 6 +- src/domain/functionComparisonSchemas.ts | 10 +- src/domain/functionDossierEvidence.ts | 72 +-- src/domain/referenceSourceGraph.test.ts | 6 +- src/domain/referenceSourceGraph.ts | 9 +- 11 files changed, 224 insertions(+), 468 deletions(-) diff --git a/src/domain/callPath.ts b/src/domain/callPath.ts index 0f31d69c8..a98145607 100644 --- a/src/domain/callPath.ts +++ b/src/domain/callPath.ts @@ -160,8 +160,8 @@ const parseSnapshots = ( const snapshots = new Map(); for (const group of groups) { const snapshot = parseFunctionEvidence(group); - const address = normalizeAddress(snapshot.procedure.address); - for (const callee of snapshot.collections.callees.items) + const address = normalizeAddress(snapshot.dossier.procedure.address); + for (const callee of snapshot.dossier.callees) normalizeAddress(callee.address); if (snapshots.has(address)) throw new TypeError(`Duplicate function Evidence for ${address}`); @@ -184,9 +184,9 @@ const assertCompatible = ( ) throw new TypeError("Call-path Evidence mixes artifact subjects"); if ( - snapshot.provider.id !== first.provider.id || - snapshot.provider.name !== first.provider.name || - snapshot.provider.version !== first.provider.version + snapshot.evidence.provider.id !== first.evidence.provider.id || + snapshot.evidence.provider.name !== first.evidence.provider.name || + snapshot.evidence.provider.version !== first.evidence.provider.version ) throw new TypeError("Call-path Evidence mixes providers"); } @@ -198,7 +198,7 @@ const createGraph = ( const graph = new CallGraph(); for (const [address, snapshot] of snapshots) { graph.mergeNode(address); - for (const callee of snapshot.collections.callees.items) { + for (const callee of snapshot.dossier.callees) { const calleeAddress = normalizeAddress(callee.address); graph.mergeNode(calleeAddress); graph.mergeDirectedEdge(address, calleeAddress); @@ -346,7 +346,7 @@ const citePath = ( (index > 0 ? snapshots.get(addresses[index - 1] ?? "") : undefined); return { address, - name: snapshot?.procedure.name ?? null, + name: snapshot?.dossier.procedure.name ?? null, evidence_links: snapshotLinks(supporting), }; }); @@ -367,7 +367,7 @@ const citePath = ( const snapshotLinks = (snapshot: FunctionSnapshot | undefined): string[] => { if (snapshot === undefined) throw new TypeError("Every call-path claim requires supporting Evidence"); - return snapshot.evidence.map(({ evidence_id }) => evidence_id); + return [snapshot.evidence.evidence_id]; }; const uniqueEvidence = (snapshots: Iterable): string[] => diff --git a/src/domain/changedBehavior.ts b/src/domain/changedBehavior.ts index 36f62e94f..9ef188d2a 100644 --- a/src/domain/changedBehavior.ts +++ b/src/domain/changedBehavior.ts @@ -293,7 +293,7 @@ const functionFindings = (evidence: Evidence): Finding[] => { scope: "static_candidate", status: dimension.status, classification: - dimension.status === "unknown" || dimension.status === "truncated" + dimension.status === "unknown" ? "unresolved_branch" : dimension.conclusion_kind, limitations: dimension.limitations, diff --git a/src/domain/functionComparison.test.ts b/src/domain/functionComparison.test.ts index 4adf6becd..d9b6b2f31 100644 --- a/src/domain/functionComparison.test.ts +++ b/src/domain/functionComparison.test.ts @@ -9,6 +9,7 @@ import { import { createEvidence, type Evidence } from "./evidence.js"; import { functionDossierSchema } from "./hopperValues.js"; import { canonicalDigest, canonicalJson } from "./comparisonSemantics.js"; +import { compareCodePoints } from "./canonicalOrdering.js"; import { jsonValueSchema } from "./jsonValue.js"; const dossier = ( @@ -219,17 +220,17 @@ describe("function collection collation ties", () => { expect(calls?.left_digest).not.toBe(calls?.right_digest); }); - it("preserves existing digests when canonical records do not collate equally", () => { + it("uses canonical code-point ordering for collection digests", () => { const callees = ["zeta", "Alpha", "alpha", "_helper", "beta"].map( (name, index) => ({ address: `0x${(0x2000 + index).toString(16)}`, name, }), ); - const legacyProjection = callees + const canonicalProjection = callees .map(({ name }) => ({ direction: "out", name })) .sort((left, right) => - canonicalJson(left).localeCompare(canonicalJson(right)), + compareCodePoints(canonicalJson(left), canonicalJson(right)), ); const result = compareFunctions( observe("b", calling(callees)), @@ -240,8 +241,8 @@ describe("function collection collation ties", () => { ); expect(calls).toMatchObject({ status: "unchanged", - left_digest: canonicalDigest(legacyProjection), - right_digest: canonicalDigest(legacyProjection), + left_digest: canonicalDigest(canonicalProjection), + right_digest: canonicalDigest(canonicalProjection), }); }); }); @@ -395,6 +396,28 @@ describe("function comparison CFG address normalization", () => { }); }); +describe("function comparison unresolved text", () => { + it("counts Unicode text consistently for unresolved provider comparisons", () => { + const left = observe("b", dossier("return '😀';", "0x1000"), "provider-a"); + const right = observe("c", dossier("return '😀';", "0x2000"), "provider-b"); + const comparison = compareFunctions(left, right); + expect( + comparison.dimensions.find(({ dimension }) => dimension === "pseudocode"), + ).toMatchObject({ status: "unknown", left_count: 11, right_count: 11 }); + expect(comparison.summary).toEqual({ + unchanged: 6, + changed: 0, + unknown: 2, + }); + expect( + functionComparisonResultSchema.safeParse({ + ...comparison, + status: "truncated", + }).success, + ).toBe(false); + }); +}); + describe("function comparison", () => { it("preserves text changes alongside complete inline dossier facets", () => { const result = compareFunctions( diff --git a/src/domain/functionComparison.ts b/src/domain/functionComparison.ts index eaf0d54d1..e494dd2fd 100644 --- a/src/domain/functionComparison.ts +++ b/src/domain/functionComparison.ts @@ -20,11 +20,11 @@ export const compareFunctions = ( ): FunctionComparisonResult => { const left = parseFunctionEvidence(leftInput); const right = parseFunctionEvidence(rightInput); - const links = [left.evidence[0].evidence_id, right.evidence[0].evidence_id]; + const links = [left.evidence.evidence_id, right.evidence.evidence_id]; const providersDiffer = - canonicalJson(left.provider, "Function comparison") !== - canonicalJson(right.provider, "Function comparison"); - const dimensions = compareDimensions(left, right, links, providersDiffer); + canonicalJson(left.evidence.provider, "Function comparison") !== + canonicalJson(right.evidence.provider, "Function comparison"); + const dimensions = compareDimensions(left, right, { links, providersDiffer }); const match = functionMatch(left, right); const changes = dimensions.filter(({ status }) => status !== "unchanged"); return functionComparisonResultSchema.parse({ diff --git a/src/domain/functionComparisonDimensions.ts b/src/domain/functionComparisonDimensions.ts index b0b30b890..f4d7d86a1 100644 --- a/src/domain/functionComparisonDimensions.ts +++ b/src/domain/functionComparisonDimensions.ts @@ -1,17 +1,12 @@ import { canonicalJson } from "./comparisonSemantics.js"; import { diffLines } from "diff"; -import type { - FunctionCollection, - FunctionSnapshot, -} from "./functionDossierEvidence.js"; +import type { FunctionSnapshot } from "./functionDossierEvidence.js"; import { commentProjection, - combineCoverage, identityProjection, isAutoName, normalizeCfg, - project, referenceKindProjection, referenceProjection, sorted, @@ -23,113 +18,79 @@ import type { } from "./functionComparisonSchemas.js"; import { dimensionResult, - unresolvedDimension as buildUnresolvedDimension, + unresolvedDimension, + type DimensionResultInput, } from "./functionComparisonResults.js"; -const unresolvedDimension = ( - ...[dimension, status, links, leftCount, rightCount, limitations]: readonly [ - DimensionName, - "truncated" | "unknown", - readonly string[], - number | null, - number | null, - readonly string[], - ] -): FunctionDimension => - buildUnresolvedDimension({ - dimension, - status, - links, - leftCount, - rightCount, - limitations, - }); +type ComparisonContext = Pick< + DimensionResultInput, + "links" | "providersDiffer" +>; export const compareDimensions = ( left: FunctionSnapshot, right: FunctionSnapshot, - links: readonly string[], - providersDiffer: boolean, -): FunctionDimension[] => [ - compareIdentity(left, right, links, providersDiffer), - compareText( - "pseudocode", - left.pseudocode.text, - right.pseudocode.text, - left.pseudocode.complete, - right.pseudocode.complete, - links, - providersDiffer, - ), - compareText( - "assembly", - left.collections.assembly.items.join("\n"), - right.collections.assembly.items.join("\n"), - left.collections.assembly.complete, - right.collections.assembly.complete, - links, - providersDiffer, - left.collections.assembly.truncated || right.collections.assembly.truncated, - "Assembly is opaque provider text; relocation normalization is unavailable.", - ), - compareComments(left, right, links, providersDiffer), - compareCalls(left, right, links, providersDiffer), - compareReferences(left, right, links, providersDiffer), - compareStringsAndNames(left, right, links, providersDiffer), - compareCfg(left, right, links, providersDiffer), -]; + context: ComparisonContext, +): FunctionDimension[] => { + return [ + compareIdentity(left, right, context), + compareText( + "pseudocode", + left.dossier.pseudocode, + right.dossier.pseudocode, + context, + ), + compareText( + "assembly", + left.dossier.assembly.join("\n"), + right.dossier.assembly.join("\n"), + context, + ), + compareComments(left, right, context), + compareCalls(left, right, context), + compareReferences(left, right, context), + compareStringsAndNames(left, right, context), + compareCfg(left, right, context), + ]; +}; const compareText = ( - ...[ - dimension, - left, - right, - leftComplete, - rightComplete, - links, - providersDiffer, - explicitTruncation, - limitation, - ]: readonly [ - "pseudocode" | "assembly", - string, - string, - boolean, - boolean, - readonly string[], - boolean, - boolean?, - string?, - ] + dimension: "pseudocode" | "assembly", + left: string, + right: string, + context: ComparisonContext, ): FunctionDimension => { - const truncated = explicitTruncation ?? (!leftComplete || !rightComplete); - if (!leftComplete || !rightComplete || providersDiffer) - return unresolvedDimension( + const limitations = + dimension === "assembly" + ? [ + "Assembly is opaque provider text; relocation normalization is unavailable.", + ] + : []; + if (context.providersDiffer) + return unresolvedDimension({ dimension, - truncated ? "truncated" : "unknown", - links, - left.length, - right.length, - [ - ...(limitation === undefined ? [] : [limitation]), - ...(providersDiffer - ? ["Exact text comparison requires one provider identity."] - : []), + links: context.links, + leftCount: [...left].length, + rightCount: [...right].length, + limitations: [ + ...limitations, + "Exact text comparison requires one provider identity.", ], - ); + }); const changes = diffLines(left, right, { timeout: 100, maxEditLength: 10_000, }); if (changes === undefined) - return unresolvedDimension( + return unresolvedDimension({ dimension, - "unknown", - links, - left.length, - right.length, - ["Bounded line diff exceeded its time or edit-distance limit."], - ); + links: context.links, + leftCount: [...left].length, + rightCount: [...right].length, + limitations: [ + "Bounded line diff exceeded its time or edit-distance limit.", + ], + }); const delta = changes.reduce( (summary, change) => ({ added_lines: @@ -145,138 +106,59 @@ const compareText = ( status: delta.hunks === 0 ? "unchanged" : "changed", left, right, - links, - providersDiffer, + ...context, leftCount: [...left].length, rightCount: [...right].length, textDelta: delta, - limitations: limitation === undefined ? [] : [limitation], + limitations, }); }; -const compareCollections = ( - ...[ - dimension, - left, - right, - leftCoverage, - rightCoverage, - links, - providersDiffer, - ]: readonly [ - DimensionName, - readonly unknown[], - readonly unknown[], - Pick, - Pick, - readonly string[], - boolean, - ] -): FunctionDimension => { - if (!leftCoverage.complete || !rightCoverage.complete) - return unresolvedDimension( - dimension, - leftCoverage.truncated || rightCoverage.truncated - ? "truncated" - : "unknown", - links, - left.length, - right.length, - [], - ); - return compareValues( - dimension, - sorted(left), - sorted(right), - links, - true, - true, - providersDiffer, - ); -}; - const compareComments = ( left: FunctionSnapshot, right: FunctionSnapshot, - links: readonly string[], - providersDiffer: boolean, + context: ComparisonContext, ): FunctionDimension => { const leftValues = commentProjection(left); const rightValues = commentProjection(right); if (leftValues === null || rightValues === null) - return unresolvedDimension( - "comments", - "unknown", - links, - left.collections.comments.items.length, - right.collections.comments.items.length, - ["Comment locations could not be normalized relative to the function."], - ); - return compareCollections( - "comments", - leftValues, - rightValues, - left.collections.comments, - right.collections.comments, - links, - providersDiffer, - ); + return unresolvedDimension({ + dimension: "comments", + links: context.links, + leftCount: left.dossier.comments.length, + rightCount: right.dossier.comments.length, + limitations: [ + "Comment locations could not be normalized relative to the function.", + ], + }); + return compareValues("comments", leftValues, rightValues, context); }; const compareStringsAndNames = ( left: FunctionSnapshot, right: FunctionSnapshot, - links: readonly string[], - providersDiffer: boolean, + context: ComparisonContext, ): FunctionDimension => { const leftValues = stringAndNameProjection(left); const rightValues = stringAndNameProjection(right); if (leftValues === null || rightValues === null) - return unresolvedDimension("strings_names", "unknown", links, null, null, [ - "Reference source locations could not be normalized to function offsets.", - ]); - return compareCollections( - "strings_names", - leftValues, - rightValues, - combineCoverage( - left.collections.referenced_strings, - left.collections.referenced_names, - ), - combineCoverage( - right.collections.referenced_strings, - right.collections.referenced_names, - ), - links, - providersDiffer, - ); + return unresolvedDimension({ + dimension: "strings_names", + links: context.links, + leftCount: null, + rightCount: null, + limitations: [ + "Reference source locations could not be normalized to function offsets.", + ], + }); + return compareValues("strings_names", leftValues, rightValues, context); }; const compareReferences = ( left: FunctionSnapshot, right: FunctionSnapshot, - links: readonly string[], - providersDiffer: boolean, + context: ComparisonContext, ): FunctionDimension => { - const leftCoverage = combineCoverage( - left.collections.incoming_references, - left.collections.outgoing_references, - ); - const rightCoverage = combineCoverage( - right.collections.incoming_references, - right.collections.outgoing_references, - ); - if (!leftCoverage.complete || !rightCoverage.complete) - return unresolvedDimension( - "references", - leftCoverage.truncated || rightCoverage.truncated - ? "truncated" - : "unknown", - links, - leftCoverage.items.length, - rightCoverage.items.length, - [], - ); const leftProjection = referenceProjection(left); const rightProjection = referenceProjection(right); if (leftProjection.length === 0 && rightProjection.length === 0) @@ -284,10 +166,7 @@ const compareReferences = ( "references", leftProjection, rightProjection, - links, - true, - true, - providersDiffer, + context, ); if ( canonicalJson(leftProjection, "Function comparison") !== @@ -298,8 +177,7 @@ const compareReferences = ( status: "changed", left: leftProjection, right: rightProjection, - links, - providersDiffer, + ...context, leftCount: leftProjection.length, rightCount: rightProjection.length, textDelta: null, @@ -310,82 +188,75 @@ const compareReferences = ( const leftKinds = referenceKindProjection(left); const rightKinds = referenceKindProjection(right); if (leftKinds !== null && rightKinds !== null) - return compareValues( - "references", - leftKinds, - rightKinds, - links, - true, - true, - providersDiffer, - ); - return unresolvedDimension( - "references", - "unknown", - links, - leftProjection.length, - rightProjection.length, - [ + return compareValues("references", leftKinds, rightKinds, context); + return unresolvedDimension({ + dimension: "references", + links: context.links, + leftCount: leftProjection.length, + rightCount: rightProjection.length, + limitations: [ "At least one provider did not expose reference kinds, so equal endpoints do not prove equal edge semantics.", ], - ); + }); }; const compareIdentity = ( left: FunctionSnapshot, right: FunctionSnapshot, - links: readonly string[], - providersDiffer: boolean, + context: ComparisonContext, ): FunctionDimension => { - if (isAutoName(left.procedure.name) || isAutoName(right.procedure.name)) - return unresolvedDimension("identity", "unknown", links, null, null, [ - "Address-derived function names are not stable cross-version identity.", - ]); + if ( + isAutoName(left.dossier.procedure.name) || + isAutoName(right.dossier.procedure.name) + ) + return unresolvedDimension({ + dimension: "identity", + links: context.links, + leftCount: null, + rightCount: null, + limitations: [ + "Address-derived function names are not stable cross-version identity.", + ], + }); return compareValues( "identity", identityProjection(left), identityProjection(right), - links, - true, - true, - providersDiffer, + context, ); }; const compareCalls = ( left: FunctionSnapshot, right: FunctionSnapshot, - links: readonly string[], - providersDiffer: boolean, + context: ComparisonContext, ): FunctionDimension => { const leftValues = callProjection(left); const rightValues = callProjection(right); if ([...leftValues, ...rightValues].some(({ name }) => isAutoName(name))) - return unresolvedDimension( - "calls", - "unknown", - links, - leftValues.length, - rightValues.length, - ["Address-derived callee or caller names cannot be matched safely."], - ); - return compareCollections( + return unresolvedDimension({ + dimension: "calls", + links: context.links, + leftCount: leftValues.length, + rightCount: rightValues.length, + limitations: [ + "Address-derived callee or caller names cannot be matched safely.", + ], + }); + return compareValues( "calls", - leftValues, - rightValues, - combineCoverage(left.collections.callers, left.collections.callees), - combineCoverage(right.collections.callers, right.collections.callees), - links, - providersDiffer, + sorted(leftValues), + sorted(rightValues), + context, ); }; const callProjection = (snapshot: FunctionSnapshot) => [ - ...project(snapshot.collections.callers, ({ name }) => ({ + ...snapshot.dossier.callers.map(({ name }) => ({ direction: "in" as const, name, })), - ...project(snapshot.collections.callees, ({ name }) => ({ + ...snapshot.dossier.callees.map(({ name }) => ({ direction: "out" as const, name, })), @@ -394,63 +265,31 @@ const callProjection = (snapshot: FunctionSnapshot) => [ const compareCfg = ( left: FunctionSnapshot, right: FunctionSnapshot, - links: readonly string[], - providersDiffer: boolean, + context: ComparisonContext, ): FunctionDimension => { - const leftBlocks = left.collections.basic_blocks; - const rightBlocks = right.collections.basic_blocks; - if (!leftBlocks.complete || !rightBlocks.complete) - return unresolvedDimension( - "cfg", - leftBlocks.truncated || rightBlocks.truncated ? "truncated" : "unknown", - links, - leftBlocks.items.length, - rightBlocks.items.length, - [], - ); - const leftGraph = normalizeCfg(leftBlocks.items); - const rightGraph = normalizeCfg(rightBlocks.items); + const leftBlocks = left.dossier.basic_blocks; + const rightBlocks = right.dossier.basic_blocks; + const leftGraph = normalizeCfg(leftBlocks); + const rightGraph = normalizeCfg(rightBlocks); if (leftGraph === null || rightGraph === null) - return unresolvedDimension( - "cfg", - "unknown", - links, - leftBlocks.items.length, - rightBlocks.items.length, - ["CFG addresses could not be normalized to local block indices."], - ); - return compareValues( - "cfg", - leftGraph, - rightGraph, - links, - true, - true, - providersDiffer, - ); + return unresolvedDimension({ + dimension: "cfg", + links: context.links, + leftCount: leftBlocks.length, + rightCount: rightBlocks.length, + limitations: [ + "CFG addresses could not be normalized to local block indices.", + ], + }); + return compareValues("cfg", leftGraph, rightGraph, context); }; const compareValues = ( - ...[ - dimension, - left, - right, - links, - leftComplete, - rightComplete, - providersDiffer, - ]: readonly [ - DimensionName, - unknown, - unknown, - readonly string[], - boolean, - boolean, - boolean, - ] + dimension: DimensionName, + left: unknown, + right: unknown, + context: ComparisonContext, ): FunctionDimension => { - if (!leftComplete || !rightComplete) - return unresolvedDimension(dimension, "unknown", links, null, null, []); const leftJson = canonicalJson(left, "Function comparison"); const rightJson = canonicalJson(right, "Function comparison"); return dimensionResult({ @@ -458,8 +297,7 @@ const compareValues = ( status: leftJson === rightJson ? "unchanged" : "changed", left, right, - links, - providersDiffer, + ...context, leftCount: Array.isArray(left) ? left.length : null, rightCount: Array.isArray(right) ? right.length : null, textDelta: null, diff --git a/src/domain/functionComparisonNormalization.ts b/src/domain/functionComparisonNormalization.ts index 804127675..ea7b1defc 100644 --- a/src/domain/functionComparisonNormalization.ts +++ b/src/domain/functionComparisonNormalization.ts @@ -1,16 +1,13 @@ import { canonicalJson } from "./comparisonSemantics.js"; import { compareCodePoints } from "./canonicalOrdering.js"; -import type { - FunctionCollection, - FunctionSnapshot, -} from "./functionDossierEvidence.js"; +import type { FunctionSnapshot } from "./functionDossierEvidence.js"; import type { FunctionComparisonResult } from "./functionComparisonSchemas.js"; export const identityProjection = (snapshot: FunctionSnapshot) => ({ - name: snapshot.procedure.name, - signature: snapshot.procedure.signature, - locals: snapshot.procedure.locals + name: snapshot.dossier.procedure.name, + signature: snapshot.dossier.procedure.signature, + locals: snapshot.dossier.procedure.locals .map(({ description }) => description) .sort(), }); @@ -20,26 +17,28 @@ export const functionMatch = ( right: FunctionSnapshot, ): FunctionComparisonResult["function_match"] => { if ( - !isAutoName(left.procedure.name) && - left.procedure.name === right.procedure.name + !isAutoName(left.dossier.procedure.name) && + left.dossier.procedure.name === right.dossier.procedure.name ) return { status: "matched", method: "symbol", - left_name: left.procedure.name, - right_name: right.procedure.name, + left_name: left.dossier.procedure.name, + right_name: right.dossier.procedure.name, }; return { status: - left.procedure.name === right.procedure.name ? "ambiguous" : "mismatched", + left.dossier.procedure.name === right.dossier.procedure.name + ? "ambiguous" + : "mismatched", method: "explicit", - left_name: left.procedure.name, - right_name: right.procedure.name, + left_name: left.dossier.procedure.name, + right_name: right.dossier.procedure.name, }; }; export const normalizeCfg = ( - blocks: FunctionSnapshot["collections"]["basic_blocks"]["items"], + blocks: FunctionSnapshot["dossier"]["basic_blocks"], ): readonly unknown[] | null => { const parsed: { block: (typeof blocks)[number]; @@ -78,12 +77,12 @@ export const normalizeCfg = ( export const referenceProjection = (snapshot: FunctionSnapshot) => sorted([ - ...snapshot.collections.incoming_references.items.map((item) => ({ + ...snapshot.dossier.incoming_references.map((item) => ({ direction: "in", source: item.source_procedure?.name ?? null, target: item.target_procedure?.name ?? null, })), - ...snapshot.collections.outgoing_references.items.map((item) => ({ + ...snapshot.dossier.outgoing_references.map((item) => ({ direction: "out", source: item.source_procedure?.name ?? null, target: item.target_procedure?.name ?? null, @@ -94,11 +93,11 @@ export const referenceKindProjection = ( snapshot: FunctionSnapshot, ): readonly unknown[] | null => { const edges = [ - ...snapshot.collections.incoming_references.items.map((edge) => ({ + ...snapshot.dossier.incoming_references.map((edge) => ({ direction: "in", edge, })), - ...snapshot.collections.outgoing_references.items.map((edge) => ({ + ...snapshot.dossier.outgoing_references.map((edge) => ({ direction: "out", edge, })), @@ -136,13 +135,11 @@ export const referenceKindProjection = ( export const commentProjection = ( snapshot: FunctionSnapshot, ): readonly unknown[] | null => { - const values = snapshot.collections.comments.items.map( - ({ address, kind, text }) => ({ - offset: relativeAddress(address, snapshot.procedure.address), - kind, - text, - }), - ); + const values = snapshot.dossier.comments.map(({ address, kind, text }) => ({ + offset: relativeAddress(address, snapshot.dossier.procedure.address), + kind, + text, + })); return values.some(({ offset }) => offset === null) ? null : sorted(values); }; @@ -150,22 +147,22 @@ export const stringAndNameProjection = ( snapshot: FunctionSnapshot, ): readonly unknown[] | null => { const values = [ - ...snapshot.collections.referenced_strings.items.map( + ...snapshot.dossier.referenced_strings.map( ({ source_address: sourceAddress, value }) => ({ kind: "string", source_offset: relativeAddress( sourceAddress, - snapshot.procedure.address, + snapshot.dossier.procedure.address, ), value, }), ), - ...snapshot.collections.referenced_names.items.map( + ...snapshot.dossier.referenced_names.map( ({ source_address: sourceAddress, value }) => ({ kind: "name", source_offset: relativeAddress( sourceAddress, - snapshot.procedure.address, + snapshot.dossier.procedure.address, ), value, }), @@ -182,32 +179,9 @@ export const sorted = (values: readonly unknown[]): readonly unknown[] => value, json: canonicalJson(value, "Function normalization"), })) - .sort((left, right) => { - // Preserve existing collation while ordering distinct values within a tie. - return ( - left.json.localeCompare(right.json) || - compareCodePoints(left.json, right.json) - ); - }) + .sort((left, right) => compareCodePoints(left.json, right.json)) .map(({ value }) => value); -export const combineCoverage = ( - left: FunctionCollection, - right: FunctionCollection, -): FunctionCollection => { - return { - items: [...left.items, ...right.items], - total: left.total + right.total, - complete: true, - truncated: false, - }; -}; - -export const project = ( - collection: FunctionCollection, - mapper: (item: Input) => Output, -): Output[] => collection.items.map(mapper); - export const isAutoName = (name: string): boolean => /^(?:sub_[0-9a-f]+|fcn\.[0-9a-f]+)$/iu.test(name); diff --git a/src/domain/functionComparisonResults.ts b/src/domain/functionComparisonResults.ts index d635cc317..b605b947f 100644 --- a/src/domain/functionComparisonResults.ts +++ b/src/domain/functionComparisonResults.ts @@ -48,14 +48,13 @@ export const dimensionResult = ( export const unresolvedDimension = (input: { readonly dimension: DimensionName; - readonly status: "truncated" | "unknown"; readonly links: readonly string[]; readonly leftCount: number | null; readonly rightCount: number | null; readonly limitations: readonly string[]; }): FunctionDimension => ({ dimension: input.dimension, - status: input.status, + status: "unknown", left_digest: null, right_digest: null, left_count: input.leftCount, @@ -70,8 +69,6 @@ export const overallStatus = ( dimensions: readonly FunctionDimension[], match: FunctionComparisonResult["function_match"]["status"], ): FunctionComparisonResult["status"] => { - if (dimensions.some(({ status }) => status === "truncated")) - return "truncated"; if ( match === "ambiguous" || dimensions.some(({ status }) => status === "unknown") @@ -86,7 +83,6 @@ export const overallStatus = ( export const summarize = (dimensions: readonly FunctionDimension[]) => ({ unchanged: dimensions.filter(({ status }) => status === "unchanged").length, changed: dimensions.filter(({ status }) => status === "changed").length, - truncated: dimensions.filter(({ status }) => status === "truncated").length, unknown: dimensions.filter(({ status }) => status === "unknown").length, }); diff --git a/src/domain/functionComparisonSchemas.ts b/src/domain/functionComparisonSchemas.ts index 24b7ed1fb..26c10b1fb 100644 --- a/src/domain/functionComparisonSchemas.ts +++ b/src/domain/functionComparisonSchemas.ts @@ -3,12 +3,7 @@ import { evidenceSchema } from "./evidence.js"; import { digestSchema } from "./../domain/digests.js"; import { prefixedDigestSchema } from "./../domain/digests.js"; -const comparisonStatusSchema = z.enum([ - "unchanged", - "changed", - "truncated", - "unknown", -]); +const comparisonStatusSchema = z.enum(["unchanged", "changed", "unknown"]); const dimensionNameSchema = z.enum([ "identity", "pseudocode", @@ -60,7 +55,7 @@ const functionDimensionSchema = z.union([ }), z.object({ ...functionDimensionContextShape, - status: z.enum(["truncated", "unknown"]), + status: z.literal("unknown"), left_digest: z.null(), right_digest: z.null(), text_delta: z.null(), @@ -92,7 +87,6 @@ export const functionComparisonResultSchema = z.object({ summary: z.object({ unchanged: z.number().int().min(0), changed: z.number().int().min(0), - truncated: z.number().int().min(0), unknown: z.number().int().min(0), }), dimensions: z.array(functionDimensionSchema).length(8), diff --git a/src/domain/functionDossierEvidence.ts b/src/domain/functionDossierEvidence.ts index cdaa4235e..852b0faeb 100644 --- a/src/domain/functionDossierEvidence.ts +++ b/src/domain/functionDossierEvidence.ts @@ -1,48 +1,11 @@ import { parseEvidence, type Evidence } from "./evidence.js"; import { functionDossierSchema, type FunctionDossier } from "./hopperValues.js"; -const DOSSIER_COLLECTION_FIELDS = [ - "assembly", - "comments", - "callers", - "callees", - "incoming_references", - "outgoing_references", - "referenced_strings", - "referenced_names", - "basic_blocks", -] as const; - -type DossierCollectionField = (typeof DOSSIER_COLLECTION_FIELDS)[number]; -type DossierItem = - FunctionDossier[Field][number]; - -export type FunctionCollection = { - readonly items: readonly Item[]; - readonly total: number; - readonly complete: true; - readonly truncated: false; -}; - -type FunctionCollections = { - readonly [Field in DossierCollectionField]: FunctionCollection< - DossierItem - >; -}; - /** Complete function observation parsed from one analyze_function Evidence record. */ export interface FunctionSnapshot { - readonly evidence: readonly [Evidence]; - readonly procedure: FunctionDossier["procedure"]; - readonly provider: Evidence["provider"]; + readonly evidence: Evidence; readonly subject: NonNullable; - readonly pseudocode: { - readonly text: string; - readonly total: number; - readonly complete: true; - readonly truncated: false; - }; - readonly collections: FunctionCollections; + readonly dossier: FunctionDossier; readonly limitations: readonly string[]; } @@ -57,38 +20,11 @@ export const parseFunctionEvidence = (input: unknown): FunctionSnapshot => { throw new TypeError("Function comparison requires artifact-bound Evidence"); const dossier = functionDossierSchema.parse(evidence.normalized_result); return { - evidence: [evidence], - procedure: dossier.procedure, - provider: evidence.provider, + evidence, subject: evidence.subject, - pseudocode: { - text: dossier.pseudocode, - total: [...dossier.pseudocode].length, - complete: true, - truncated: false, - }, - collections: { - assembly: completeCollection(dossier.assembly), - comments: completeCollection(dossier.comments), - callers: completeCollection(dossier.callers), - callees: completeCollection(dossier.callees), - incoming_references: completeCollection(dossier.incoming_references), - outgoing_references: completeCollection(dossier.outgoing_references), - referenced_strings: completeCollection(dossier.referenced_strings), - referenced_names: completeCollection(dossier.referenced_names), - basic_blocks: completeCollection(dossier.basic_blocks), - }, + dossier, limitations: [ ...new Set([...evidence.limitations, ...dossier.limitations]), ].sort((left, right) => left.localeCompare(right)), }; }; - -const completeCollection = ( - items: readonly Item[], -): FunctionCollection => ({ - items, - total: items.length, - complete: true, - truncated: false, -}); diff --git a/src/domain/referenceSourceGraph.test.ts b/src/domain/referenceSourceGraph.test.ts index 4cd384005..c4b201813 100644 --- a/src/domain/referenceSourceGraph.test.ts +++ b/src/domain/referenceSourceGraph.test.ts @@ -184,7 +184,7 @@ describe("historical source graph", () => { } }); - it("retains actual external targets and accepts legacy markers", () => { + it("retains actual external targets and rejects placeholder targets", () => { const input = { ...graphInput(), inventory_state: "partial" as const }; input.entries[2] = symlinkEntry({ target: "/private/shared/target.js", @@ -205,7 +205,7 @@ describe("historical source graph", () => { : entry, ), }), - ).not.toThrow(); + ).toThrow(/target path does not match/u); }); it("derives language and manifest indexes and enforces code-point order", () => { @@ -337,7 +337,7 @@ describe("historical source graph validation", () => { : entry, ), }), - ).not.toThrow(); + ).toThrow(/target path does not match/u); expect(() => createHistoricalSourceGraph({ ...graphInput(), diff --git a/src/domain/referenceSourceGraph.ts b/src/domain/referenceSourceGraph.ts index 51e614cd3..31a9b566f 100644 --- a/src/domain/referenceSourceGraph.ts +++ b/src/domain/referenceSourceGraph.ts @@ -80,7 +80,6 @@ const symlinkTargetSchema = z .min(1) .refine( (target) => - target === "" || isPortableAbsoluteSymlinkTarget(target) || (!target.startsWith("/") && !target.includes("\\") && @@ -317,12 +316,8 @@ const checkSymlinks = ( if (entry.kind !== "symlink") continue; const absolute = isPortableAbsoluteSymlinkTarget(entry.target); if ( - (entry.target_state === "external" && - entry.target !== "" && - !absolute) || - (entry.target_state === "internal" && - (entry.target === "" || absolute)) || - (entry.target_state === "missing" && entry.target === "") + (entry.target_state === "external" && !absolute) || + (entry.target_state === "internal" && absolute) ) context.addIssue({ code: "custom",