project-tiny-context-harness 0.8.4 → 0.8.6

package/dist/lib/long-task-evidence-capability-types.d.ts

@@ -1,9 +1,15 @@
 import type { EvidenceCapabilityV2 } from "./long-task-semantic-contract-types.js";
 import type { DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
+import type { DesignResourceComparator, DesignResourceLocatedDigestV1 } from "./design-resource-fact-manifest-types.js";
+import type { SemanticFactEnvironmentV1, SemanticFactLocatedValueV1, SemanticFactOracleV1 } from "./semantic-fact-types.js";
 interface EvidenceRecordBaseV2 {
     assertion_key: string;
     capability: EvidenceCapabilityV2;
 }
+export interface DesignEvidenceLocatorV2 {
+    kind: "json_pointer" | "image_region" | "semantic_node" | "trace_event" | "timeline_sample" | "asset_ref" | "custom";
+    value: string;
+}
 export interface InteractionTraceEvidenceV2 extends EvidenceRecordBaseV2 {
     capability: "interaction_trace";
     target_ref: string;
@@ -81,6 +87,113 @@ export interface DesignMethodEvidenceV2 extends EvidenceRecordBaseV2 {
         artifact_path: string;
         observation_artifact_path: string;
         fact_refs: string[];
+        fact_results: DesignFactResultV2[];
+    }>;
+}
+export interface DesignFactResultV2 {
+    fact_ref: string;
+    subject_ref: string;
+    variation_ref: string;
+    property_ref: string;
+    actual_observation: {
+        artifact_path: string;
+        artifact_sha256: string;
+        locator: DesignEvidenceLocatorV2;
+        value_sha256: string;
+        sensitivity: "plain" | "protected";
+        redaction: {
+            policy_ref: string;
+            representation: "digest_only" | "redacted_structured";
+            raw_persisted: false;
+        } | null;
+    };
+    actual_environment: {
+        artifact_path: string;
+        artifact_sha256: string;
+        locator: DesignEvidenceLocatorV2;
+        value_sha256: string;
+    };
+    expected: DesignResourceLocatedDigestV1;
+    comparison: {
+        artifact_path: string;
+        artifact_sha256: string;
+        locator: DesignEvidenceLocatorV2;
+        result_sha256: string;
+        comparator: DesignResourceComparator | string;
+        mode: "exact" | "tolerance";
+        parameters: DesignResourceLocatedDigestV1;
+        tolerance: DesignResourceLocatedDigestV1 | null;
+        mask: DesignResourceLocatedDigestV1 | null;
+        passed: boolean;
+    };
+    verdict: "passed" | "failed";
+    oracle: {
+        key: string;
+        trust: "frozen_executable" | "named_external_tcb";
+        identity: string;
+        version: string;
+        sha256: string | null;
+    };
+    environment: {
+        key: string;
+        identity: string;
+        definition: DesignResourceLocatedDigestV1;
+    };
+}
+export interface SemanticFactEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "semantic_fact";
+    manifest_ref: string;
+    manifest_sha256: string;
+    outcome_ref: string;
+    target_ref: string;
+    fact_ref: string;
+    proof_ref: string;
+    method: string;
+    subject_ref: string;
+    condition_ref: string;
+    property_ref: string;
+    actual_observation: {
+        artifact_path: string;
+        artifact_sha256: string;
+        locator: DesignEvidenceLocatorV2;
+        value_sha256: string;
+        sensitivity: "plain" | "protected";
+        redaction: {
+            policy_ref: string;
+            representation: "digest_only" | "redacted_structured";
+            raw_persisted: false;
+        } | null;
+    };
+    actual_environment: {
+        artifact_path: string;
+        artifact_sha256: string;
+        locator: DesignEvidenceLocatorV2;
+        value_sha256: string;
+    };
+    expected: SemanticFactLocatedValueV1;
+    comparison: {
+        artifact_path: string;
+        artifact_sha256: string;
+        locator: DesignEvidenceLocatorV2;
+        result_sha256: string;
+        comparator: string;
+        mode: "exact" | "tolerance";
+        parameters: SemanticFactLocatedValueV1;
+        tolerance: SemanticFactLocatedValueV1 | null;
+        mask: SemanticFactLocatedValueV1 | null;
+        passed: boolean;
+    };
+    verdict: "passed" | "failed";
+    oracle: SemanticFactOracleV1;
+    environment: SemanticFactEnvironmentV1;
+    observer_results: Array<{
+        target_ref: string;
+        artifact_path: string;
+        artifact_sha256: string;
+        locator: DesignEvidenceLocatorV2;
+        value_sha256: string;
+        comparison_result_sha256: string;
+        passed: boolean;
     }>;
 }
 export interface InputVariationEvidenceV2 extends EvidenceRecordBaseV2 {
@@ -91,5 +204,5 @@ export interface InputVariationEvidenceV2 extends EvidenceRecordBaseV2 {
     }>;
     failure_case_observed: boolean;
 }
