rea-agents 2.2.0 → 2.3.0

package/dist/domain/processTraceEvaluation.js

@@ -0,0 +1,312 @@
+import { z } from "zod";
+import { processObservationLocationSchema, projectProcessObservation, } from "./processObservation.js";
+import { canonicalTraceJson, comparableTracePayload, processTraceCardinalityBounds, } from "./processTraceSpecification.js";
+const identifierSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]{0,63}$/u);
+const locationSchema = processObservationLocationSchema;
+const matchedEventSchema = z.strictObject({
+    event_id: identifierSchema,
+    location: locationSchema,
+});
+const sideResultSchema = z.strictObject({
+    status: z.enum(["pass", "fail", "unknown"]),
+    matched_variant: identifierSchema.nullable(),
+    satisfied_constraints: z.array(z.string()),
+    raw_trace: z.array(matchedEventSchema),
+});
+const diagnosticSchema = z.strictObject({
+    kind: z.enum([
+        "journal",
+        "predicate",
+        "cardinality",
+        "edge",
+        "prefix",
+        "suffix",
+        "trace",
+    ]),
+    side: z.enum(["left", "right"]),
+    message: z.string(),
+    event_ids: z.array(identifierSchema),
+    locations: z.array(locationSchema),
+});
+/** Structured verdict for one declared process trace language. */
+export const processTraceComparisonResultSchema = z.strictObject({
+    verdict: z.enum(["equivalent", "different", "nonconforming", "unknown"]),
+    left: sideResultSchema,
+    right: sideResultSchema,
+    diagnostic: diagnosticSchema.nullable(),
+});
+const scopesFor = (sources) => new Set([...sources].map((source) => {
+    if (source.startsWith("terminal_"))
+        return "terminal";
+    if (source === "lifecycle")
+        return "exit";
+    if (source === "http" ||
+        source === "websocket" ||
+        source === "replay_transition")
+        return "protocol";
+    if (source === "filesystem")
+        return "filesystem";
+    if (source === "process")
+        return "process";
+    if (source === "shim")
+        return "shim";
+    return "interaction";
+}));
+const unknownSide = () => ({
+    status: "unknown",
+    matched_variant: null,
+    satisfied_constraints: [],
+    raw_trace: [],
+});
+const failure = (input) => ({
+    result: {
+        status: "fail",
+        matched_variant: null,
+        satisfied_constraints: [],
+        raw_trace: input.rawTrace,
+    },
+    diagnostic: {
+        kind: input.kind,
+        message: input.message,
+        event_ids: [...input.eventIds],
+        locations: [...input.locations],
+    },
+});
+const evaluateFiniteTrace = (ids, specification) => {
+    if (specification.language.kind !== "finite_traces")
+        return null;
+    for (const variant of specification.language.variants) {
+        let offset = 0;
+        let accepted = true;
+        for (const token of variant.trace) {
+            if (typeof token === "string") {
+                if (ids[offset] !== token)
+                    accepted = false;
+                offset += 1;
+                continue;
+            }
+            const actual = ids.slice(offset, offset + token.unordered.length).sort();
+            const expected = [...token.unordered].sort();
+            if (canonicalTraceJson(actual) !== canonicalTraceJson(expected))
+                accepted = false;
+            offset += token.unordered.length;
+        }
+        if (accepted && offset === ids.length)
+            return variant.id;
+    }
+    return null;
+};
+const collectRecords = (capture, sources) => {
+    const records = [];
+    for (const location of capture.event_journal ?? []) {
+        const record = projectProcessObservation(capture, location);
+        if (record !== null && sources.has(record.source))
+            records.push({
+                source: record.source,
+                payload: record.payload,
+                location,
+            });
+    }
+    return records;
+};
+const matchRecords = (records, specification) => {
+    const rawTrace = [];
+    const locationsById = new Map();
+    const ignoredFieldsBySource = new Map();
+    const eventsByKey = new Map();
+    for (const event of specification.events) {
+        const ignoredFields = event.ignore_fields ?? [];
+        ignoredFieldsBySource.set(event.source, ignoredFields);
+        eventsByKey.set(`${event.source}\0${canonicalTraceJson(comparableTracePayload(event.exact, ignoredFields))}`, event);
+    }
+    for (const record of records) {
+        const match = eventsByKey.get(`${record.source}\0${canonicalTraceJson(comparableTracePayload(record.payload, ignoredFieldsBySource.get(record.source)))}`);
+        if (match === undefined)
+            return failure({
+                kind: "predicate",
+                message: "Observed event does not match any declared exact predicate.",
+                eventIds: [],
+                locations: [record.location],
+                rawTrace,
+            });
+        rawTrace.push({ event_id: match.id, location: record.location });
+        const locations = locationsById.get(match.id) ?? [];
+        locations.push(record.location);
+        locationsById.set(match.id, locations);
+    }
+    return { rawTrace, locationsById };
+};
+const cardinalityFailure = (trace, specification) => {
+    for (const event of specification.events) {
+        const [minimum, maximum] = processTraceCardinalityBounds(event.cardinality);
+        const locations = trace.locationsById.get(event.id) ?? [];
+        if (locations.length < minimum || locations.length > maximum)
+            return failure({
+                kind: "cardinality",
+                message: `${event.id} observed ${String(locations.length)} times; expected ${String(minimum)}..${String(maximum)}.`,
+                eventIds: [event.id],
+                locations,
+                rawTrace: trace.rawTrace,
+            });
+    }
+    return null;
+};
+const evaluateOrderingConstraints = (trace, language) => {
+    const satisfied = [];
+    for (const edge of language.happens_before) {
+        const before = trace.locationsById.get(edge.before) ?? [];
+        const after = trace.locationsById.get(edge.after) ?? [];
+        const lastBefore = before.at(-1);
+        const firstAfter = after[0];
+        if (lastBefore === undefined && firstAfter !== undefined)
+            return {
+                failure: failure({
+                    kind: "edge",
+                    message: `${edge.before} is required when ${edge.after} occurs.`,
+                    eventIds: [edge.before, edge.after],
+                    locations: [firstAfter],
+                    rawTrace: trace.rawTrace,
+                }),
+                satisfied,
+            };
+        if (lastBefore !== undefined &&
+            firstAfter !== undefined &&
+            lastBefore.capture_order >= firstAfter.capture_order)
+            return {
+                failure: failure({
+                    kind: "edge",
+                    message: `${edge.before} must happen before ${edge.after}.`,
+                    eventIds: [edge.before, edge.after],
+                    locations: [lastBefore, firstAfter],
+                    rawTrace: trace.rawTrace,
+                }),
+                satisfied,
+            };
+        satisfied.push(`happens_before:${edge.before}:${edge.after}`);
+    }
+    for (const constraint of language.not_before) {
+        const events = trace.locationsById.get(constraint.event) ?? [];
+        const anchors = trace.locationsById.get(constraint.anchor) ?? [];
+        const firstEvent = events[0];
+        const firstAnchor = anchors[0];
+        if (firstEvent !== undefined && firstAnchor === undefined)
+            return {
+                failure: failure({
+                    kind: "edge",
+                    message: `${constraint.anchor} is required when ${constraint.event} occurs.`,
+                    eventIds: [constraint.event, constraint.anchor],
+                    locations: [firstEvent],
+                    rawTrace: trace.rawTrace,
+                }),
+                satisfied,
+            };
+        if (firstEvent !== undefined &&
+            firstAnchor !== undefined &&
+            firstEvent.capture_order < firstAnchor.capture_order)
+            return {
+                failure: failure({
+                    kind: "edge",
+                    message: `${constraint.event} must not occur before ${constraint.anchor}.`,
+                    eventIds: [constraint.event, constraint.anchor],
+                    locations: [firstEvent, firstAnchor],
+                    rawTrace: trace.rawTrace,
+                }),
+                satisfied,
+            };
+        satisfied.push(`not_before:${constraint.event}:${constraint.anchor}`);
+    }
+    return { failure: null, satisfied };
+};
+const boundaryFailure = (trace, kind, expected) => {
+    const ids = trace.rawTrace.map(({ event_id }) => event_id);
+    const actual = kind === "prefix"
+        ? ids.slice(0, expected.length)
+        : expected.length === 0
+            ? []
+            : ids.slice(-expected.length);
+    if (canonicalTraceJson(actual) === canonicalTraceJson(expected))
+        return null;
+    const locations = kind === "prefix"
+        ? trace.rawTrace.slice(0, expected.length)
+        : trace.rawTrace.slice(-expected.length);
+    return failure({
+        kind,
+        message: `Observed trace does not satisfy the declared ${kind}.`,
+        eventIds: expected,
+        locations: locations.map(({ location }) => location),
+        rawTrace: trace.rawTrace,
+    });
+};
+const evaluatePartialOrder = (trace, language) => {
+    const ordering = evaluateOrderingConstraints(trace, language);
+    if (ordering.failure !== null)
+        return ordering.failure;
+    const prefixFailure = boundaryFailure(trace, "prefix", language.prefix);
+    if (prefixFailure !== null)
+        return prefixFailure;
+    const suffixFailure = boundaryFailure(trace, "suffix", language.suffix);
+    if (suffixFailure !== null)
+        return suffixFailure;
+    const satisfied = ordering.satisfied;
+    satisfied.push(...language.unordered_groups.map(({ events }) => `unordered:${events.join(":")}`));
+    if (language.prefix.length > 0)
+        satisfied.push(`prefix:${language.prefix.join(":")}`);
+    if (language.suffix.length > 0)
+        satisfied.push(`suffix:${language.suffix.join(":")}`);
+    return {
+        result: {
+            status: "pass",
+            matched_variant: null,
+            satisfied_constraints: satisfied,
+            raw_trace: trace.rawTrace,
+        },
+        diagnostic: null,
+    };
+};
+const evaluateMatchedTrace = (trace, specification) => {
+    const invalidCardinality = cardinalityFailure(trace, specification);
+    if (invalidCardinality !== null)
+        return invalidCardinality;
+    if (specification.language.kind === "partial_order")
+        return evaluatePartialOrder(trace, specification.language);
+    const ids = trace.rawTrace.map(({ event_id }) => event_id);
+    const variant = evaluateFiniteTrace(ids, specification);
+    return variant === null
+        ? failure({
+            kind: "trace",
+            message: "Observed events do not match any finite trace variant.",
+            eventIds: ids,
+            locations: trace.rawTrace.map(({ location }) => location),
+            rawTrace: trace.rawTrace,
+        })
+        : {
+            result: {
+                status: "pass",
+                matched_variant: variant,
+                satisfied_constraints: [`variant:${variant}`],
+                raw_trace: trace.rawTrace,
+            },
+            diagnostic: null,
+        };
+};
+export const evaluateProcessTraceSide = (capture, specification) => {
+    const sources = new Set(specification.events.map(({ source }) => source));
+    const relevantScopes = scopesFor(sources);
+    if (capture.truncated ||
+        capture.residual_unknowns.some(({ scope }) => relevantScopes.has(scope)))
+        return { result: unknownSide(), diagnostic: null };
+    if ((capture.event_journal ?? []).length === 0)
+        return {
+            result: unknownSide(),
+            diagnostic: {
+                kind: "journal",
+                message: "Capture has no cross-source event journal.",
+                event_ids: [],
+                locations: [],
+            },
+        };
+    const matched = matchRecords(collectRecords(capture, sources), specification);
+    return "rawTrace" in matched
+        ? evaluateMatchedTrace(matched, specification)
+        : matched;
+};

