project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-outcome-parser.js

@@ -1,143 +0,0 @@
-import { parseCheck } from "./long-task-check-shape.js";
-import { normalizeRepositoryFile } from "./long-task-paths.js";
-import { parseRequirements } from "./long-task-requirement-shape.js";
-import { array, boolean, key, literal, nullable, object, parseBindings, parseControls, parseCounterfactuals, parseApplicableKeyedStatements, parseClaimApplicability, parseControlRelationClosure, parseControlRelations, parseObligations, parseOwner, parsePopulation, parseRollback, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
-import { parseStrictYaml } from "./strict-codec.js";
-import { assertNoSemanticDriftMigration, semanticDriftOutcomeMigrationFields, } from "./long-task-semantic-drift-migration.js";
-import { parseSurfaceBindings } from "./long-task-ui-surface-shape.js";
-import { parseSemanticFactOutcomeBindings } from "./long-task-semantic-fact-shape.js";
-export function parseOutcome(value, label) {
-    assertNoSemanticDriftMigration(semanticDriftOutcomeMigrationFields(value, label));
-    const row = object(value, label, [
-        "key",
-        "title",
-        "stage",
-        "applicability",
-        "semantic_fact_bindings",
-        "product",
-        "technical",
-        "acceptance",
-    ], ["depends_on"]);
-    const product = object(row.product, `${label}.product`, [
-        "observable_result",
-        "result_applicability_refs",
-        "success_path_required",
-        "degradation_path_required",
-        "owner",
-        "control_relation_closure",
-    ], [
-        "requirements",
-        "owner_surfaces",
-        "controls",
-        "control_relations",
-        "surface_bindings",
-        "non_completing_outcomes",
-    ]);
-    const technical = object(row.technical, `${label}.technical`, ["expected_change_paths"], [
-        "obligations",
-        "allowed_support_paths",
-        "forbidden_paths",
-        "forbidden_shortcuts",
-        "bindings",
-        "rollback_and_recovery",
-    ]);
-    const acceptance = object(row.acceptance, `${label}.acceptance`, ["checks"], ["population", "counterfactual_controls"]);
-    return {
-        key: key(row.key, `${label}.key`),
-        title: string(row.title, `${label}.title`),
-        stage: key(row.stage, `${label}.stage`),
-        depends_on: Object.hasOwn(row, "depends_on")
-            ? strings(row.depends_on, `${label}.depends_on`).map((item, index) => key(item, `${label}.depends_on[${index}]`))
-            : [],
-        applicability: parseClaimApplicability(row.applicability, `${label}.applicability`),
-        semantic_fact_bindings: parseSemanticFactOutcomeBindings(row.semantic_fact_bindings, `${label}.semantic_fact_bindings`),
-        product: {
-            observable_result: string(product.observable_result, `${label}.product.observable_result`),
-            result_applicability_refs: strings(product.result_applicability_refs, `${label}.product.result_applicability_refs`).map((item, index) => key(item, `${label}.product.result_applicability_refs[${index}]`)),
-            success_path_required: boolean(product.success_path_required, `${label}.product.success_path_required`),
-            degradation_path_required: boolean(product.degradation_path_required, `${label}.product.degradation_path_required`),
-            owner: parseOwner(product.owner, `${label}.product.owner`),
-            requirements: Object.hasOwn(product, "requirements")
-                ? parseRequirements(product.requirements, `${label}.product.requirements`)
-                : [],
-            owner_surfaces: Object.hasOwn(product, "owner_surfaces")
-                ? strings(product.owner_surfaces, `${label}.product.owner_surfaces`)
-                : [],
-            controls: Object.hasOwn(product, "controls")
-                ? parseControls(product.controls, `${label}.product.controls`)
-                : [],
-            control_relation_closure: parseControlRelationClosure(product.control_relation_closure, `${label}.product.control_relation_closure`),
-            control_relations: Object.hasOwn(product, "control_relations")
-                ? parseControlRelations(product.control_relations, `${label}.product.control_relations`)
-                : [],
-            surface_bindings: Object.hasOwn(product, "surface_bindings")
-                ? parseSurfaceBindings(product.surface_bindings, `${label}.product.surface_bindings`)
-                : [],
-            non_completing_outcomes: Object.hasOwn(product, "non_completing_outcomes")
-                ? parseApplicableKeyedStatements(product.non_completing_outcomes, `${label}.product.non_completing_outcomes`)
-                : [],
-        },
-        technical: {
-            obligations: Object.hasOwn(technical, "obligations")
-                ? parseObligations(technical.obligations, `${label}.technical.obligations`)
-                : [],
-            expected_change_paths: repositoryPatterns(technical.expected_change_paths, `${label}.technical.expected_change_paths`),
-            allowed_support_paths: Object.hasOwn(technical, "allowed_support_paths")
-                ? repositoryPatterns(technical.allowed_support_paths, `${label}.technical.allowed_support_paths`)
-                : [],
-            forbidden_paths: Object.hasOwn(technical, "forbidden_paths")
-                ? repositoryPatterns(technical.forbidden_paths, `${label}.technical.forbidden_paths`)
-                : [],
-            forbidden_shortcuts: Object.hasOwn(technical, "forbidden_shortcuts")
-                ? parseApplicableKeyedStatements(technical.forbidden_shortcuts, `${label}.technical.forbidden_shortcuts`)
-                : [],
-            bindings: Object.hasOwn(technical, "bindings")
-                ? parseBindings(technical.bindings, `${label}.technical.bindings`)
-                : [],
-            rollback_and_recovery: Object.hasOwn(technical, "rollback_and_recovery")
-                ? nullable(technical.rollback_and_recovery, (item) => parseRollback(item, `${label}.technical.rollback_and_recovery`))
-                : null,
-        },
-        acceptance: {
-            checks: array(acceptance.checks, `${label}.acceptance.checks`).map((item, index) => parseCheck(item, `${label}.acceptance.checks[${index}]`)),
-            population: Object.hasOwn(acceptance, "population")
-                ? nullable(acceptance.population, (item) => parsePopulation(item, `${label}.acceptance.population`))
-                : null,
-            counterfactual_controls: Object.hasOwn(acceptance, "counterfactual_controls")
-                ? parseCounterfactuals(acceptance.counterfactual_controls, `${label}.acceptance.counterfactual_controls`)
-                : [],
-        },
-    };
-}
-export function parseOutcomeFragment(raw, relative) {
-    const value = parseStrictYaml(raw);
-    if (Array.isArray(value))
-        return value.map((item, index) => parseOutcome(item, `${relative}[${index}]`));
-    const row = object(value, relative, [], [
-        "schema_version",
-        "outcomes",
-        "key",
-        "title",
-        "stage",
-        "depends_on",
-        "applicability",
-        "semantic_fact_bindings",
-        "product",
-        "technical",
-        "acceptance",
-    ]);
-    if (Object.hasOwn(row, "outcomes")) {
-        if (Object.keys(row).some((name) => !["schema_version", "outcomes"].includes(name)))
-            throw new Error(`delivery_contract_invalid:${relative}:fragment cannot mix root or Outcome keys`);
-        if (Object.hasOwn(row, "schema_version"))
-            literal(row.schema_version, ["long-task-outcomes-v2"], `${relative}.schema_version`);
-        return array(row.outcomes, `${relative}.outcomes`).map((item, index) => parseOutcome(item, `${relative}.outcomes[${index}]`));
-    }
-    return [parseOutcome(value, relative)];
-}
-export function safeFragmentPath(value, index) {
-    const normalized = normalizeRepositoryFile(value, `outcome_files[${index}]`);
-    if (!normalized.endsWith(".yaml"))
-        throw new Error(`unsafe_path:outcome_files[${index}]:${value}`);
-    return normalized;
-}

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;