-export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ExternalSideEffectEvidenceV2 | FailureInjectionEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | DesignMethodEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;
+export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ExternalSideEffectEvidenceV2 | FailureInjectionEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | DesignMethodEvidenceV2 | SemanticFactEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;
 export {};

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

@@ -5,6 +5,7 @@ import { array, boolean, key, literal, nullable, object, parseBindings, parseCon
 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, [
@@ -12,6 +13,7 @@ export function parseOutcome(value, label) {
         "title",
         "stage",
         "applicability",
+        "semantic_fact_bindings",
         "product",
         "technical",
         "acceptance",
@@ -48,6 +50,7 @@ export function parseOutcome(value, label) {
             ? 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}]`)),
@@ -118,6 +121,7 @@ export function parseOutcomeFragment(raw, relative) {
         "stage",
         "depends_on",
         "applicability",
+        "semantic_fact_bindings",
         "product",
         "technical",
         "acceptance",

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

@@ -0,0 +1,5 @@
+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;

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

@@ -0,0 +1,146 @@
+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), ...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))
+        .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 ?? []) {
+        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 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}`;
+}

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

@@ -1,4 +1,5 @@
 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;
@@ -13,6 +14,7 @@ export interface PlaywrightCaseInstance {
     given_keys: string[];
     action_keys: string[];
     attachment_names: string[];
+    attachment_payloads: Record<string, string>;
 }
 export interface PlaywrightCase {
     id: string;
@@ -33,6 +35,7 @@ export interface PlaywrightCase {
     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[];
@@ -41,5 +44,3 @@ export declare function collectCases(report: Record<string, unknown>, declaredId
 };
 export declare function declaredCaseIds(check: CompiledCheckV2): Set<string>;
 export declare function duplicateCaseInstance(values: PlaywrightCaseInstance[]): PlaywrightCaseInstance | null;
-export declare function record(value: unknown): Record<string, unknown> | null;
-export declare function same(left: string[], right: string[]): boolean;

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

@@ -1,3 +1,5 @@
+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 };
@@ -48,59 +50,21 @@ function declaredIdsInTitle(title, declared) {
     ].sort();
 }
 function playwrightCase(id, 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";
-    const results = Array.isArray(test.results)
-        ? test.results.map(record).filter(Boolean)
-        : [];
+    const { status, projectId } = playwrightIdentity(test);
+    const results = playwrightResults(test);
     const resultStatuses = results
         .map((result) => result.status)
         .filter((value) => typeof value === "string");
-    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";
-    const traces = results.map((result) => scenarioTrace(result));
-    const attachmentNames = [
-        ...new Set(results.flatMap((result) => Array.isArray(result.attachments)
-            ? result.attachments
-                .map(record)
-                .filter(Boolean)
-                .map((attachment) => attachment.name)
-                .filter((name) => typeof name === "string")
-            : [])),
-    ].sort();
-    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));
+    const state = playwrightExecutionState(status, resultStatuses);
+    const trace = consistentScenarioTrace(results);
+    const attachments = playwrightAttachments(results);
     return {
         id,
         project_id: projectId,
-        executed,
-        passed,
-        skipped,
-        flaky,
-        unexpected,
-        timed_out: timedOut,
-        interrupted,
+        ...state,
         status,
-        given_keys: traceConsistent ? givenKeys : [],
-        action_keys: traceConsistent ? actionKeys : [],
-        attachment_names: attachmentNames,
+        ...trace,
+        ...attachments,
     };
 }
 export function declaredCaseIds(check) {
@@ -125,36 +89,3 @@ export function duplicateCaseInstance(values) {
     }
     return null;
 }
-export function record(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function scenarioTrace(result) {
-    const givenKeys = [];
-    const actionKeys = [];
-    const visit = (value) => {
-        if (!Array.isArray(value))
-            return;
-        for (const item of value) {
-            const step = record(item);
-            if (!step)
-                continue;
-            if (typeof step.title === "string") {
-                const given = /^\[given:([a-z0-9][a-z0-9-]*)\]$/u.exec(step.title);
-                const action = /^\[action:([a-z0-9][a-z0-9-]*)\]$/u.exec(step.title);
-                if (given)
-                    givenKeys.push(given[1]);
-                if (action)
-                    actionKeys.push(action[1]);
-            }
-            visit(step.steps);
-        }
-    };
-    visit(result.steps);
-    return { given_keys: givenKeys, action_keys: actionKeys };
-}
-export function same(left, right) {
-    return (left.length === right.length &&
-        left.every((value, index) => value === right[index]));
-}

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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,143 @@
+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-evidence.d.ts

@@ -1,8 +1,8 @@
 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;
-export declare function designMethodAttachmentName(target: string, method: string, condition: string, kind: "record" | "observation"): string;