@valerypopoff/rivet2-evaluations 2.3.0

package/dist/esm/assertions.js

@@ -0,0 +1,555 @@
+import { assertPortableJson, canonicalStringify } from './canonical.js';
+function readQuotedPathKey(source, start) {
+    const quote = source[start];
+    if (quote !== '"' && quote !== "'")
+        return undefined;
+    let cursor = start + 1;
+    let key = '';
+    while (cursor < source.length) {
+        const character = source[cursor++];
+        if (character === quote)
+            return { key, cursor };
+        if (character !== '\\') {
+            key += character;
+            continue;
+        }
+        const escaped = source[cursor++];
+        if (escaped === undefined)
+            return undefined;
+        if (escaped === 'u') {
+            const hex = source.slice(cursor, cursor + 4);
+            if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                return undefined;
+            key += String.fromCharCode(Number.parseInt(hex, 16));
+            cursor += 4;
+            continue;
+        }
+        const escapes = {
+            '"': '"',
+            "'": "'",
+            '\\': '\\',
+            '/': '/',
+            b: '\b',
+            f: '\f',
+            n: '\n',
+            r: '\r',
+            t: '\t',
+        };
+        if (!(escaped in escapes))
+            return undefined;
+        key += escapes[escaped];
+    }
+    return undefined;
+}
+function parseEvaluationOutputPath(path) {
+    const source = path.trim();
+    if (source === '$')
+        return [];
+    if (!source.startsWith('$') || source.length === 1)
+        return undefined;
+    let cursor = 1;
+    const segments = [];
+    // Validate every character. A partially parsed selector could otherwise
+    // assert against a different output than the author wrote (for example
+    // `$.answer!`). Dot notation intentionally remains identifier-only; quoted
+    // bracket notation covers output names containing spaces, dots, or dashes.
+    while (cursor < source.length) {
+        if (source[cursor] === '.') {
+            cursor += 1;
+            while (/\s/u.test(source[cursor] ?? ''))
+                cursor += 1;
+            const identifier = /^[A-Za-z_$][\w$]*/u.exec(source.slice(cursor));
+            if (!identifier)
+                return undefined;
+            segments.push({ kind: 'property', key: identifier[0] });
+            cursor += identifier[0].length;
+        }
+        else if (source[cursor] === '[') {
+            cursor += 1;
+            while (/\s/u.test(source[cursor] ?? ''))
+                cursor += 1;
+            const quoted = readQuotedPathKey(source, cursor);
+            if (quoted) {
+                segments.push({ kind: 'property', key: quoted.key });
+                cursor = quoted.cursor;
+            }
+            else {
+                const index = /^\d+/u.exec(source.slice(cursor));
+                if (!index)
+                    return undefined;
+                segments.push({ kind: 'index', index: Number(index[0]) });
+                cursor += index[0].length;
+            }
+            while (/\s/u.test(source[cursor] ?? ''))
+                cursor += 1;
+            if (source[cursor] !== ']')
+                return undefined;
+            cursor += 1;
+        }
+        else {
+            return undefined;
+        }
+    }
+    return segments;
+}
+/**
+ * Validates the exact JSON-path subset supported by evaluation assertions.
+ * UI authoring and runtime execution intentionally share this parser so a
+ * path cannot pass preflight and then resolve with different grammar.
+ */
+export function isEvaluationOutputPathSyntaxValid(path) {
+    return parseEvaluationOutputPath(path) !== undefined;
+}
+/** The Graph Output that owns an assertion path, including nested paths. */
+export function getEvaluationTopLevelOutputId(path) {
+    const first = parseEvaluationOutputPath(path)?.[0];
+    return first?.kind === 'property' ? first.key : undefined;
+}
+function getPath(value, path) {
+    const segments = parseEvaluationOutputPath(path);
+    if (!segments)
+        return undefined;
+    let current = value;
+    for (const segment of segments) {
+        if (Array.isArray(current)) {
+            if (segment.kind !== 'index')
+                return undefined;
+            const index = segment.index;
+            if (!Number.isInteger(index) || index < 0 || index >= current.length)
+                return undefined;
+            current = current[index];
+            continue;
+        }
+        if (segment.kind !== 'property')
+            return undefined;
+        if (current === null || typeof current !== 'object' || !Object.hasOwn(current, segment.key))
+            return undefined;
+        current = current[segment.key];
+    }
+    return current;
+}
+function expectedValue(assertion, testCase) {
+    if (assertion.expected.kind === 'literal')
+        return assertion.expected.value;
+    const value = testCase.values[assertion.expected.fieldId];
+    if (value === undefined)
+        throw new Error(`Expected dataset field "${assertion.expected.fieldId}" is missing.`);
+    return value;
+}
+function typeMatches(actual, expected) {
+    if (typeof expected !== 'string')
+        return false;
+    if (actual === undefined)
+        return false;
+    if (expected === 'array')
+        return Array.isArray(actual);
+    if (expected === 'null')
+        return actual === null;
+    if (expected === 'object')
+        return actual !== null && typeof actual === 'object' && !Array.isArray(actual);
+    return typeof actual === expected;
+}
+function expectedTextList(assertion, expected) {
+    if (!Array.isArray(expected) || expected.length === 0 || expected.some((value) => typeof value !== 'string')) {
+        throw new Error(`Quality check "${assertion.name}" requires a non-empty array of expected text values.`);
+    }
+    return expected;
+}
+function assertionConfigurationError(assertion, message) {
+    throw new Error(`Quality check "${assertion.name}" ${message}`);
+}
+const ASSERTION_TYPE_NAMES = new Set(['array', 'boolean', 'null', 'number', 'object', 'string']);
+function expectedTypeName(assertion, expected) {
+    if (typeof expected !== 'string' || !ASSERTION_TYPE_NAMES.has(expected)) {
+        assertionConfigurationError(assertion, 'requires one of these expected type names: array, boolean, null, number, object, or string.');
+    }
+    return expected;
+}
+function expectedString(assertion, expected, description) {
+    if (typeof expected !== 'string') {
+        assertionConfigurationError(assertion, `requires ${description} to be a string.`);
+    }
+    return expected;
+}
+function expectedFiniteNumber(assertion, expected, description) {
+    if (typeof expected !== 'number' || !Number.isFinite(expected)) {
+        assertionConfigurationError(assertion, `requires ${description} to be a finite number.`);
+    }
+    return expected;
+}
+function expectedNumberRange(assertion, expected) {
+    if (!Array.isArray(expected) ||
+        expected.length !== 2 ||
+        typeof expected[0] !== 'number' ||
+        !Number.isFinite(expected[0]) ||
+        typeof expected[1] !== 'number' ||
+        !Number.isFinite(expected[1])) {
+        assertionConfigurationError(assertion, 'requires an expected range containing exactly two finite numbers.');
+    }
+    if (expected[0] > expected[1]) {
+        assertionConfigurationError(assertion, 'requires its expected range minimum to be no greater than its maximum.');
+    }
+    return expected;
+}
+function expectedSet(assertion, expected) {
+    if (!Array.isArray(expected))
+        assertionConfigurationError(assertion, 'requires the expected set to be an array.');
+    return expected;
+}
+function operatorDescription(operator) {
+    switch (operator) {
+        case 'equals':
+            return 'equals';
+        case 'not-equals':
+            return 'does not equal';
+        case 'contains':
+            return 'contains the expected text';
+        case 'matches-regex':
+            return 'matches the regular expression';
+        case 'type-is':
+            return 'has the expected type';
+        case 'json-schema':
+            return 'matches the JSON Schema';
+        case 'number-at-least':
+            return 'is at least the expected value';
+        case 'number-at-most':
+            return 'is at most the expected value';
+        case 'number-between':
+            return 'is inside the expected range';
+        case 'array-includes':
+            return 'includes the expected value';
+        case 'set-overlaps':
+            return 'overlaps the expected set';
+        case 'contains-any':
+            return 'contains any expected text';
+        case 'contains-all':
+            return 'contains every expected text';
+    }
+}
+/**
+ * Validates author-controlled expected data without needing target outputs.
+ * The runner uses this before scheduling work; assertion execution uses the
+ * same function so direct callers cannot observe a looser contract.
+ */
+export function validateEvaluationAssertionExpectedValue(assertion, expected) {
+    assertPortableJson(expected, `quality check ${assertion.name} expected value`);
+    switch (assertion.operator) {
+        case 'equals':
+        case 'not-equals':
+        case 'array-includes':
+            return;
+        case 'contains':
+            expectedString(assertion, expected, 'its expected text');
+            return;
+        case 'matches-regex': {
+            const pattern = expectedString(assertion, expected, 'its expected regular expression');
+            try {
+                new RegExp(pattern);
+            }
+            catch {
+                assertionConfigurationError(assertion, 'contains an invalid expected regular expression.');
+            }
+            return;
+        }
+        case 'type-is':
+            expectedTypeName(assertion, expected);
+            return;
+        case 'json-schema':
+            assertSupportedJsonSchema(assertion, expected);
+            return;
+        case 'number-at-least':
+            expectedFiniteNumber(assertion, expected, 'its expected minimum');
+            return;
+        case 'number-at-most':
+            expectedFiniteNumber(assertion, expected, 'its expected maximum');
+            return;
+        case 'number-between':
+            expectedNumberRange(assertion, expected);
+            return;
+        case 'set-overlaps':
+            expectedSet(assertion, expected);
+            return;
+        case 'contains-any':
+        case 'contains-all':
+            expectedTextList(assertion, expected);
+            return;
+    }
+}
+export function validateEvaluationAssertionConfiguration(assertion, expected) {
+    if (!isEvaluationOutputPathSyntaxValid(assertion.outputPath)) {
+        assertionConfigurationError(assertion, `uses invalid output path "${assertion.outputPath}".`);
+    }
+    validateEvaluationAssertionExpectedValue(assertion, expected);
+}
+const SUPPORTED_SCHEMA_KEYWORDS = new Set([
+    'type',
+    'enum',
+    'const',
+    'minLength',
+    'maxLength',
+    'pattern',
+    'minimum',
+    'maximum',
+    'minItems',
+    'maxItems',
+    'items',
+    'required',
+    'properties',
+    'additionalProperties',
+]);
+const SUPPORTED_SCHEMA_TYPES = new Set(['array', 'boolean', 'integer', 'null', 'number', 'object', 'string']);
+function schemaRecord(assertion, schema, path) {
+    if (schema === null || typeof schema !== 'object' || Array.isArray(schema)) {
+        assertionConfigurationError(assertion, `requires the JSON Schema at ${path} to be an object.`);
+    }
+    return schema;
+}
+function assertNonNegativeInteger(assertion, value, path) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        assertionConfigurationError(assertion, `requires ${path} to be a non-negative safe integer.`);
+    }
+}
+/**
+ * Validates the exact JSON Schema subset implemented below. Rejecting unknown
+ * constraints is essential: silently ignoring one can turn a schema that
+ * appears strict into a false quality pass.
+ */
+function assertSupportedJsonSchema(assertion, schema, path = '$') {
+    const objectSchema = schemaRecord(assertion, schema, path);
+    for (const keyword of Object.keys(objectSchema)) {
+        if (!SUPPORTED_SCHEMA_KEYWORDS.has(keyword)) {
+            assertionConfigurationError(assertion, `uses unsupported JSON Schema keyword "${keyword}" at ${path}.`);
+        }
+    }
+    if (objectSchema.type !== undefined) {
+        if (typeof objectSchema.type !== 'string' || !SUPPORTED_SCHEMA_TYPES.has(objectSchema.type)) {
+            assertionConfigurationError(assertion, `requires ${path}.type to be one of: array, boolean, integer, null, number, object, or string.`);
+        }
+    }
+    if (objectSchema.enum !== undefined && (!Array.isArray(objectSchema.enum) || objectSchema.enum.length === 0)) {
+        assertionConfigurationError(assertion, `requires ${path}.enum to be a non-empty array.`);
+    }
+    for (const keyword of ['minLength', 'maxLength', 'minItems', 'maxItems']) {
+        if (objectSchema[keyword] !== undefined)
+            assertNonNegativeInteger(assertion, objectSchema[keyword], `${path}.${keyword}`);
+    }
+    if (typeof objectSchema.minLength === 'number' &&
+        typeof objectSchema.maxLength === 'number' &&
+        objectSchema.minLength > objectSchema.maxLength) {
+        assertionConfigurationError(assertion, `requires ${path}.minLength to be no greater than ${path}.maxLength.`);
+    }
+    if (typeof objectSchema.minItems === 'number' &&
+        typeof objectSchema.maxItems === 'number' &&
+        objectSchema.minItems > objectSchema.maxItems) {
+        assertionConfigurationError(assertion, `requires ${path}.minItems to be no greater than ${path}.maxItems.`);
+    }
+    for (const keyword of ['minimum', 'maximum']) {
+        const value = objectSchema[keyword];
+        if (value !== undefined && (typeof value !== 'number' || !Number.isFinite(value))) {
+            assertionConfigurationError(assertion, `requires ${path}.${keyword} to be a finite number.`);
+        }
+    }
+    if (typeof objectSchema.minimum === 'number' &&
+        typeof objectSchema.maximum === 'number' &&
+        objectSchema.minimum > objectSchema.maximum) {
+        assertionConfigurationError(assertion, `requires ${path}.minimum to be no greater than ${path}.maximum.`);
+    }
+    if (objectSchema.pattern !== undefined) {
+        if (typeof objectSchema.pattern !== 'string') {
+            assertionConfigurationError(assertion, `requires ${path}.pattern to be a string.`);
+        }
+        try {
+            new RegExp(objectSchema.pattern);
+        }
+        catch {
+            assertionConfigurationError(assertion, `contains an invalid regular expression at ${path}.pattern.`);
+        }
+    }
+    if (objectSchema.required !== undefined) {
+        if (!Array.isArray(objectSchema.required) ||
+            objectSchema.required.some((key) => typeof key !== 'string' || key.length === 0) ||
+            new Set(objectSchema.required).size !== objectSchema.required.length) {
+            assertionConfigurationError(assertion, `requires ${path}.required to contain unique, non-empty strings.`);
+        }
+    }
+    if (objectSchema.additionalProperties !== undefined && typeof objectSchema.additionalProperties !== 'boolean') {
+        assertionConfigurationError(assertion, `supports only a boolean ${path}.additionalProperties value.`);
+    }
+    if (objectSchema.items !== undefined) {
+        assertSupportedJsonSchema(assertion, objectSchema.items, `${path}.items`);
+    }
+    if (objectSchema.properties !== undefined) {
+        const properties = schemaRecord(assertion, objectSchema.properties, `${path}.properties`);
+        for (const [key, childSchema] of Object.entries(properties)) {
+            assertSupportedJsonSchema(assertion, childSchema, `${path}.properties[${JSON.stringify(key)}]`);
+        }
+    }
+}
+function schemaTypeMatches(actual, expected) {
+    if (expected === 'integer')
+        return typeof actual === 'number' && Number.isInteger(actual);
+    return typeMatches(actual, expected);
+}
+/** Evaluate the validated, deliberately portable JSON Schema subset. */
+function matchesSchema(actual, schema) {
+    if (actual === undefined)
+        return false;
+    const objectSchema = schema;
+    const declaredType = objectSchema.type;
+    if (typeof declaredType === 'string' && !schemaTypeMatches(actual, declaredType))
+        return false;
+    if (Array.isArray(objectSchema.enum) &&
+        !objectSchema.enum.some((candidate) => canonicalStringify(candidate) === canonicalStringify(actual ?? null)))
+        return false;
+    if (Object.hasOwn(objectSchema, 'const') &&
+        canonicalStringify(objectSchema.const) !== canonicalStringify(actual ?? null))
+        return false;
+    if (typeof actual === 'string') {
+        if (typeof objectSchema.minLength === 'number' && actual.length < objectSchema.minLength)
+            return false;
+        if (typeof objectSchema.maxLength === 'number' && actual.length > objectSchema.maxLength)
+            return false;
+        if (typeof objectSchema.pattern === 'string') {
+            if (!new RegExp(objectSchema.pattern).test(actual))
+                return false;
+        }
+    }
+    if (typeof actual === 'number') {
+        if (typeof objectSchema.minimum === 'number' && actual < objectSchema.minimum)
+            return false;
+        if (typeof objectSchema.maximum === 'number' && actual > objectSchema.maximum)
+            return false;
+    }
+    if (Array.isArray(actual)) {
+        if (typeof objectSchema.minItems === 'number' && actual.length < objectSchema.minItems)
+            return false;
+        if (typeof objectSchema.maxItems === 'number' && actual.length > objectSchema.maxItems)
+            return false;
+        if (objectSchema.items !== undefined && !actual.every((item) => matchesSchema(item, objectSchema.items)))
+            return false;
+    }
+    if (actual !== null && typeof actual === 'object' && !Array.isArray(actual)) {
+        const record = actual;
+        if (Array.isArray(objectSchema.required) &&
+            !objectSchema.required.every((key) => typeof key === 'string' && Object.hasOwn(record, key)))
+            return false;
+        const properties = objectSchema.properties;
+        if (properties !== undefined) {
+            const propertySchemas = properties;
+            for (const [key, childSchema] of Object.entries(propertySchemas)) {
+                if (Object.hasOwn(record, key) && !matchesSchema(record[key], childSchema))
+                    return false;
+            }
+        }
+        if (objectSchema.additionalProperties === false) {
+            const propertySchemas = (properties ?? {});
+            if (Object.keys(record).some((key) => !Object.hasOwn(propertySchemas, key)))
+                return false;
+        }
+    }
+    return true;
+}
+export function evaluateAssertion(assertion, outputs, testCase) {
+    const outputRoot = outputs;
+    const actual = getPath(outputRoot, assertion.outputPath);
+    const actualFound = actual !== undefined;
+    const expected = expectedValue(assertion, testCase);
+    validateEvaluationAssertionConfiguration(assertion, expected);
+    let passed = false;
+    switch (assertion.operator) {
+        case 'equals':
+            passed = actual !== undefined && canonicalStringify(actual) === canonicalStringify(expected);
+            break;
+        case 'not-equals':
+            // A configured path must resolve before any comparison can pass. Treating
+            // a missing value as "not equal" would let a typo in an output path turn
+            // into a false quality pass.
+            passed = actual !== undefined && canonicalStringify(actual) !== canonicalStringify(expected);
+            break;
+        case 'contains':
+            {
+                const expectedText = expected;
+                passed = typeof actual === 'string' && actual.includes(expectedText);
+            }
+            break;
+        case 'matches-regex':
+            // Invalid author-supplied expressions are evaluator configuration
+            // errors. Let the runner report that quality could not be evaluated instead
+            // of reporting a normal failed quality assertion.
+            {
+                const pattern = new RegExp(expected);
+                passed = typeof actual === 'string' && pattern.test(actual);
+            }
+            break;
+        case 'type-is':
+            passed = typeMatches(actual, expected);
+            break;
+        case 'json-schema':
+            passed = matchesSchema(actual, expected);
+            break;
+        case 'number-at-least':
+            {
+                const minimum = expected;
+                passed = typeof actual === 'number' && actual >= minimum;
+            }
+            break;
+        case 'number-at-most':
+            {
+                const maximum = expected;
+                passed = typeof actual === 'number' && actual <= maximum;
+            }
+            break;
+        case 'number-between':
+            {
+                const [minimum, maximum] = expected;
+                passed = typeof actual === 'number' && actual >= minimum && actual <= maximum;
+            }
+            break;
+        case 'array-includes':
+            passed =
+                Array.isArray(actual) && actual.some((item) => canonicalStringify(item) === canonicalStringify(expected));
+            break;
+        case 'set-overlaps':
+            {
+                const candidates = expected;
+                passed =
+                    Array.isArray(actual) &&
+                        candidates.some((candidate) => actual.some((item) => canonicalStringify(item) === canonicalStringify(candidate)));
+            }
+            break;
+        case 'contains-any':
+            {
+                const expectedTexts = expected;
+                passed = typeof actual === 'string' && expectedTexts.some((candidate) => actual.includes(candidate));
+            }
+            break;
+        case 'contains-all':
+            {
+                const expectedTexts = expected;
+                passed = typeof actual === 'string' && expectedTexts.every((candidate) => actual.includes(candidate));
+            }
+            break;
+    }
+    const requirement = operatorDescription(assertion.operator);
+    return {
+        id: assertion.id,
+        kind: 'assertion',
+        name: assertion.name,
+        required: assertion.required !== false,
+        status: passed ? 'passed' : 'failed',
+        message: passed
+            ? `Target output ${requirement}.`
+            : actualFound
+                ? `Target output does not satisfy the requirement: ${requirement}.`
+                : `Target output path "${assertion.outputPath}" does not exist.`,
+        evidence: {
+            actual: actual ?? null,
+            actualFound,
+            expected,
+            outputPath: assertion.outputPath,
+            operator: assertion.operator,
+            expectedSource: assertion.expected.kind,
+            ...(assertion.expected.kind === 'dataset-field' ? { expectedFieldId: assertion.expected.fieldId } : {}),
+        },
+    };
+}