package/dist/domain/processTraceSpecification.js

@@ -0,0 +1,373 @@
+import canonicalize from "canonicalize";
+import { z } from "zod";
+import { jsonValueSchema } from "./jsonValue.js";
+import { comparableProcessObservationPayload, processObservationSourceSchema, } from "./processObservation.js";
+const identifierSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]{0,63}$/u);
+/** Process observation families admitted by a declared trace specification. */
+export const processTraceSourceSchema = processObservationSourceSchema;
+const cardinalitySchema = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("required") }),
+    z.strictObject({ kind: z.literal("optional") }),
+    z.strictObject({
+        kind: z.literal("exact"),
+        count: z.number().int().min(0).max(10_000),
+    }),
+    z
+        .strictObject({
+        kind: z.literal("range"),
+        min: z.number().int().min(0).max(10_000),
+        max: z.number().int().min(0).max(10_000),
+    })
+        .refine(({ min, max }) => min <= max, {
+        message: "cardinality min must not exceed max",
+        path: ["min"],
+    }),
+]);
+const eventDeclarationSchema = z.strictObject({
+    id: identifierSchema,
+    source: processTraceSourceSchema,
+    exact: jsonValueSchema,
+    ignore_fields: z
+        .array(z.enum([
+        "sequence",
+        "at_ms",
+        "scheduled_at_ms",
+        "dispatched_at_ms",
+        "elapsed_ms",
+    ]))
+        .max(5)
+        .refine((values) => new Set(values).size === values.length, {
+        message: "ignored event fields must be unique",
+    })
+        .optional(),
+    cardinality: cardinalitySchema.default({ kind: "required" }),
+});
+const partialOrderLanguageSchema = z.strictObject({
+    kind: z.literal("partial_order"),
+    happens_before: z
+        .array(z.strictObject({
+        before: identifierSchema,
+        after: identifierSchema,
+    }))
+        .max(4_096)
+        .default([]),
+    not_before: z
+        .array(z.strictObject({
+        event: identifierSchema,
+        anchor: identifierSchema,
+    }))
+        .max(4_096)
+        .default([]),
+    unordered_groups: z
+        .array(z.strictObject({ events: z.array(identifierSchema).min(2).max(256) }))
+        .max(256)
+        .default([]),
+    prefix: z.array(identifierSchema).max(4_096).default([]),
+    suffix: z.array(identifierSchema).max(4_096).default([]),
+});
+const finiteTraceTokenSchema = z.union([
+    identifierSchema,
+    z.strictObject({ unordered: z.array(identifierSchema).min(2).max(256) }),
+]);
+const finiteTraceLanguageSchema = z.strictObject({
+    kind: z.literal("finite_traces"),
+    variants: z
+        .array(z.strictObject({
+        id: identifierSchema,
+        trace: z.array(finiteTraceTokenSchema).max(4_096),
+    }))
+        .min(1)
+        .max(64),
+});
+const specificationShapeSchema = z.strictObject({
+    version: z.literal(1),
+    events: z.array(eventDeclarationSchema).min(1).max(256),
+    language: z.discriminatedUnion("kind", [
+        partialOrderLanguageSchema,
+        finiteTraceLanguageSchema,
+    ]),
+});
+export const canonicalTraceJson = (value) => {
+    const serialized = canonicalize(value);
+    if (serialized === undefined)
+        throw new TypeError("Trace specification contains a non-JSON value");
+    return serialized;
+};
+/** Remove only explicitly declared schedule metadata before exact matching. */
+export const comparableTracePayload = (value, ignoredFields = []) => comparableProcessObservationPayload(value, ignoredFields);
+export const processTraceCardinalityBounds = (cardinality) => {
+    switch (cardinality.kind) {
+        case "required":
+            return [1, 1];
+        case "optional":
+            return [0, 1];
+        case "exact":
+            return [cardinality.count, cardinality.count];
+        case "range":
+            return [cardinality.min, cardinality.max];
+    }
+};
+const addReferenceIssue = (context, known, id, path) => {
+    if (!known.has(id))
+        context.addIssue({
+            code: "custom",
+            message: `unknown event id: ${id}`,
+            path,
+        });
+};
+const pairKey = (left, right) => [left, right].sort().join("\0");
+const buildAdjacency = (language, context, known) => {
+    const adjacency = new Map([...known].map((id) => [id, new Set()]));
+    for (const [index, edge] of language.happens_before.entries()) {
+        const path = ["language", "happens_before", index];
+        addReferenceIssue(context, known, edge.before, [...path, "before"]);
+        addReferenceIssue(context, known, edge.after, [...path, "after"]);
+        if (edge.before === edge.after)
+            context.addIssue({
+                code: "custom",
+                message: "happens-before edges must reference distinct events",
+                path,
+            });
+        adjacency.get(edge.before)?.add(edge.after);
+    }
+    return adjacency;
+};
+const validateNotBefore = (language, context, known, reachable) => {
+    const pairs = new Set();
+    for (const [index, constraint] of language.not_before.entries()) {
+        const path = ["language", "not_before", index];
+        addReferenceIssue(context, known, constraint.event, [...path, "event"]);
+        addReferenceIssue(context, known, constraint.anchor, [...path, "anchor"]);
+        if (constraint.event === constraint.anchor)
+            context.addIssue({
+                code: "custom",
+                message: "not-before constraints must reference distinct events",
+                path,
+            });
+        const key = pairKey(constraint.event, constraint.anchor);
+        if (pairs.has(key))
+            context.addIssue({
+                code: "custom",
+                message: "not-before event pairs must be declared once",
+                path,
+            });
+        pairs.add(key);
+        if (reachable.get(constraint.event)?.has(constraint.anchor) === true)
+            context.addIssue({
+                code: "custom",
+                message: "not-before constraint conflicts with happens-before order",
+                path,
+            });
+    }
+    return pairs;
+};
+const graphHasCycle = (ids, adjacency) => {
+    const active = new Set();
+    const complete = new Set();
+    const visit = (current) => {
+        if (active.has(current))
+            return true;
+        if (complete.has(current))
+            return false;
+        active.add(current);
+        const cyclic = [...(adjacency.get(current) ?? [])].some(visit);
+        active.delete(current);
+        complete.add(current);
+        return cyclic;
+    };
+    return ids.some(visit);
+};
+const computeReachability = (ids, adjacency) => {
+    const reachable = new Map();
+    for (const origin of ids) {
+        const seen = new Set();
+        const pending = [...(adjacency.get(origin) ?? [])];
+        while (pending.length > 0) {
+            const current = pending.pop();
+            if (current === undefined || seen.has(current))
+                continue;
+            seen.add(current);
+            pending.push(...(adjacency.get(current) ?? []));
+        }
+        reachable.set(origin, seen);
+    }
+    return reachable;
+};
+const isOrdered = (reachable, left, right) => reachable.get(left)?.has(right) === true ||
+    reachable.get(right)?.has(left) === true;
+const validateUnorderedGroups = (language, context, known, relations) => {
+    const pairs = new Set();
+    for (const [groupIndex, group] of language.unordered_groups.entries()) {
+        const path = ["language", "unordered_groups", groupIndex];
+        if (new Set(group.events).size !== group.events.length)
+            context.addIssue({
+                code: "custom",
+                message: "unordered groups must not repeat event ids",
+                path: [...path, "events"],
+            });
+        for (const [eventIndex, id] of group.events.entries())
+            addReferenceIssue(context, known, id, [...path, "events", eventIndex]);
+        for (const [leftIndex, leftId] of group.events.entries()) {
+            for (const rightId of group.events.slice(leftIndex + 1)) {
+                const key = pairKey(leftId, rightId);
+                if (pairs.has(key))
+                    context.addIssue({
+                        code: "custom",
+                        message: "unordered event pairs must be declared once",
+                        path,
+                    });
+                pairs.add(key);
+                if (isOrdered(relations.reachable, leftId, rightId) ||
+                    relations.notBeforePairs.has(key))
+                    context.addIssue({
+                        code: "custom",
+                        message: "ordered events cannot also be declared unordered",
+                        path,
+                    });
+            }
+        }
+    }
+    return pairs;
+};
+const validateCompletePairDeclarations = (ids, relations, unorderedPairs, context) => {
+    for (const [leftIndex, leftId] of ids.entries())
+        for (const rightId of ids.slice(leftIndex + 1))
+            if (!isOrdered(relations.reachable, leftId, rightId) &&
+                !relations.notBeforePairs.has(pairKey(leftId, rightId)) &&
+                !unorderedPairs.has(pairKey(leftId, rightId)))
+                context.addIssue({
+                    code: "custom",
+                    message: `event pair ${leftId}/${rightId} must be explicitly ordered or unordered`,
+                    path: ["language"],
+                });
+};
+const validatePartialOrder = (specification, context) => {
+    if (specification.language.kind !== "partial_order")
+        return;
+    const ids = specification.events.map(({ id }) => id);
+    const known = new Set(ids);
+    const adjacency = buildAdjacency(specification.language, context, known);
+    if (graphHasCycle(ids, adjacency))
+        context.addIssue({
+            code: "custom",
+            message: "happens-before graph must be acyclic",
+            path: ["language"],
+        });
+    const reachable = computeReachability(ids, adjacency);
+    const notBeforePairs = validateNotBefore(specification.language, context, known, reachable);
+    const relations = { reachable, notBeforePairs };
+    const unorderedPairs = validateUnorderedGroups(specification.language, context, known, relations);
+    validateCompletePairDeclarations(ids, relations, unorderedPairs, context);
+    for (const [kind, values] of [
+        ["prefix", specification.language.prefix],
+        ["suffix", specification.language.suffix],
+    ])
+        for (const [index, id] of values.entries())
+            addReferenceIssue(context, known, id, ["language", kind, index]);
+};
+const countVariantEvents = (trace) => {
+    const counts = new Map();
+    for (const token of trace)
+        for (const id of typeof token === "string" ? [token] : token.unordered)
+            counts.set(id, (counts.get(id) ?? 0) + 1);
+    return counts;
+};
+const validateFiniteTraces = (specification, context) => {
+    if (specification.language.kind !== "finite_traces")
+        return;
+    const known = new Set(specification.events.map(({ id }) => id));
+    const variantIds = new Set();
+    const variantTraces = new Set();
+    for (const [variantIndex, variant,] of specification.language.variants.entries()) {
+        const variantPath = ["language", "variants", variantIndex];
+        if (variantIds.has(variant.id))
+            context.addIssue({
+                code: "custom",
+                message: "finite trace variant ids must be unique",
+                path: [...variantPath, "id"],
+            });
+        variantIds.add(variant.id);
+        const canonicalTrace = canonicalTraceJson(variant.trace);
+        if (variantTraces.has(canonicalTrace))
+            context.addIssue({
+                code: "custom",
+                message: "finite trace variants must not duplicate a trace",
+                path: [...variantPath, "trace"],
+            });
+        variantTraces.add(canonicalTrace);
+        for (const [tokenIndex, token] of variant.trace.entries()) {
+            const values = typeof token === "string" ? [token] : token.unordered;
+            for (const [eventIndex, id] of values.entries())
+                addReferenceIssue(context, known, id, [
+                    ...variantPath,
+                    "trace",
+                    tokenIndex,
+                    ...(typeof token === "string" ? [] : ["unordered", eventIndex]),
+                ]);
+        }
+        const counts = countVariantEvents(variant.trace);
+        for (const event of specification.events) {
+            const [minimum, maximum] = processTraceCardinalityBounds(event.cardinality);
+            const count = counts.get(event.id) ?? 0;
+            if (count < minimum || count > maximum)
+                context.addIssue({
+                    code: "custom",
+                    message: `variant ${variant.id} violates ${event.id} cardinality`,
+                    path: [...variantPath, "trace"],
+                });
+        }
+    }
+};
+/** Strict, bounded concurrency model for Process Capture observations. */
+export const processTraceSpecificationSchema = specificationShapeSchema.superRefine((specification, context) => {
+    const ids = new Set();
+    const predicates = new Set();
+    const ignoredFieldsBySource = new Map();
+    for (const [index, event] of specification.events.entries()) {
+        if (ids.has(event.id))
+            context.addIssue({
+                code: "custom",
+                message: "event ids must be unique",
+                path: ["events", index, "id"],
+            });
+        ids.add(event.id);
+        const ignoredFields = [...(event.ignore_fields ?? [])].sort();
+        if (ignoredFields.length > 0 &&
+            (typeof event.exact !== "object" ||
+                event.exact === null ||
+                Array.isArray(event.exact)))
+            context.addIssue({
+                code: "custom",
+                message: "ignored schedule fields require an exact object payload",
+                path: ["events", index, "ignore_fields"],
+            });
+        const ignoredKey = canonicalTraceJson(ignoredFields);
+        const priorIgnoredKey = ignoredFieldsBySource.get(event.source);
+        if (priorIgnoredKey !== undefined && priorIgnoredKey !== ignoredKey)
+            context.addIssue({
+                code: "custom",
+                message: "events from one source must use the same ignored schedule fields",
+                path: ["events", index, "ignore_fields"],
+            });
+        ignoredFieldsBySource.set(event.source, ignoredKey);
+        if (ignoredFields.some((field) => typeof event.exact === "object" &&
+            event.exact !== null &&
+            !Array.isArray(event.exact) &&
+            field in event.exact))
+            context.addIssue({
+                code: "custom",
+                message: "exact payload must omit every ignored schedule field",
+                path: ["events", index, "exact"],
+            });
+        const predicate = `${event.source}\0${canonicalTraceJson(comparableTracePayload(event.exact, ignoredFields))}`;
+        if (predicates.has(predicate))
+            context.addIssue({
+                code: "custom",
+                message: "exact event predicates must not overlap",
+                path: ["events", index],
+            });
+        predicates.add(predicate);
+    }
+    validatePartialOrder(specification, context);
+    validateFiniteTraces(specification, context);
+});