project-tiny-context-harness 0.8.11 → 0.8.12

package/dist/lib/long-task-evidence-capability-codec.js

@@ -183,39 +183,11 @@ function decodeRecord(value, index) {
                 cold_start: row.cold_start,
             };
         case "design_method":
-            exact(row, label, [
-                "assertion_key",
-                "capability",
-                "design_target_ref",
-                "target_ref",
-                "method",
-                "cells",
-            ]);
-            return {
-                ...base,
-                capability,
-                design_target_ref: key(row.design_target_ref, `${label}.design_target_ref`),
-                target_ref: key(row.target_ref, `${label}.target_ref`),
-                method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${label}.method`),
-                cells: array(row.cells, `${label}.cells`).map((item, cellIndex) => {
-                    const cellLabel = `${label}.cells[${cellIndex}]`;
-                    const cell = record(item, cellLabel);
-                    exact(cell, cellLabel, [
-                        "condition_key",
-                        "artifact_path",
-                        "observation_artifact_path",
-                        "fact_refs",
-                        "fact_results",
-                    ]);
-                    return {
-                        condition_key: key(cell.condition_key, `${cellLabel}.condition_key`),
-                        artifact_path: nonEmpty(cell.artifact_path, `${cellLabel}.artifact_path`),
-                        observation_artifact_path: nonEmpty(cell.observation_artifact_path, `${cellLabel}.observation_artifact_path`),
-                        fact_refs: designFactRefs(cell.fact_refs, `${cellLabel}.fact_refs`),
-                        fact_results: array(cell.fact_results, `${cellLabel}.fact_results`).map((result, resultIndex) => decodeDesignFactResult(result, `${cellLabel}.fact_results[${resultIndex}]`)),
-                    };
-                }),
-            };
+            return Object.hasOwn(row, "fact_model")
+                ? decodeSymbolicDesignMethodEvidence(row, label, base)
+                : decodeGroundDesignMethodEvidence(row, label, base);
+        case "design_symbolic_certificate":
+            return decodeDesignSymbolicCertificateEvidence(row, label, base);
         case "semantic_fact":
             return decodeSemanticFactEvidence(row, label, base);
         case "input_variation":
@@ -224,6 +196,217 @@ function decodeRecord(value, index) {
             throw invalidRecord(`${label}.capability_unsupported:${capability}`);
     }
 }
+function decodeGroundDesignMethodEvidence(row, label, base) {
+    exact(row, label, [
+        "assertion_key",
+        "capability",
+        "design_target_ref",
+        "target_ref",
+        "method",
+        "cells",
+    ]);
+    return {
+        ...base,
+        capability: "design_method",
+        design_target_ref: key(row.design_target_ref, `${label}.design_target_ref`),
+        target_ref: key(row.target_ref, `${label}.target_ref`),
+        method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${label}.method`),
+        cells: array(row.cells, `${label}.cells`).map((item, cellIndex) => {
+            const cellLabel = `${label}.cells[${cellIndex}]`;
+            const cell = record(item, cellLabel);
+            exact(cell, cellLabel, [
+                "condition_key",
+                "artifact_path",
+                "observation_artifact_path",
+                "fact_refs",
+                "fact_results",
+            ]);
+            return {
+                condition_key: key(cell.condition_key, `${cellLabel}.condition_key`),
+                artifact_path: nonEmpty(cell.artifact_path, `${cellLabel}.artifact_path`),
+                observation_artifact_path: nonEmpty(cell.observation_artifact_path, `${cellLabel}.observation_artifact_path`),
+                fact_refs: designFactRefs(cell.fact_refs, `${cellLabel}.fact_refs`),
+                fact_results: array(cell.fact_results, `${cellLabel}.fact_results`).map((result, resultIndex) => decodeDesignFactResult(result, `${cellLabel}.fact_results[${resultIndex}]`)),
+            };
+        }),
+    };
+}
+function decodeSymbolicDesignMethodEvidence(row, label, base) {
+    exact(row, label, [
+        "assertion_key",
+        "capability",
+        "fact_model",
+        "design_target_ref",
+        "target_ref",
+        "method",
+        "artifact_path",
+        "observation_artifact_path",
+        "rule_results",
+    ]);
+    return {
+        ...base,
+        capability: "design_method",
+        fact_model: literal(row.fact_model, ["symbolic_rules_v2"], `${label}.fact_model`),
+        design_target_ref: key(row.design_target_ref, `${label}.design_target_ref`),
+        target_ref: key(row.target_ref, `${label}.target_ref`),
+        method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${label}.method`),
+        artifact_path: nonEmpty(row.artifact_path, `${label}.artifact_path`),
+        observation_artifact_path: nonEmpty(row.observation_artifact_path, `${label}.observation_artifact_path`),
+        rule_results: array(row.rule_results, `${label}.rule_results`).map((item, index) => decodeDesignSymbolicRuleResult(item, `${label}.rule_results[${index}]`)),
+    };
+}
+function decodeDesignSymbolicRuleResult(value, label) {
+    const row = record(value, label);
+    exact(row, label, [
+        "obligation_ref",
+        "fact_rule_ref",
+        "region_sha256",
+        "subject_or_relation_ref",
+        "property_ref",
+        "population_ref",
+        "quantifier",
+        "actual_observation",
+        "actual_environment",
+        "observation_sensitivity",
+        "expected",
+        "proof_surface",
+        "observation_boundary",
+        "comparison",
+        "verdict",
+        "oracle",
+        "environment",
+        "protected_value_policy",
+        "completion_effect",
+    ]);
+    const decoded = decodeDesignFactResult({
+        fact_ref: row.fact_rule_ref,
+        subject_ref: row.subject_or_relation_ref,
+        variation_ref: "symbolic",
+        property_ref: row.property_ref,
+        actual_observation: row.actual_observation,
+        actual_environment: row.actual_environment,
+        expected: row.expected,
+        comparison: row.comparison,
+        verdict: row.verdict,
+        oracle: row.oracle,
+        environment: row.environment,
+    }, label);
+    const quantifier = record(row.quantifier, `${label}.quantifier`);
+    exact(quantifier, `${label}.quantifier`, ["kind", "minimum", "maximum"]);
+    return {
+        obligation_ref: designFactRef(row.obligation_ref, `${label}.obligation_ref`),
+        fact_rule_ref: decoded.fact_ref,
+        region_sha256: sha(row.region_sha256, `${label}.region_sha256`),
+        subject_or_relation_ref: decoded.subject_ref,
+        property_ref: decoded.property_ref,
+        population_ref: nullable(row.population_ref, (item) => designFactRef(item, `${label}.population_ref`)),
+        quantifier: {
+            kind: literal(quantifier.kind, [
+                "one",
+                "all",
+                "any",
+                "none",
+                "exactly",
+                "at_least",
+                "at_most",
+                "range",
+            ], `${label}.quantifier.kind`),
+            minimum: nullable(quantifier.minimum, (item) => nonnegativeInteger(item, `${label}.quantifier.minimum`)),
+            maximum: nullable(quantifier.maximum, (item) => nonnegativeInteger(item, `${label}.quantifier.maximum`)),
+        },
+        actual_observation: decoded.actual_observation,
+        actual_environment: decoded.actual_environment,
+        observation_sensitivity: literal(row.observation_sensitivity, ["plain", "protected"], `${label}.observation_sensitivity`),
+        expected: decoded.expected,
+        proof_surface: nonEmpty(row.proof_surface, `${label}.proof_surface`),
+        observation_boundary: nonEmpty(row.observation_boundary, `${label}.observation_boundary`),
+        comparison: decoded.comparison,
+        verdict: decoded.verdict,
+        oracle: decoded.oracle,
+        environment: decoded.environment,
+        protected_value_policy: nonEmpty(row.protected_value_policy, `${label}.protected_value_policy`),
+        completion_effect: nonEmpty(row.completion_effect, `${label}.completion_effect`),
+    };
+}
+function decodeDesignSymbolicCertificateEvidence(row, label, base) {
+    exact(row, label, [
+        "assertion_key",
+        "capability",
+        "design_target_ref",
+        "target_ref",
+        "artifact_path",
+        "artifact_sha256",
+        "metrics",
+        "certificate_results",
+    ]);
+    const metrics = record(row.metrics, `${label}.metrics`);
+    exact(metrics, `${label}.metrics`, [
+        "semantic_obligations",
+        "certificate_obligations",
+        "certificate_covered_omitted_axes",
+        "certificate_covered_dependency_edges",
+        "canonical_dag_nodes",
+        "canonical_partition_edges",
+        "canonical_bytes",
+        "theoretical_ground_cardinality",
+    ]);
+    return {
+        ...base,
+        capability: "design_symbolic_certificate",
+        design_target_ref: key(row.design_target_ref, `${label}.design_target_ref`),
+        target_ref: key(row.target_ref, `${label}.target_ref`),
+        artifact_path: nonEmpty(row.artifact_path, `${label}.artifact_path`),
+        artifact_sha256: sha(row.artifact_sha256, `${label}.artifact_sha256`),
+        metrics: {
+            semantic_obligations: nonnegativeInteger(metrics.semantic_obligations, `${label}.metrics.semantic_obligations`),
+            certificate_obligations: nonnegativeInteger(metrics.certificate_obligations, `${label}.metrics.certificate_obligations`),
+            certificate_covered_omitted_axes: nonnegativeInteger(metrics.certificate_covered_omitted_axes, `${label}.metrics.certificate_covered_omitted_axes`),
+            certificate_covered_dependency_edges: nonnegativeInteger(metrics.certificate_covered_dependency_edges, `${label}.metrics.certificate_covered_dependency_edges`),
+            canonical_dag_nodes: nonnegativeInteger(metrics.canonical_dag_nodes, `${label}.metrics.canonical_dag_nodes`),
+            canonical_partition_edges: nonnegativeInteger(metrics.canonical_partition_edges, `${label}.metrics.canonical_partition_edges`),
+            canonical_bytes: nonnegativeInteger(metrics.canonical_bytes, `${label}.metrics.canonical_bytes`),
+            theoretical_ground_cardinality: decimalCardinality(metrics.theoretical_ground_cardinality, `${label}.metrics.theoretical_ground_cardinality`),
+        },
+        certificate_results: array(row.certificate_results, `${label}.certificate_results`).map((item, index) => {
+            const itemLabel = `${label}.certificate_results[${index}]`;
+            const result = record(item, itemLabel);
+            exact(result, itemLabel, [
+                "certificate_ref",
+                "fact_rule_refs",
+                "omitted_axis_refs",
+                "dependency_edge_refs",
+                "canonical_rule_dag_sha256",
+                "recomputed",
+                "verdict",
+                ...[
+                    "source_noninterference_proof_sha256",
+                    "production_noninterference_proof_sha256",
+                ].filter((field) => Object.hasOwn(result, field)),
+            ]);
+            if (result.recomputed !== true)
+                throw invalidRecord(`${itemLabel}.recomputed`);
+            return {
+                certificate_ref: designFactRef(result.certificate_ref, `${itemLabel}.certificate_ref`),
+                fact_rule_refs: designFactRefs(result.fact_rule_refs, `${itemLabel}.fact_rule_refs`),
+                omitted_axis_refs: designFactRefs(result.omitted_axis_refs, `${itemLabel}.omitted_axis_refs`),
+                dependency_edge_refs: designFactRefs(result.dependency_edge_refs, `${itemLabel}.dependency_edge_refs`),
+                canonical_rule_dag_sha256: sha(result.canonical_rule_dag_sha256, `${itemLabel}.canonical_rule_dag_sha256`),
+                ...(result.source_noninterference_proof_sha256 === undefined
+                    ? {}
+                    : {
+                        source_noninterference_proof_sha256: sha(result.source_noninterference_proof_sha256, `${itemLabel}.source_noninterference_proof_sha256`),
+                    }),
+                ...(result.production_noninterference_proof_sha256 === undefined
+                    ? {}
+                    : {
+                        production_noninterference_proof_sha256: sha(result.production_noninterference_proof_sha256, `${itemLabel}.production_noninterference_proof_sha256`),
+                    }),
+                recomputed: true,
+                verdict: literal(result.verdict, ["passed", "failed"], `${itemLabel}.verdict`),
+            };
+        }),
+    };
+}
 function decodeInputVariationEvidence(row, label, base) {
     exact(row, label, [
         "assertion_key",
@@ -249,7 +432,7 @@ function decodeInputVariationEvidence(row, label, base) {
     };
 }
 function decodeSemanticFactEvidence(row, label, base) {
-    exact(row, label, [
+    exactOptional(row, label, [
         "assertion_key",
         "capability",
         "manifest_ref",
@@ -270,7 +453,21 @@ function decodeSemanticFactEvidence(row, label, base) {
         "oracle",
         "environment",
         "observer_results",
+    ], [
+        "fact_key",
+        "fact_revision_digest",
+        "obligation_key",
+        "obligation_revision_digest",
     ]);
+    const revisionFields = [
+        "fact_key",
+        "fact_revision_digest",
+        "obligation_key",
+        "obligation_revision_digest",
+    ];
+    const revisionFieldCount = revisionFields.filter((field) => Object.hasOwn(row, field)).length;
+    if (revisionFieldCount !== 0 && revisionFieldCount !== revisionFields.length)
+        throw invalidRecord(`${label}.revision_identity.shape`);
     const actual = record(row.actual_observation, `${label}.actual_observation`);
     exact(actual, `${label}.actual_observation`, [
         "artifact_path",
@@ -320,6 +517,14 @@ function decodeSemanticFactEvidence(row, label, base) {
         manifest_sha256: sha(row.manifest_sha256, `${label}.manifest_sha256`),
         outcome_ref: semanticFactRef(row.outcome_ref, `${label}.outcome_ref`),
         target_ref: key(row.target_ref, `${label}.target_ref`),
+        ...(revisionFieldCount
+            ? {
+                fact_key: semanticFactRef(row.fact_key, `${label}.fact_key`),
+                fact_revision_digest: sha(row.fact_revision_digest, `${label}.fact_revision_digest`),
+                obligation_key: semanticFactRef(row.obligation_key, `${label}.obligation_key`),
+                obligation_revision_digest: sha(row.obligation_revision_digest, `${label}.obligation_revision_digest`),
+            }
+            : {}),
         fact_ref: semanticFactRef(row.fact_ref, `${label}.fact_ref`),
         proof_ref: semanticFactRef(row.proof_ref, `${label}.proof_ref`),
         method: semanticFactRef(row.method, `${label}.method`),
@@ -611,6 +816,12 @@ function exact(row, label, fields) {
         Object.keys(row).some((field) => !allowed.has(field)))
         throw invalidRecord(`${label}.shape`);
 }
+function exactOptional(row, label, required, optional) {
+    const allowed = new Set([...required, ...optional]);
+    if (required.some((field) => !Object.hasOwn(row, field)) ||
+        Object.keys(row).some((field) => !allowed.has(field)))
+        throw invalidRecord(`${label}.shape`);
+}
 function array(value, label) {
     if (!Array.isArray(value))
         throw invalidRecord(label);
@@ -621,6 +832,17 @@ function nonEmpty(value, label) {
         throw invalidRecord(label);
     return value;
 }
+function nonnegativeInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw invalidRecord(label);
+    return value;
+}
+function decimalCardinality(value, label) {
+    const result = nonEmpty(value, label);
+    if (!/^(0|[1-9][0-9]*)$/u.test(result))
+        throw invalidRecord(label);
+    return result;
+}
 function key(value, label) {
     const result = nonEmpty(value, label);
     if (!/^[a-z0-9][a-z0-9-]*$/u.test(result))

package/dist/lib/long-task-evidence-capability-policy.js

@@ -45,6 +45,9 @@ function validateArtifactCapabilityDeclarations(assertion, check, label, report)
     if (assertion.evidence_capabilities.includes("design_method") &&
         !check.artifact_globs.length)
         issue(report, "design_method_artifact_required", label);
+    if (assertion.evidence_capabilities.includes("design_symbolic_certificate") &&
+        !check.artifact_globs.length)
+        issue(report, "design_symbolic_certificate_artifact_required", label);
     if (assertion.evidence_capabilities.includes("semantic_fact") &&
         !check.artifact_globs.length)
         issue(report, "semantic_fact_artifact_required", label);
@@ -58,6 +61,7 @@ function validateRunnerCapabilityDeclarations(assertion, check, targets, label,
             capability !== "interaction_trace" &&
             capability !== "design_conformance" &&
             capability !== "design_method" &&
+            capability !== "design_symbolic_certificate" &&
             capability !== "semantic_fact" &&
             capability !== "target_runtime"))
         issue(report, "playwright_evidence_capability_unsupported", label);
@@ -161,8 +165,17 @@ function validateDistinctDesignMethodArtifacts(check, records, artifactHashes, f
     const pathOwners = new Map();
     const digestOwners = new Map();
     for (const record of records) {
+        if (record.capability === "design_symbolic_certificate") {
+            addDistinctArtifact(check, findings, pathOwners, digestOwners, record.assertion_key, `symbolic-certificate:${record.design_target_ref}`, record.artifact_path, artifactHashes);
+            continue;
+        }
         if (record.capability !== "design_method")
             continue;
+        if ("fact_model" in record) {
+            addDistinctArtifact(check, findings, pathOwners, digestOwners, record.assertion_key, `symbolic-method:${record.design_target_ref}:${record.method}:observation`, record.observation_artifact_path, artifactHashes);
+            addDistinctArtifact(check, findings, pathOwners, digestOwners, record.assertion_key, `symbolic-method:${record.design_target_ref}:${record.method}:comparison`, record.artifact_path, artifactHashes);
+            continue;
+        }
         for (const cell of record.cells) {
             const currentOwner = `${record.method}:${cell.condition_key}`;
             const pathOwner = pathOwners.get(cell.observation_artifact_path);
@@ -181,6 +194,21 @@ function validateDistinctDesignMethodArtifacts(check, records, artifactHashes, f
         }
     }
 }
+function addDistinctArtifact(check, findings, pathOwners, digestOwners, assertionKey, currentOwner, path, artifactHashes) {
+    const pathOwner = pathOwners.get(path);
+    if (pathOwner)
+        findings.push(reusedDesignMethodArtifactFinding(check, assertionKey, currentOwner, pathOwner, "path", path));
+    else
+        pathOwners.set(path, currentOwner);
+    const digest = artifactHashes[path];
+    if (!digest)
+        return;
+    const digestOwner = digestOwners.get(digest);
+    if (digestOwner)
+        findings.push(reusedDesignMethodArtifactFinding(check, assertionKey, currentOwner, digestOwner, "sha256", digest));
+    else
+        digestOwners.set(digest, currentOwner);
+}
 function reusedDesignMethodArtifactFinding(check, assertionKey, currentOwner, previousOwner, identityKind, identity) {
     return {
         ...checkFinding(check, "design_method_evidence_reused", `Design-method evidence ${identityKind} ${identity} is reused by ${previousOwner} and ${currentOwner}.`, "Emit method-and-condition evidence whose path and current content digest are both distinct for every verification-method cell."),