project-tiny-context-harness 0.11.0 → 0.12.1

package/dist/lib/long-task-paths.d.ts

@@ -1,48 +0,0 @@
-export type PatternContainment = {
-    status: "proven_subset";
-    reason: string;
-} | {
-    status: "not_subset";
-    reason: string;
-} | {
-    status: "unknown";
-    reason: string;
-};
-export type PatternOverlap = {
-    status: "proven_overlap";
-    reason: string;
-} | {
-    status: "proven_disjoint";
-    reason: string;
-} | {
-    status: "unknown";
-    reason: string;
-};
-export interface RepositoryPatternAst {
-    normalized: string;
-    segments: RepositoryPatternSegmentAst[];
-}
-export type RepositoryPatternSegmentAst = {
-    kind: "recursive";
-    raw: "**";
-} | {
-    kind: "segment";
-    raw: string;
-    tokens: RepositoryPatternTokenAst[];
-};
-export type RepositoryPatternTokenAst = {
-    kind: "literal";
-    value: string;
-} | {
-    kind: "star";
-} | {
-    kind: "question";
-};
-export declare function parseRepositoryPattern(value: string, label?: string): RepositoryPatternAst;
-export declare function normalizeRepositoryFile(value: string, label?: string): string;
-export declare function normalizeRepositoryCwd(value: string, label?: string): string;
-export declare function assertRepositoryPattern(repositoryRoot: string, value: string, label: string): string;
-export declare function matchesRepoPattern(fileInput: string, patternInput: string): boolean;
-export declare function proveRepositoryPatternSubset(candidateInput: string, ownerInput: string): PatternContainment;
-export declare function classifyRepositoryPatternOverlap(leftInput: string, rightInput: string): PatternOverlap;
-export declare function repositoryPatternsMayOverlap(left: string, right: string): boolean;

package/dist/lib/long-task-paths.js

