Skip to content

armgit / rea

Public Imported from GitHub
0

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

fix(process): accept a trace identifier the comparison result can represent (#2488)

吴佳浩Alben2c6a4fac4ff3
diff --git a/src/domain/process/processTraceComparison.test.ts b/src/domain/process/processTraceComparison.test.ts
index caeaf7999..2207352e3 100644
--- a/src/domain/process/processTraceComparison.test.ts
+++ b/src/domain/process/processTraceComparison.test.ts
@@ -1,6 +1,7 @@
import { describe, expect, it } from "vitest";
import { parseProcessCapture } from "./processCaptureParsing.js";
import type { ProcessTraceSpecification } from "./processTraceSpecification.js";
+import { processTraceSpecificationSchema as specificationSchema } from "./processTraceSpecification.js";
import { processTraceComparisonResultSchema } from "./processTraceEvaluation.js";
import {
capture,
@@ -100,6 +101,33 @@ describe("generic capture trace comparison", () => {
right: { matched_variant: "two" },
});
});
+
+ it("compares a declared identifier the comparison result can represent", () => {
+ // The specification owns the trace identifier vocabulary and the result
+ // echoes those identifiers verbatim, so both must accept the same values
+ // rather than handing the caller a raw schema error for its own input.
+ const eventId = `e${"0".repeat(64)}`;
+ const specification: ProcessTraceSpecification = {
+ events: [
+ {
+ id: eventId,
+ source: "terminal_raw",
+ exact: terminal,
+ cardinality: { kind: "required" },
+ },
+ ],
+ language: {
+ kind: "finite_traces",
+ variants: [{ id: "only", trace: [eventId] }],
+ },
+ };
+ expect(specificationSchema.safeParse(specification).success).toBe(true);
+ const left = capture(values(["terminal", "process"]));
+ expect(compareProcessTraces(left, left, specification)).toMatchObject({
+ verdict: "equivalent",
+ left: { matched_variant: "only", raw_trace: [{ event_id: eventId }] },
+ });
+ });
});
describe("process trace constraints and evidence sufficiency", () => {
diff --git a/src/domain/process/processTraceEvaluation.ts b/src/domain/process/processTraceEvaluation.ts
index 51a2a15f8..7c232a480 100644
--- a/src/domain/process/processTraceEvaluation.ts
+++ b/src/domain/process/processTraceEvaluation.ts
@@ -13,13 +13,12 @@ import {
import {
canonicalTraceJson,
processTraceCardinalityBounds,
+ processTraceIdentifierSchema,
type ProcessTraceSpecification,
} from "./processTraceSpecification.js";
-const identifierSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._\x2d]{0,63}$/u);
-
const matchedEventSchema = z.strictObject({
- event_id: identifierSchema,
+ event_id: processTraceIdentifierSchema,
location: processObservationLocationSchema,
});
@@ -32,7 +31,7 @@ const sideResultSchema = z.union([
z.strictObject({
...sideResultShape,
status: z.literal("pass"),
- matched_variant: identifierSchema.nullable(),
+ matched_variant: processTraceIdentifierSchema.nullable(),
}),
z.strictObject({
...sideResultShape,
@@ -53,7 +52,7 @@ const diagnosticSchema = z.strictObject({
]),
side: z.enum(["left", "right"]),
message: z.string(),
- event_ids: z.array(identifierSchema),
+ event_ids: z.array(processTraceIdentifierSchema),
locations: z.array(processObservationLocationSchema),
});
diff --git a/src/domain/process/processTraceSpecification.ts b/src/domain/process/processTraceSpecification.ts
index 09c14cf10..4e28774e0 100644
--- a/src/domain/process/processTraceSpecification.ts
+++ b/src/domain/process/processTraceSpecification.ts
@@ -9,7 +9,16 @@ import {
processObservationSourceSchema,
} from "./processObservation.js";
-const identifierSchema = z.string().regex(IDENTIFIER_PATTERN);
+/**
+ * A declared trace, event or variant identifier. The specification owns this
+ * vocabulary and the comparison result echoes those identifiers verbatim, so
+ * the result module must reuse this schema rather than restate the pattern:
+ * two bounds on the same identifier would reject the result of an accepted
+ * specification.
+ */
+export const processTraceIdentifierSchema = z
+ .string()
+ .regex(IDENTIFIER_PATTERN);
const cardinalitySchema = z.discriminatedUnion("kind", [
z.strictObject({ kind: z.literal("required") }),
@@ -31,7 +40,7 @@ const cardinalitySchema = z.discriminatedUnion("kind", [
]);
const eventDeclarationSchema = z.strictObject({
- id: identifierSchema,
+ id: processTraceIdentifierSchema,
source: processObservationSourceSchema,
exact: jsonValueSchema,
ignore_fields: z
@@ -56,29 +65,31 @@ const partialOrderLanguageSchema = z.strictObject({
happens_before: z
.array(
z.strictObject({
- before: identifierSchema,
- after: identifierSchema,
+ before: processTraceIdentifierSchema,
+ after: processTraceIdentifierSchema,
}),
)
.default([]),
not_before: z
.array(
z.strictObject({
- event: identifierSchema,
- anchor: identifierSchema,
+ event: processTraceIdentifierSchema,
+ anchor: processTraceIdentifierSchema,
}),
)
.default([]),
unordered_groups: z
- .array(z.strictObject({ events: z.array(identifierSchema).min(2) }))
+ .array(
+ z.strictObject({ events: z.array(processTraceIdentifierSchema).min(2) }),
+ )
.default([]),
- prefix: z.array(identifierSchema).default([]),
- suffix: z.array(identifierSchema).default([]),
+ prefix: z.array(processTraceIdentifierSchema).default([]),
+ suffix: z.array(processTraceIdentifierSchema).default([]),
});
const finiteTraceTokenSchema = z.union([
- identifierSchema,
- z.strictObject({ unordered: z.array(identifierSchema).min(2) }),
+ processTraceIdentifierSchema,
+ z.strictObject({ unordered: z.array(processTraceIdentifierSchema).min(2) }),
]);
const finiteTraceLanguageSchema = z.strictObject({
@@ -86,7 +97,7 @@ const finiteTraceLanguageSchema = z.strictObject({
variants: z
.array(
z.strictObject({
- id: identifierSchema,
+ id: processTraceIdentifierSchema,
trace: z.array(finiteTraceTokenSchema),
}),
)