project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-playwright-capability-records.js

@@ -1,218 +0,0 @@
-import { decodeDesignFactResults, decodeEvidenceCapabilityRecords, } from "./long-task-evidence-capability-codec.js";
-export function evidenceRecordsForPlaywrightCases(check, cases) {
-    const records = [];
-    for (const item of cases) {
-        const assertion = [
-            ...check.positive_assertions,
-            ...check.negative_assertions,
-        ].find((candidate) => candidate.key === item.id);
-        if (!assertion)
-            continue;
-        records.push(...baseEvidenceRecords(check, item, assertion), ...designConformanceRecords(check, item, assertion), ...designMethodRecords(check, item, assertion), ...symbolicDesignEvidenceRecords(check, item, assertion), ...semanticFactRecords(check, item, assertion));
-    }
-    return records;
-}
-function baseEvidenceRecords(check, item, assertion) {
-    if (!item.executed)
-        return [];
-    const records = [];
-    if (assertion.evidence_capabilities.includes("interaction_trace"))
-        records.push({
-            assertion_key: assertion.key,
-            capability: "interaction_trace",
-            target_ref: check.execution_target.target_ref,
-            given_keys: item.given_keys,
-            action_keys: item.action_keys,
-        });
-    if (assertion.evidence_capabilities.includes("target_runtime"))
-        records.push({
-            assertion_key: assertion.key,
-            capability: "target_runtime",
-            target_ref: check.execution_target.target_ref,
-            root_entrypoint: check.execution_target_definition.root_entrypoint,
-            session_id: `playwright:${item.id}:${item.project_ids.join(",")}`,
-            cold_start: check.execution_target.entrypoint === "root",
-        });
-    return records;
-}
-function designConformanceRecords(check, item, assertion) {
-    if (!item.executed ||
-        !assertion.evidence_capabilities.includes("design_conformance"))
-        return [];
-    return (check.design_conformance_targets ?? [])
-        .filter((candidate) => candidate.conformance_assertion_ref === assertion.key ||
-        candidate.verification_method_bindings.some((binding) => binding.assertion_ref === assertion.key) ||
-        (candidate.symbolic_method_bindings ?? []).some((binding) => binding.assertion_ref === assertion.key))
-        .map((target) => ({
-        assertion_key: assertion.key,
-        capability: "design_conformance",
-        design_target_ref: target.key,
-        target_ref: target.target_ref,
-        condition_keys: target.condition_keys,
-        actual_artifact_path: target.actual_artifact_path,
-        comparison_artifact_path: target.comparison_artifact_path,
-    }));
-}
-function designMethodRecords(check, item, assertion) {
-    if (!item.executed ||
-        !assertion.evidence_capabilities.includes("design_method"))
-        return [];
-    const records = [];
-    for (const target of check.design_conformance_targets ?? []) {
-        if (target.fact_model === "symbolic_rules_v2")
-            continue;
-        const binding = target.verification_method_bindings.find((candidate) => candidate.assertion_ref === assertion.key);
-        if (!binding)
-            continue;
-        const requiredAttachments = binding.evidence_artifacts.flatMap((artifact) => [
-            designMethodAttachmentName(target.key, binding.method, artifact.condition_key, "record"),
-            designMethodAttachmentName(target.key, binding.method, artifact.condition_key, "observation"),
-        ]);
-        if (!requiredAttachments.every((name) => item.attachment_names.includes(name)))
-            continue;
-        const cells = binding.evidence_artifacts.map((artifact) => {
-            const recordName = designMethodAttachmentName(target.key, binding.method, artifact.condition_key, "record");
-            return {
-                condition_key: artifact.condition_key,
-                artifact_path: artifact.path,
-                observation_artifact_path: artifact.observation_path,
-                fact_refs: artifact.fact_refs,
-                fact_results: designFactResultAttachment(item.attachment_payloads[recordName], `${target.key}:${binding.method}:${artifact.condition_key}`),
-            };
-        });
-        if (cells.some((cell) => cell.fact_results === null))
-            continue;
-        records.push({
-            assertion_key: assertion.key,
-            capability: "design_method",
-            design_target_ref: target.key,
-            target_ref: target.target_ref,
-            method: binding.method,
-            cells: cells.map((cell) => ({
-                ...cell,
-                fact_results: cell.fact_results,
-            })),
-        });
-    }
-    return records;
-}
-function symbolicDesignEvidenceRecords(check, item, assertion) {
-    if (!item.executed)
-        return [];
-    const records = [];
-    for (const target of check.design_conformance_targets ?? []) {
-        if (target.fact_model !== "symbolic_rules_v2")
-            continue;
-        records.push(...symbolicMethodEvidenceRecords(target, item, assertion));
-        const certificate = symbolicCertificateEvidenceRecord(target, item, assertion);
-        if (certificate)
-            records.push(certificate);
-    }
-    return records;
-}
-function symbolicMethodEvidenceRecords(target, item, assertion) {
-    if (!assertion.evidence_capabilities.includes("design_method"))
-        return [];
-    const records = [];
-    for (const binding of target.symbolic_method_bindings ?? []) {
-        if (binding.assertion_ref !== assertion.key)
-            continue;
-        const attachmentName = symbolicDesignMethodAttachmentName(target.key, binding.method);
-        if (!item.attachment_names.includes(attachmentName))
-            continue;
-        const record = typedEvidenceAttachment(item.attachment_payloads[attachmentName], "design_method");
-        if (record?.capability === "design_method" &&
-            "fact_model" in record &&
-            record.assertion_key === assertion.key &&
-            record.design_target_ref === target.key &&
-            record.method === binding.method)
-            records.push(record);
-    }
-    return records;
-}
-function symbolicCertificateEvidenceRecord(target, item, assertion) {
-    const binding = target.symbolic_certificate_binding;
-    if (binding?.assertion_ref !== assertion.key ||
-        !assertion.evidence_capabilities.includes("design_symbolic_certificate"))
-        return null;
-    const attachmentName = symbolicDesignCertificateAttachmentName(target.key);
-    if (!item.attachment_names.includes(attachmentName))
-        return null;
-    const record = typedEvidenceAttachment(item.attachment_payloads[attachmentName], "design_symbolic_certificate");
-    return record?.capability === "design_symbolic_certificate" &&
-        record.assertion_key === assertion.key &&
-        record.design_target_ref === target.key
-        ? record
-        : null;
-}
-function typedEvidenceAttachment(payload, capability) {
-    if (!payload)
-        return null;
-    try {
-        const records = decodeEvidenceCapabilityRecords([JSON.parse(payload)]);
-        const record = records[0];
-        return records.length === 1 && record.capability === capability
-            ? record
-            : null;
-    }
-    catch {
-        return null;
-    }
-}
-function semanticFactRecords(check, item, assertion) {
-    if (!item.executed ||
-        !assertion.evidence_capabilities.includes("semantic_fact"))
-        return [];
-    const expectation = check.semantic_fact_expectations.find((candidate) => candidate.assertion_ref === assertion.key);
-    if (!expectation)
-        return [];
-    const attachmentName = semanticFactAttachmentName(expectation.proof_ref);
-    if (!item.attachment_names.includes(attachmentName))
-        return [];
-    const record = semanticFactAttachment(item.attachment_payloads[attachmentName]);
-    return record &&
-        record.assertion_key === assertion.key &&
-        record.proof_ref === expectation.proof_ref
-        ? [record]
-        : [];
-}
-function semanticFactAttachment(payload) {
-    if (!payload)
-        return null;
-    try {
-        const records = decodeEvidenceCapabilityRecords([JSON.parse(payload)]);
-        const record = records[0];
-        return records.length === 1 && record.capability === "semantic_fact"
-            ? record
-            : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function semanticFactAttachmentName(proofRef) {
-    return `ty-semantic-fact:${proofRef}`;
-}
-function designFactResultAttachment(content, label) {
-    if (!content)
-        return null;
-    try {
-        const payload = JSON.parse(content);
-        if (payload.schema_version !== "design-method-fact-results-v1" ||
-            !Object.hasOwn(payload, "fact_results"))
-            return null;
-        return decodeDesignFactResults(payload.fact_results, `playwright_design_method.${label}.fact_results`);
-    }
-    catch {
-        return null;
-    }
-}
-export function designMethodAttachmentName(target, method, condition, kind) {
-    return `ty-context-design-method:${target}:${method}:${condition}:${kind}`;
-}
-export function symbolicDesignMethodAttachmentName(target, method) {
-    return `ty-context-design-symbolic-method:${target}:${method}:record`;
-}
-export function symbolicDesignCertificateAttachmentName(target) {
-    return `ty-context-design-symbolic-certificate:${target}:record`;
-}

package/dist/lib/long-task-playwright-case-evidence.d.ts

@@ -1,46 +0,0 @@
-import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
-export { record, same } from "./long-task-playwright-case-primitives.js";
-export interface PlaywrightCaseInstance {
-    id: string;
-    project_id: string;
-    executed: boolean;
-    passed: boolean;
-    skipped: boolean;
-    flaky: boolean;
-    unexpected: boolean;
-    timed_out: boolean;
-    interrupted: boolean;
-    status: string;
-    given_keys: string[];
-    action_keys: string[];
-    attachment_names: string[];
-    attachment_payloads: Record<string, string>;
-}
-export interface PlaywrightCase {
-    id: string;
-    executed: boolean;
-    passed: boolean;
-    skipped: boolean;
-    flaky: boolean;
-    unexpected: boolean;
-    status: string;
-    project_ids: string[];
-    executed_instances: number;
-    failed_instances: number;
-    skipped_instances: number;
-    flaky_instances: number;
-    unexpected_instances: number;
-    timed_out_instances: number;
-    interrupted_instances: number;
-    given_keys: string[];
-    action_keys: string[];
-    attachment_names: string[];
-    attachment_payloads: Record<string, string>;
-}
-export declare function collectCases(report: Record<string, unknown>, declaredIds: Set<string>): {
-    cases: PlaywrightCaseInstance[];
-    unbound_unexpected_instances: number;
-    error: string | null;
-};
-export declare function declaredCaseIds(check: CompiledCheckV2): Set<string>;
-export declare function duplicateCaseInstance(values: PlaywrightCaseInstance[]): PlaywrightCaseInstance | null;

package/dist/lib/long-task-playwright-case-evidence.js

@@ -1,91 +0,0 @@
-import { consistentScenarioTrace, playwrightAttachments, playwrightExecutionState, playwrightIdentity, playwrightResults, record, } from "./long-task-playwright-case-primitives.js";
-export { record, same } from "./long-task-playwright-case-primitives.js";
-export function collectCases(report, declaredIds) {
-    const cases = [];
-    const collection = { unbound_unexpected_instances: 0 };
-    const error = visitSuites(report.suites, cases, declaredIds, collection);
-    return { cases, error, ...collection };
-}
-function visitSuites(value, cases, declaredIds, collection) {
-    if (!Array.isArray(value))
-        return null;
-    for (const suiteValue of value) {
-        const suite = record(suiteValue);
-        if (!suite)
-            continue;
-        const nestedError = visitSuites(suite.suites, cases, declaredIds, collection);
-        if (nestedError)
-            return nestedError;
-        if (!Array.isArray(suite.specs))
-            continue;
-        for (const specValue of suite.specs) {
-            const spec = record(specValue);
-            if (!spec || !Array.isArray(spec.tests))
-                continue;
-            for (const testValue of spec.tests) {
-                const test = record(testValue);
-                if (!test)
-                    continue;
-                const title = [spec.title, test.title]
-                    .filter((item) => typeof item === "string")
-                    .join(" ");
-                const ids = declaredIdsInTitle(title, declaredIds);
-                if (ids.length > 1)
-                    return `playwright_test_multiple_ac_ids:${ids.join(",")}`;
-                const instance = playwrightCase(ids[0] ?? "unbound", test);
-                if (ids.length === 1)
-                    cases.push(instance);
-                else if (instance.unexpected)
-                    collection.unbound_unexpected_instances += 1;
-            }
-        }
-    }
-    return null;
-}
-function declaredIdsInTitle(title, declared) {
-    const explicit = [...title.matchAll(/\[ac:([a-z0-9][a-z0-9-]*)\]/gu)].map((match) => match[1]);
-    const legacy = [...title.matchAll(/\[([a-z0-9][a-z0-9-]*)\]/gu)].map((match) => match[1]);
-    return [
-        ...new Set([...explicit, ...legacy].filter((id) => declared.has(id))),
-    ].sort();
-}
-function playwrightCase(id, test) {
-    const { status, projectId } = playwrightIdentity(test);
-    const results = playwrightResults(test);
-    const resultStatuses = results
-        .map((result) => result.status)
-        .filter((value) => typeof value === "string");
-    const state = playwrightExecutionState(status, resultStatuses);
-    const trace = consistentScenarioTrace(results);
-    const attachments = playwrightAttachments(results);
-    return {
-        id,
-        project_id: projectId,
-        ...state,
-        status,
-        ...trace,
-        ...attachments,
-    };
-}
-export function declaredCaseIds(check) {
-    const result = new Set();
-    for (const assertion of [
-        ...check.positive_assertions,
-        ...check.negative_assertions,
-    ]) {
-        const match = /^playwright\.case\.([a-z0-9][a-z0-9-]*)\.passed$/u.exec(assertion.observation);
-        if (match)
-            result.add(assertion.key);
-    }
-    return result;
-}
-export function duplicateCaseInstance(values) {
-    const seen = new Set();
-    for (const value of values) {
-        const identity = `${value.id}\0${value.project_id}`;
-        if (seen.has(identity))
-            return value;
-        seen.add(identity);
-    }
-    return null;
-}

package/dist/lib/long-task-playwright-case-primitives.d.ts

@@ -1,28 +0,0 @@
-interface PlaywrightExecutionState {
-    executed: boolean;
-    passed: boolean;
-    skipped: boolean;
-    flaky: boolean;
-    unexpected: boolean;
-    timed_out: boolean;
-    interrupted: boolean;
-}
-interface PlaywrightAttachments {
-    attachment_names: string[];
-    attachment_payloads: Record<string, string>;
-}
-interface PlaywrightScenarioTrace {
-    given_keys: string[];
-    action_keys: string[];
-}
-export declare function playwrightIdentity(test: Record<string, unknown>): {
-    status: string;
-    projectId: string;
-};
-export declare function playwrightResults(test: Record<string, unknown>): Record<string, unknown>[];
-export declare function playwrightExecutionState(status: string, resultStatuses: string[]): PlaywrightExecutionState;
-export declare function playwrightAttachments(results: Record<string, unknown>[]): PlaywrightAttachments;
-export declare function consistentScenarioTrace(results: Record<string, unknown>[]): PlaywrightScenarioTrace;
-export declare function record(value: unknown): Record<string, unknown> | null;
-export declare function same(left: string[], right: string[]): boolean;
-export {};

package/dist/lib/long-task-playwright-case-primitives.js

@@ -1,143 +0,0 @@
-export function playwrightIdentity(test) {
-    const status = typeof test.status === "string" ? test.status : "invalid";
-    const projectId = typeof test.projectId === "string"
-        ? test.projectId
-        : typeof test.projectName === "string"
-            ? test.projectName
-            : "default";
-    return { status, projectId };
-}
-export function playwrightResults(test) {
-    if (!Array.isArray(test.results))
-        return [];
-    return test.results
-        .map(record)
-        .filter((item) => item !== null);
-}
-export function playwrightExecutionState(status, resultStatuses) {
-    const skipped = status === "skipped" ||
-        (resultStatuses.length > 0 &&
-            resultStatuses.every((value) => value === "skipped"));
-    const executed = !skipped && resultStatuses.length > 0;
-    const flaky = status === "flaky";
-    const unexpected = status === "unexpected";
-    const timedOut = resultStatuses.includes("timedOut");
-    const interrupted = resultStatuses.includes("interrupted");
-    const passed = executed &&
-        !flaky &&
-        !unexpected &&
-        status === "expected" &&
-        resultStatuses.length > 0 &&
-        resultStatuses.at(-1) === "passed";
-    return {
-        executed,
-        passed,
-        skipped,
-        flaky,
-        unexpected,
-        timed_out: timedOut,
-        interrupted,
-    };
-}
-export function playwrightAttachments(results) {
-    const attachmentNames = [
-        ...new Set(results.flatMap((result) => Array.isArray(result.attachments)
-            ? result.attachments
-                .map(record)
-                .filter((item) => item !== null)
-                .map((attachment) => attachment.name)
-                .filter((name) => typeof name === "string")
-            : [])),
-    ].sort();
-    const attachmentPayloads = {};
-    for (const result of results)
-        collectAttachmentPayloads(result.attachments, attachmentPayloads);
-    return {
-        attachment_names: attachmentNames,
-        attachment_payloads: attachmentPayloads,
-    };
-}
-function collectAttachmentPayloads(values, payloads) {
-    if (!Array.isArray(values))
-        return;
-    for (const value of values) {
-        const attachment = record(value);
-        if (!attachment || typeof attachment.name !== "string")
-            continue;
-        const body = attachmentBody(attachment.body);
-        if (body === null)
-            continue;
-        const previous = payloads[attachment.name];
-        if (previous !== undefined && previous !== body)
-            delete payloads[attachment.name];
-        else
-            payloads[attachment.name] = body;
-    }
-}
-export function consistentScenarioTrace(results) {
-    const traces = results.map((result) => scenarioTrace(result));
-    const givenKeys = traces[0]?.given_keys ?? [];
-    const actionKeys = traces[0]?.action_keys ?? [];
-    const traceConsistent = traces.every((trace) => same(trace.given_keys, givenKeys) && same(trace.action_keys, actionKeys));
-    return {
-        given_keys: traceConsistent ? givenKeys : [],
-        action_keys: traceConsistent ? actionKeys : [],
-    };
-}
-function attachmentBody(value) {
-    if (typeof value === "string")
-        return stringAttachmentBody(value);
-    const body = record(value);
-    if (body?.type === "Buffer" &&
-        Array.isArray(body.data) &&
-        body.data.every((item) => Number.isInteger(item) && Number(item) >= 0 && Number(item) <= 255))
-        return Buffer.from(body.data).toString("utf8");
-    return null;
-}
-function stringAttachmentBody(value) {
-    try {
-        const decoded = Buffer.from(value, "base64").toString("utf8");
-        if (decoded.trim().startsWith("{") || decoded.trim().startsWith("["))
-            return decoded;
-    }
-    catch {
-        // Fall through to plain text.
-    }
-    return value;
-}
-export function record(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function scenarioTrace(result) {
-    const givenKeys = [];
-    const actionKeys = [];
-    visitScenarioSteps(result.steps, givenKeys, actionKeys);
-    return { given_keys: givenKeys, action_keys: actionKeys };
-}
-function visitScenarioSteps(value, givenKeys, actionKeys) {
-    if (!Array.isArray(value))
-        return;
-    for (const item of value) {
-        const step = record(item);
-        if (!step)
-            continue;
-        appendScenarioStep(step.title, givenKeys, actionKeys);
-        visitScenarioSteps(step.steps, givenKeys, actionKeys);
-    }
-}
-function appendScenarioStep(title, givenKeys, actionKeys) {
-    if (typeof title !== "string")
-        return;
-    const given = /^\[given:([a-z0-9][a-z0-9-]*)\]$/u.exec(title);
-    const action = /^\[action:([a-z0-9][a-z0-9-]*)\]$/u.exec(title);
-    if (given)
-        givenKeys.push(given[1]);
-    if (action)
-        actionKeys.push(action[1]);
-}
-export function same(left, right) {
-    return (left.length === right.length &&
-        left.every((value, index) => value === right[index]));
-}

package/dist/lib/long-task-playwright-counterfactual-policy.d.ts

@@ -1,7 +0,0 @@
-import type { CheckExecutionResultV2, CounterfactualControlV2, GlobalCounterfactualControlV2, RawCommandExecutionV2 } from "./long-task-delivery-types.js";
-export interface PlaywrightCounterfactualClassification {
-    accepted_test_failure_exit: boolean;
-    normalized_result: CheckExecutionResultV2;
-    rejection_reasons: string[];
-}
-export declare function classifyPlaywrightCounterfactual(raw: RawCommandExecutionV2, result: CheckExecutionResultV2, control: CounterfactualControlV2 | GlobalCounterfactualControlV2): PlaywrightCounterfactualClassification;

package/dist/lib/long-task-playwright-counterfactual-policy.js

@@ -1,125 +0,0 @@
-export function classifyPlaywrightCounterfactual(raw, result, control) {
-    const reasons = [];
-    const expected = [...new Set(control.expected_assertion_failures)].sort();
-    if (expected.length !== control.expected_assertion_failures.length)
-        reasons.push("expected_assertion_failures_duplicate");
-    if (result.evidence_adapter !== "playwright_json_v1")
-        reasons.push("evidence_adapter_not_playwright_json_v1");
-    if (raw.execution_status !== "completed")
-        reasons.push(`execution_status_${raw.execution_status}`);
-    if (raw.exit_code === 0)
-        reasons.push("exit_code_zero_with_test_failure");
-    else if (raw.exit_code !== 1)
-        reasons.push(`exit_code_not_expected_test_failure:${raw.exit_code}`);
-    const reportErrorCount = count(raw.observations, "playwright.report_error_count", reasons);
-    const declaredUnexpectedInstances = count(raw.observations, "playwright.declared_unexpected_instances", reasons);
-    const unboundUnexpectedInstances = count(raw.observations, "playwright.unbound_unexpected_instances", reasons);
-    const reportUnexpectedInstances = count(raw.observations, "playwright.unexpected", reasons);
-    if (reportErrorCount !== null && reportErrorCount !== 0)
-        reasons.push(`playwright_report_errors:${reportErrorCount}`);
-    if (unboundUnexpectedInstances !== null && unboundUnexpectedInstances !== 0)
-        reasons.push(`playwright_unbound_unexpected_instances:${unboundUnexpectedInstances}`);
-    const expectedCaseIds = new Set();
-    let expectedUnexpectedInstances = 0;
-    for (const assertionKey of expected) {
-        const assertion = result.assertion_results.find((item) => item.key === assertionKey);
-        if (!assertion) {
-            reasons.push(`expected_assertion_missing:${assertionKey}`);
-            continue;
-        }
-        const caseId = playwrightCaseId(assertion.observation);
-        if (!caseId) {
-            reasons.push(`expected_assertion_not_playwright_ac:${assertionKey}`);
-            continue;
-        }
-        if (expectedCaseIds.has(caseId))
-            reasons.push(`expected_playwright_ac_duplicate:${caseId}`);
-        expectedCaseIds.add(caseId);
-        const prefix = `playwright.case.${caseId}`;
-        if (boolean(raw.observations, `${prefix}.executed`) !== true)
-            reasons.push(`expected_playwright_ac_not_executed:${caseId}`);
-        if (boolean(raw.observations, `${prefix}.unexpected`) !== true)
-            reasons.push(`expected_playwright_ac_not_unexpected:${caseId}`);
-        if (boolean(raw.observations, `${prefix}.skipped`) !== false)
-            reasons.push(`expected_playwright_ac_skipped:${caseId}`);
-        if (boolean(raw.observations, `${prefix}.flaky`) !== false)
-            reasons.push(`expected_playwright_ac_flaky:${caseId}`);
-        const unexpectedInstances = count(raw.observations, `${prefix}.unexpected_instances`, reasons);
-        const timedOutInstances = count(raw.observations, `${prefix}.timed_out_instances`, reasons);
-        const interruptedInstances = count(raw.observations, `${prefix}.interrupted_instances`, reasons);
-        if (unexpectedInstances !== null) {
-            expectedUnexpectedInstances += unexpectedInstances;
-            if (unexpectedInstances === 0)
-                reasons.push(`expected_playwright_ac_has_no_unexpected_instance:${caseId}`);
-        }
-        if (timedOutInstances !== null && timedOutInstances !== 0)
-            reasons.push(`expected_playwright_ac_timed_out:${caseId}`);
-        if (interruptedInstances !== null && interruptedInstances !== 0)
-            reasons.push(`expected_playwright_ac_interrupted:${caseId}`);
-        if (assertion.passed || assertion.status !== "assertion_value_mismatch")
-            reasons.push(`expected_assertion_not_value_mismatch:${assertionKey}`);
-    }
-    for (const assertion of result.assertion_results)
-        if (!expected.includes(assertion.key) && !assertion.passed)
-            reasons.push(`unspecified_assertion_failed:${assertion.key}`);
-    if (declaredUnexpectedInstances !== null &&
-        declaredUnexpectedInstances !== expectedUnexpectedInstances)
-        reasons.push(`declared_unexpected_instance_mismatch:${declaredUnexpectedInstances}:${expectedUnexpectedInstances}`);
-    if (reportUnexpectedInstances !== null &&
-        reportUnexpectedInstances !== expectedUnexpectedInstances)
-        reasons.push(`report_unexpected_instance_mismatch:${reportUnexpectedInstances}:${expectedUnexpectedInstances}`);
-    const genericTestFailures = result.findings.filter((finding) => finding.code === "test_failed" && !finding.assertion_key);
-    if (genericTestFailures.length !== 1)
-        reasons.push(`generic_test_failure_count_unexpected:${genericTestFailures.length}`);
-    for (const finding of result.findings) {
-        const expectedAcceptanceFailure = finding.code === "acceptance_case_unexpected" &&
-            Boolean(finding.assertion_key) &&
-            expected.includes(finding.assertion_key);
-        const genericTestFailure = finding.code === "test_failed" && !finding.assertion_key;
-        if (!expectedAcceptanceFailure && !genericTestFailure)
-            reasons.push(`unexplained_finding:${finding.code}:${finding.assertion_key ?? "none"}`);
-    }
-    for (const assertionKey of expected)
-        if (!result.findings.some((finding) => finding.code === "acceptance_case_unexpected" &&
-            finding.assertion_key === assertionKey))
-            reasons.push(`expected_acceptance_failure_missing:${assertionKey}`);
-    const rejectionReasons = [...new Set(reasons)].sort();
-    if (rejectionReasons.length)
-        return {
-            accepted_test_failure_exit: false,
-            normalized_result: result,
-            rejection_reasons: rejectionReasons,
-        };
-    return {
-        accepted_test_failure_exit: true,
-        normalized_result: {
-            ...result,
-            status: "assertion_failed",
-            claim_proofs: [],
-            findings: result.findings
-                .filter((finding) => !(finding.code === "test_failed" && !finding.assertion_key))
-                .map((finding) => finding.code === "acceptance_case_unexpected" &&
-                finding.assertion_key &&
-                expected.includes(finding.assertion_key)
-                ? { ...finding, code: "assertion_value_mismatch" }
-                : finding),
-        },
-        rejection_reasons: [],
-    };
-}
-function playwrightCaseId(observation) {
-    return (/^playwright\.case\.([a-z0-9][a-z0-9-]*)\.passed$/u.exec(observation)?.[1] ?? null);
-}
-function count(observations, key, reasons) {
-    const value = observations[key];
-    if (!Number.isInteger(value) || Number(value) < 0) {
-        reasons.push(`playwright_diagnostic_count_invalid:${key}`);
-        return null;
-    }
-    return Number(value);
-}
-function boolean(observations, key) {
-    return typeof observations[key] === "boolean"
-        ? observations[key]
-        : null;
-}

package/dist/lib/long-task-playwright-evidence.d.ts

@@ -1,8 +0,0 @@
-import type { CompiledCheckV2, EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
-export { designMethodAttachmentName, semanticFactAttachmentName, } from "./long-task-playwright-capability-records.js";
-export interface PlaywrightEvidence {
-    observations: Record<string, unknown>;
-    evidence_records: EvidenceCapabilityRecordV2[];
-    error: string | null;
-}
-export declare function extractPlaywrightEvidence(check: CompiledCheckV2, report: Record<string, unknown>, exitCode: number): PlaywrightEvidence;