@@ -1,414 +0,0 @@
-import path from "node:path";
-import { resolveInsideRepository } from "./long-task-workspace.js";
-export function parseRepositoryPattern(value, label = "repository_pattern") {
-    const normalized = canonicalRepositoryPath(value, label, "pattern");
-    if (/[\[\]{}]/u.test(normalized))
-        throw new Error(`unsupported_repository_pattern_syntax:${label}:${value}`);
-    const segments = normalized.split("/").map((segment) => {
-        if (segment === "**")
-            return { kind: "recursive", raw: "**" };
-        if (segment.includes("**"))
-            throw new Error(`unsupported_repository_pattern_syntax:${label}:${value}`);
-        const tokens = [];
-        let literal = "";
-        const flush = () => {
-            if (!literal)
-                return;
-            tokens.push({ kind: "literal", value: literal });
-            literal = "";
-        };
-        for (const character of segment) {
-            if (character === "*") {
-                flush();
-                tokens.push({ kind: "star" });
-            }
-            else if (character === "?") {
-                flush();
-                tokens.push({ kind: "question" });
-            }
-            else
-                literal += character;
-        }
-        flush();
-        return { kind: "segment", raw: segment, tokens };
-    });
-    return { normalized, segments };
-}
-export function normalizeRepositoryFile(value, label = "repository_file") {
-    return canonicalRepositoryPath(value, label, "file");
-}
-export function normalizeRepositoryCwd(value, label = "runner.cwd") {
-    return canonicalRepositoryPath(value, label, "cwd");
-}
-export function assertRepositoryPattern(repositoryRoot, value, label) {
-    const pattern = parseRepositoryPattern(value, label);
-    const prefix = [];
-    for (const segment of pattern.segments) {
-        if (segment.kind === "recursive" ||
-            segment.tokens.some((token) => token.kind !== "literal"))
-            break;
-        prefix.push(segment.raw);
-    }
-    if (prefix.length)
-        resolveInsideRepository(repositoryRoot, prefix.join("/"), label);
-    return pattern.normalized;
-}
-export function matchesRepoPattern(fileInput, patternInput) {
-    const file = normalizeRepositoryFile(fileInput);
-    const pattern = parseRepositoryPattern(patternInput);
-    const fileSegments = file.split("/");
-    const memo = new Map();
-    const match = (patternIndex, fileIndex) => {
-        const key = `${patternIndex}:${fileIndex}`;
-        const cached = memo.get(key);
-        if (cached !== undefined)
-            return cached;
-        const segment = pattern.segments[patternIndex];
-        let result;
-        if (!segment)
-            result = fileIndex === fileSegments.length;
-        else if (segment.kind === "recursive")
-            result =
-                match(patternIndex + 1, fileIndex) ||
-                    (fileIndex < fileSegments.length && match(patternIndex, fileIndex + 1));
-        else
-            result =
-                fileIndex < fileSegments.length &&
-                    segmentMatches(fileSegments[fileIndex], segment) &&
-                    match(patternIndex + 1, fileIndex + 1);
-        memo.set(key, result);
-        return result;
-    };
-    return match(0, 0);
-}
-export function proveRepositoryPatternSubset(candidateInput, ownerInput) {
-    const candidate = parseRepositoryPattern(candidateInput, "candidate");
-    const owner = parseRepositoryPattern(ownerInput, "owner");
-    if (candidate.normalized === owner.normalized)
-        return { status: "proven_subset", reason: "patterns_are_equal" };
-    if (isGlobalRecursive(owner))
-        return {
-            status: "proven_subset",
-            reason: "owner_is_global_recursive_pattern",
-        };
-    if (isExactPattern(candidate))
-        return matchesAst(candidate.normalized, owner)
-            ? {
-                status: "proven_subset",
-                reason: "exact_candidate_matches_owner_pattern",
-            }
-            : {
-                status: "not_subset",
-                reason: "exact_candidate_does_not_match_owner_pattern",
-            };
-    const ownerRecursiveTail = recursiveTailPrefix(owner);
-    if (ownerRecursiveTail) {
-        const candidatePrefix = requiredLeadingSegments(candidate);
-        if (candidatePrefix.length < ownerRecursiveTail.length)
-            return {
-                status: "unknown",
-                reason: "candidate_may_match_before_owner_recursive_prefix",
-            };
-        for (let index = 0; index < ownerRecursiveTail.length; index += 1) {
-            const relation = segmentSubset(candidatePrefix[index], ownerRecursiveTail[index]);
-            if (relation.status === "not_subset")
-                return {
-                    status: "not_subset",
-                    reason: "candidate_prefix_is_not_within_owner_recursive_prefix",
-                };
-            if (relation.status === "unknown")
-                return {
-                    status: "unknown",
-                    reason: "candidate_prefix_containment_is_unknown",
-                };
-        }
-        return {
-            status: "proven_subset",
-            reason: "candidate_is_within_owner_recursive_subtree",
-        };
-    }
-    const candidateRecursive = candidate.segments.some((segment) => segment.kind === "recursive");
-    const ownerRecursive = owner.segments.some((segment) => segment.kind === "recursive");
-    if (candidateRecursive && !ownerRecursive)
-        return owner.segments.some((segment) => segment.kind === "segment" &&
-            segment.tokens.some((token) => token.kind === "question"))
-            ? {
-                status: "unknown",
-                reason: "recursive_candidate_vs_question_owner_not_proven",
-            }
-            : {
-                status: "not_subset",
-                reason: "recursive_candidate_exceeds_non_recursive_owner",
-            };
-    if (candidateRecursive || ownerRecursive)
-        return {
-            status: "unknown",
-            reason: "recursive_pattern_relation_not_proven",
-        };
-    if (candidate.segments.length !== owner.segments.length)
-        return {
-            status: "not_subset",
-            reason: "candidate_and_owner_match_different_path_depths",
-        };
-    let unknown = false;
-    for (let index = 0; index < owner.segments.length; index += 1) {
-        const relation = segmentSubset(candidate.segments[index], owner.segments[index]);
-        if (relation.status === "not_subset")
-            return {
-                status: "not_subset",
-                reason: "candidate_segment_language_exceeds_owner_segment",
-            };
-        if (relation.status === "unknown")
-            unknown = true;
-    }
-    return unknown
-        ? {
-            status: "unknown",
-            reason: "segment_language_containment_not_proven",
-        }
-        : {
-            status: "proven_subset",
-            reason: "segment_languages_are_contained",
-        };
-}
-export function classifyRepositoryPatternOverlap(leftInput, rightInput) {
-    const left = parseRepositoryPattern(leftInput, "left");
-    const right = parseRepositoryPattern(rightInput, "right");
-    const queue = [
-        { left: 0, right: 0, unknown: false },
-    ];
-    const visited = new Set();
-    let unknownAcceptance = false;
-    while (queue.length) {
-        const state = queue.shift();
-        const key = `${state.left}:${state.right}:${state.unknown ? 1 : 0}`;
-        if (visited.has(key))
-            continue;
-        visited.add(key);
-        if (state.left === left.segments.length &&
-            state.right === right.segments.length) {
-            if (!state.unknown)
-                return {
-                    status: "proven_overlap",
-                    reason: "pattern_languages_have_a_proven_common_path",
-                };
-            unknownAcceptance = true;
-            continue;
-        }
-        const leftSegment = left.segments[state.left];
-        const rightSegment = right.segments[state.right];
-        if (leftSegment?.kind === "recursive")
-            queue.push({
-                left: state.left + 1,
-                right: state.right,
-                unknown: state.unknown,
-            });
-        if (rightSegment?.kind === "recursive")
-            queue.push({
-                left: state.left,
-                right: state.right + 1,
-                unknown: state.unknown,
-            });
-        if (!leftSegment || !rightSegment)
-            continue;
-        if (leftSegment.kind === "recursive" && rightSegment.kind === "recursive")
-            continue;
-        if (leftSegment.kind === "recursive") {
-            queue.push({
-                left: state.left,
-                right: state.right + 1,
-                unknown: state.unknown,
-            });
-            continue;
-        }
-        if (rightSegment.kind === "recursive") {
-            queue.push({
-                left: state.left + 1,
-                right: state.right,
-                unknown: state.unknown,
-            });
-            continue;
-        }
-        const overlap = segmentOverlap(leftSegment, rightSegment);
-        if (overlap.status !== "proven_disjoint")
-            queue.push({
-                left: state.left + 1,
-                right: state.right + 1,
-                unknown: state.unknown || overlap.status === "unknown",
-            });
-    }
-    return unknownAcceptance
-        ? {
-            status: "unknown",
-            reason: "pattern_overlap_depends_on_unproven_segment_relation",
-        }
-        : {
-            status: "proven_disjoint",
-            reason: "pattern_languages_have_no_common_path",
-        };
-}
-export function repositoryPatternsMayOverlap(left, right) {
-    return (classifyRepositoryPatternOverlap(left, right).status !== "proven_disjoint");
-}
-function segmentSubset(candidate, owner) {
-    if (candidate.raw === owner.raw)
-        return { status: "proven_subset" };
-    if (isUniversalSegment(owner))
-        return { status: "proven_subset" };
-    if (isLiteralSegment(candidate))
-        return segmentMatches(candidate.raw, owner)
-            ? { status: "proven_subset" }
-            : { status: "not_subset" };
-    if (isLiteralSegment(owner) || isUniversalSegment(candidate))
-        return { status: "not_subset" };
-    const candidateSuffix = simpleSuffix(candidate);
-    const ownerSuffix = simpleSuffix(owner);
-    if (candidateSuffix !== null && ownerSuffix !== null)
-        return candidateSuffix.endsWith(ownerSuffix)
-            ? { status: "proven_subset" }
-            : { status: "not_subset" };
-    return { status: "unknown" };
-}
-function segmentOverlap(left, right) {
-    if (left.raw === right.raw)
-        return { status: "proven_overlap", reason: "segments_are_equal" };
-    if (isLiteralSegment(left))
-        return segmentMatches(left.raw, right)
-            ? { status: "proven_overlap", reason: "left_literal_matches_right" }
-            : { status: "proven_disjoint", reason: "left_literal_rejected" };
-    if (isLiteralSegment(right))
-        return segmentMatches(right.raw, left)
-            ? { status: "proven_overlap", reason: "right_literal_matches_left" }
-            : { status: "proven_disjoint", reason: "right_literal_rejected" };
-    if (isUniversalSegment(left) || isUniversalSegment(right))
-        return {
-            status: "proven_overlap",
-            reason: "universal_segment_has_nonempty_intersection",
-        };
-    const leftSuffix = simpleSuffix(left);
-    const rightSuffix = simpleSuffix(right);
-    if (leftSuffix !== null && rightSuffix !== null)
-        return leftSuffix.endsWith(rightSuffix) || rightSuffix.endsWith(leftSuffix)
-            ? {
-                status: "proven_overlap",
-                reason: "suffix_languages_have_a_common_value",
-            }
-            : {
-                status: "proven_disjoint",
-                reason: "suffix_languages_are_disjoint",
-            };
-    const leftFixed = fixedWidthTokens(left);
-    const rightFixed = fixedWidthTokens(right);
-    if (leftFixed && rightFixed) {
-        if (leftFixed.length !== rightFixed.length)
-            return {
-                status: "proven_disjoint",
-                reason: "fixed_width_segments_have_different_lengths",
-            };
-        for (let index = 0; index < leftFixed.length; index += 1)
-            if (leftFixed[index] !== null &&
-                rightFixed[index] !== null &&
-                leftFixed[index] !== rightFixed[index])
-                return {
-                    status: "proven_disjoint",
-                    reason: "fixed_width_literal_positions_conflict",
-                };
-        return {
-            status: "proven_overlap",
-            reason: "fixed_width_segments_have_a_common_value",
-        };
-    }
-    return {
-        status: "unknown",
-        reason: "segment_overlap_not_proven",
-    };
-}
-function matchesAst(file, pattern) {
-    return matchesRepoPattern(file, pattern.normalized);
-}
-function segmentMatches(fileSegment, pattern) {
-    return segmentExpression(pattern).test(fileSegment);
-}
-function segmentExpression(pattern) {
-    const expression = pattern.tokens
-        .map((token) => {
-        if (token.kind === "star")
-            return ".*";
-        if (token.kind === "question")
-            return ".";
-        return escapeRegex(token.value);
-    })
-        .join("");
-    return new RegExp(`^${expression}$`, "u");
-}
-function isExactPattern(pattern) {
-    return pattern.segments.every((segment) => segment.kind === "segment" && isLiteralSegment(segment));
-}
-function isGlobalRecursive(pattern) {
-    return (pattern.segments.length === 1 && pattern.segments[0].kind === "recursive");
-}
-function recursiveTailPrefix(pattern) {
-    if (pattern.segments.at(-1)?.kind !== "recursive" ||
-        pattern.segments
-            .slice(0, -1)
-            .some((segment) => segment.kind === "recursive"))
-        return null;
-    return pattern.segments.slice(0, -1);
-}
-function requiredLeadingSegments(pattern) {
-    const result = [];
-    for (const segment of pattern.segments) {
-        if (segment.kind === "recursive")
-            break;
-        result.push(segment);
-    }
-    return result;
-}
-function isLiteralSegment(segment) {
-    return segment.tokens.every((token) => token.kind === "literal");
-}
-function isUniversalSegment(segment) {
-    return segment.tokens.length === 1 && segment.tokens[0].kind === "star";
-}
-function simpleSuffix(segment) {
-    if (segment.tokens.length !== 2 ||
-        segment.tokens[0].kind !== "star" ||
-        segment.tokens[1].kind !== "literal")
-        return null;
-    return segment.tokens[1].value;
-}
-function fixedWidthTokens(segment) {
-    if (segment.tokens.some((token) => token.kind === "star"))
-        return null;
-    return segment.tokens.flatMap((token) => token.kind === "question"
-        ? [null]
-        : token.kind === "literal"
-            ? [...token.value].map((character) => character)
-            : []);
-}
-function canonicalRepositoryPath(value, label, kind) {
-    if (/[\0\r\n\t]/u.test(value))
-        throw new Error(`unsafe_path:${label}:control_character`);
-    const slashed = value.replace(/\\/gu, "/");
-    if (kind === "cwd" && slashed === ".")
-        return ".";
-    const normalized = slashed.startsWith("./") ? slashed.slice(2) : slashed;
-    if (!normalized ||
-        path.posix.isAbsolute(normalized) ||
-        normalized.startsWith("//") ||
-        /^[A-Za-z]:/u.test(normalized))
-        throw new Error(`unsafe_path:${label}:${value}`);
-    const segments = normalized.split("/");
-    if (segments.some((segment) => !segment))
-        throw new Error(`unsafe_path:${label}:${value}`);
-    if (segments.includes("."))
-        throw new Error(`non_canonical_repository_path_dot_segment:${label}:${value}`);
-    if (segments.includes(".."))
-        throw new Error(`unsafe_path:${label}:${value}`);
-    if (kind !== "pattern" && /[*?\[\]{}]/u.test(normalized))
-        throw new Error(`unsupported_repository_path_syntax:${label}:${value}`);
-    return normalized;
-}
-function escapeRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}

package/dist/lib/long-task-playwright-capability-records.d.ts

@@ -1,7 +0,0 @@
-import type { CompiledCheckV2, EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
-import type { PlaywrightCase } from "./long-task-playwright-case-evidence.js";
-export declare function evidenceRecordsForPlaywrightCases(check: CompiledCheckV2, cases: PlaywrightCase[]): EvidenceCapabilityRecordV2[];
-export declare function semanticFactAttachmentName(proofRef: string): string;
-export declare function designMethodAttachmentName(target: string, method: string, condition: string, kind: "record" | "observation"): string;
-export declare function symbolicDesignMethodAttachmentName(target: string, method: string): string;
-export declare function symbolicDesignCertificateAttachmentName(target: string): string;

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`;
-}