package/dist/esm/canonical.js

@@ -0,0 +1,109 @@
+export function assertPortableJson(value, path = '$', stack = new Set()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new Error(`${path} must not contain a non-finite number.`);
+        return;
+    }
+    if (typeof value !== 'object')
+        throw new Error(`${path} must be portable JSON.`);
+    if (stack.has(value))
+        throw new Error(`${path} must not contain a cycle.`);
+    if (Array.isArray(value)) {
+        if (Object.getOwnPropertySymbols(value).length > 0) {
+            throw new Error(`${path} must not contain symbol-keyed array properties.`);
+        }
+        stack.add(value);
+        try {
+            for (let index = 0; index < value.length; index += 1) {
+                const descriptor = Object.getOwnPropertyDescriptor(value, index);
+                if (!descriptor)
+                    throw new Error(`${path}[${index}] must not be a sparse array entry.`);
+                if (!descriptor.enumerable || descriptor.get || descriptor.set) {
+                    throw new Error(`${path}[${index}] must be an enumerable data property.`);
+                }
+                assertPortableJson(descriptor.value, `${path}[${index}]`, stack);
+            }
+            if (Object.getOwnPropertyNames(value).length !== value.length + 1) {
+                throw new Error(`${path} must not contain hidden or extra array properties.`);
+            }
+        }
+        finally {
+            stack.delete(value);
+        }
+        return;
+    }
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+        throw new Error(`${path} must be a plain object.`);
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+        throw new Error(`${path} must not contain symbol-keyed object properties.`);
+    }
+    const ownPropertyNames = Object.getOwnPropertyNames(value);
+    const keys = Object.keys(value);
+    if (ownPropertyNames.length !== keys.length) {
+        throw new Error(`${path} must not contain non-enumerable object properties.`);
+    }
+    stack.add(value);
+    try {
+        for (const key of keys) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor || descriptor.get || descriptor.set) {
+                throw new Error(`${path}.${key} must be an enumerable data property.`);
+            }
+            assertPortableJson(descriptor.value, `${path}.${key}`, stack);
+        }
+    }
+    finally {
+        stack.delete(value);
+    }
+}
+export function canonicalizePortableJson(value) {
+    assertPortableJson(value);
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map(canonicalizePortableJson);
+    return Object.fromEntries(Object.keys(value)
+        .sort()
+        .map((key) => [key, canonicalizePortableJson(value[key])]));
+}
+/**
+ * Evaluation inputs and observations cross concurrent graph-run boundaries.
+ * Clone them before handing them to an adapter so a Code or evaluator graph
+ * cannot mutate a dataset case, another trial, or the persisted run model.
+ */
+export function clonePortableJson(value) {
+    assertPortableJson(value);
+    return structuredClone(value);
+}
+export function canonicalStringify(value) {
+    return JSON.stringify(canonicalizePortableJson(value));
+}
+/** Stable, synchronously available content fingerprint for project-local identities. */
+export function fingerprint(value) {
+    const source = canonicalStringify(value);
+    let hash = 0xcbf29ce484222325n;
+    for (let index = 0; index < source.length; index += 1) {
+        hash ^= BigInt(source.charCodeAt(index));
+        hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+    }
+    return `fnv1a64:${hash.toString(16).padStart(16, '0')}`;
+}
+export function fingerprintEvaluationDataset(value) {
+    return fingerprint({ datasetId: value.id, fields: value.fields, cases: value.cases });
+}
+/**
+ * A dataset fingerprint is the link between a compact run summary and its
+ * historical input cases. Stores must reject a mismatched key rather than
+ * accepting a snapshot that can no longer prove which cases were run.
+ */
+export function assertEvaluationDatasetSnapshot(snapshot) {
+    if (snapshot.dataset.projectId !== undefined && snapshot.dataset.projectId !== snapshot.projectId) {
+        throw new Error('An evaluation dataset snapshot must belong to its project.');
+    }
+    if (fingerprintEvaluationDataset(snapshot.dataset) !== snapshot.fingerprint) {
+        throw new Error('An evaluation dataset snapshot fingerprint must match its dataset ID, fields, and cases.');
+    }
+}