project-tiny-context-harness 0.11.0 → 0.12.0

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;

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

@@ -1,147 +0,0 @@
-import { collectCases, declaredCaseIds, duplicateCaseInstance, record, same, } from "./long-task-playwright-case-evidence.js";
-import { evidenceRecordsForPlaywrightCases } from "./long-task-playwright-capability-records.js";
-export { designMethodAttachmentName, semanticFactAttachmentName, } from "./long-task-playwright-capability-records.js";
-export function extractPlaywrightEvidence(check, report, exitCode) {
-    const stats = record(report.stats);
-    if (!stats)
-        return invalid("playwright_report_invalid:stats");
-    const expected = integer(stats.expected);
-    const unexpected = integer(stats.unexpected);
-    const skipped = integer(stats.skipped);
-    const flaky = integer(stats.flaky);
-    if ([expected, unexpected, skipped, flaky].some((value) => value === null))
-        return invalid("playwright_report_invalid:counts");
-    const total = expected + unexpected + skipped + flaky;
-    const reportErrors = report.errors;
-    if (reportErrors !== undefined && !Array.isArray(reportErrors))
-        return invalid("playwright_report_invalid:errors");
-    const observations = {
-        "playwright.passed": exitCode === 0,
-        "playwright.expected": expected,
-        "playwright.unexpected": unexpected,
-        "playwright.skipped": skipped,
-        "playwright.flaky": flaky,
-        "playwright.total": total,
-        "playwright.zero_or_all_skipped": total === 0 || skipped === total,
-        "playwright.report_error_count": Array.isArray(reportErrors)
-            ? reportErrors.length
-            : 0,
-    };
-    const collected = collectCases(report, declaredCaseIds(check));
-    if (collected.error)
-        return invalid(collected.error);
-    const instances = collected.cases;
-    observations["playwright.declared_unexpected_instances"] = instances.filter((item) => item.unexpected).length;
-    observations["playwright.unbound_unexpected_instances"] =
-        collected.unbound_unexpected_instances;
-    const duplicate = duplicateCaseInstance(instances);
-    if (duplicate)
-        return invalid(`playwright_ac_id_duplicate:${duplicate.id}:${duplicate.project_id}`);
-    const cases = aggregateCases(instances);
-    for (const item of cases) {
-        const prefix = `playwright.case.${item.id}`;
-        observations[`${prefix}.executed`] = item.executed;
-        observations[`${prefix}.passed`] = item.passed;
-        observations[`${prefix}.skipped`] = item.skipped;
-        observations[`${prefix}.flaky`] = item.flaky;
-        observations[`${prefix}.unexpected`] = item.unexpected;
-        observations[`${prefix}.status`] = item.status;
-        observations[`${prefix}.project_ids`] = item.project_ids;
-        observations[`${prefix}.executed_instances`] = item.executed_instances;
-        observations[`${prefix}.failed_instances`] = item.failed_instances;
-        observations[`${prefix}.skipped_instances`] = item.skipped_instances;
-        observations[`${prefix}.flaky_instances`] = item.flaky_instances;
-        observations[`${prefix}.unexpected_instances`] = item.unexpected_instances;
-        observations[`${prefix}.timed_out_instances`] = item.timed_out_instances;
-        observations[`${prefix}.interrupted_instances`] =
-            item.interrupted_instances;
-    }
-    for (const id of declaredCaseIds(check)) {
-        const prefix = `playwright.case.${id}`;
-        if (!Object.hasOwn(observations, `${prefix}.status`)) {
-            observations[`${prefix}.executed`] = false;
-            observations[`${prefix}.status`] = "missing";
-        }
-    }
-    observations["playwright.case_ids"] = cases.map((item) => item.id).sort();
-    return {
-        observations,
-        evidence_records: evidenceRecordsForPlaywrightCases(check, cases),
-        error: null,
-    };
-}
-function aggregateCases(instances) {
-    const grouped = new Map();
-    for (const instance of instances) {
-        const rows = grouped.get(instance.id) ?? [];
-        rows.push(instance);
-        grouped.set(instance.id, rows);
-    }
-    return [...grouped.entries()]
-        .map(([id, rows]) => {
-        const executedInstances = rows.filter((item) => item.executed).length;
-        const skippedInstances = rows.filter((item) => item.skipped).length;
-        const flakyInstances = rows.filter((item) => item.flaky).length;
-        const unexpectedInstances = rows.filter((item) => item.unexpected).length;
-        const timedOutInstances = rows.filter((item) => item.timed_out).length;
-        const interruptedInstances = rows.filter((item) => item.interrupted).length;
-        const failedInstances = rows.filter((item) => !item.passed && !item.skipped).length;
-        const executed = rows.length > 0 && rows.every((item) => item.executed);
-        const passed = executed &&
-            skippedInstances === 0 &&
-            flakyInstances === 0 &&
-            unexpectedInstances === 0 &&
-            rows.every((item) => item.passed);
-        const status = passed
-            ? "passed"
-            : skippedInstances
-                ? "skipped"
-                : flakyInstances
-                    ? "flaky"
-                    : timedOutInstances
-                        ? "timed_out"
-                        : interruptedInstances
-                            ? "interrupted"
-                            : unexpectedInstances
-                                ? "unexpected"
-                                : "failed";
-        return {
-            id,
-            executed,
-            passed,
-            skipped: skippedInstances > 0,
-            flaky: flakyInstances > 0,
-            unexpected: unexpectedInstances > 0,
-            status,
-            project_ids: rows.map((item) => item.project_id).sort(),
-            executed_instances: executedInstances,
-            failed_instances: failedInstances,
-            skipped_instances: skippedInstances,
-            flaky_instances: flakyInstances,
-            unexpected_instances: unexpectedInstances,
-            timed_out_instances: timedOutInstances,
-            interrupted_instances: interruptedInstances,
-            given_keys: rows.length &&
-                rows.every((row) => same(row.given_keys, rows[0].given_keys))
-                ? rows[0].given_keys
-                : [],
-            action_keys: rows.length &&
-                rows.every((row) => same(row.action_keys, rows[0].action_keys))
-                ? rows[0].action_keys
-                : [],
-            attachment_names: rows.length === 0
-                ? []
-                : rows[0].attachment_names.filter((name) => rows.every((row) => row.attachment_names.includes(name))),
-            attachment_payloads: rows.length === 0
-                ? {}
-                : Object.fromEntries(Object.entries(rows[0].attachment_payloads).filter(([name, value]) => rows.every((row) => row.attachment_payloads[name] === value))),
-        };
-    })
-        .sort((left, right) => left.id.localeCompare(right.id));
-}
-function integer(value) {
-    return Number.isInteger(value) && Number(value) >= 0 ? Number(value) : null;
-}
-function invalid(error) {
-    return { observations: {}, evidence_records: [], error };
-}

package/dist/lib/long-task-process-observation.d.ts

@@ -1,6 +0,0 @@
-import type { CompiledObservationAuthorityV2, PackageProcessObservationV1 } from "./long-task-runtime-types.js";
-export declare const PRODUCT_OBSERVATION_SCHEMA_VERSION: "ty-context-product-observation-v1";
-export declare function decodeProductObservationEnvelope(input: {
-    bytes: Uint8Array;
-    authorities: readonly CompiledObservationAuthorityV2[];
-}): PackageProcessObservationV1;