project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-ui-surface-shape.js

@@ -1,402 +0,0 @@
-import { DESIGN_RESOURCE_VERIFICATION_METHODS } from "./design-resource-handoff-types.js";
-import { DESIGN_RESOURCE_COMPARATORS } from "./design-resource-fact-manifest-types.js";
-import { parseDesignResourceLocatedDigest } from "./design-resource-fact-shape-primitives.js";
-import { nonnegativeInteger } from "./design-resource-handoff-shape-primitives.js";
-import { EXECUTION_TARGET_CAPABILITIES } from "./execution-target-capabilities.js";
-import { array, fail, key, literal, nullable, object, repositoryFile, repositoryFiles, string, strings, } from "./long-task-shape-primitives.js";
-export function parseSurfaceBindings(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "surface_ref",
-            "target_ref",
-            "control_refs",
-            "route_binding_ref",
-            "component_binding_refs",
-            "root_journey_check_ref",
-            "entry_action_ref",
-            "design_targets",
-            "acceptance_blockers",
-        ]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            surface_ref: string(row.surface_ref, `${itemLabel}.surface_ref`),
-            target_ref: key(row.target_ref, `${itemLabel}.target_ref`),
-            control_refs: keys(row.control_refs, `${itemLabel}.control_refs`),
-            route_binding_ref: key(row.route_binding_ref, `${itemLabel}.route_binding_ref`),
-            component_binding_refs: keys(row.component_binding_refs, `${itemLabel}.component_binding_refs`),
-            root_journey_check_ref: key(row.root_journey_check_ref, `${itemLabel}.root_journey_check_ref`),
-            entry_action_ref: key(row.entry_action_ref, `${itemLabel}.entry_action_ref`),
-            design_targets: parseDesignTargets(row.design_targets, `${itemLabel}.design_targets`),
-            acceptance_blockers: parseAcceptanceBlockers(row.acceptance_blockers, `${itemLabel}.acceptance_blockers`),
-        };
-    });
-}
-function parseDesignTargets(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "interpretation",
-            "source_paths",
-            "condition_keys",
-            "claim_refs",
-            "conformance_check_ref",
-            "conformance_assertion_ref",
-            "verification_method_bindings",
-            "actual_artifact_path",
-            "comparison_artifact_path",
-        ], [
-            "fact_model",
-            "symbolic_method_bindings",
-            "symbolic_certificate_binding",
-        ]);
-        const factModel = row.fact_model === undefined
-            ? undefined
-            : literal(row.fact_model, ["symbolic_rules_v2"], `${itemLabel}.fact_model`);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            ...(factModel ? { fact_model: factModel } : {}),
-            interpretation: literal(row.interpretation, ["exact_target", "constraint"], `${itemLabel}.interpretation`),
-            source_paths: repositoryFiles(row.source_paths, `${itemLabel}.source_paths`),
-            condition_keys: keys(row.condition_keys, `${itemLabel}.condition_keys`),
-            claim_refs: strings(row.claim_refs, `${itemLabel}.claim_refs`),
-            conformance_check_ref: key(row.conformance_check_ref, `${itemLabel}.conformance_check_ref`),
-            conformance_assertion_ref: key(row.conformance_assertion_ref, `${itemLabel}.conformance_assertion_ref`),
-            verification_method_bindings: parseVerificationMethodBindings(row.verification_method_bindings, `${itemLabel}.verification_method_bindings`),
-            ...(row.symbolic_method_bindings === undefined
-                ? {}
-                : {
-                    symbolic_method_bindings: parseSymbolicMethodBindings(row.symbolic_method_bindings, `${itemLabel}.symbolic_method_bindings`),
-                }),
-            ...(row.symbolic_certificate_binding === undefined
-                ? {}
-                : {
-                    symbolic_certificate_binding: parseSymbolicCertificateBinding(row.symbolic_certificate_binding, `${itemLabel}.symbolic_certificate_binding`),
-                }),
-            actual_artifact_path: repositoryFile(row.actual_artifact_path, `${itemLabel}.actual_artifact_path`),
-            comparison_artifact_path: repositoryFile(row.comparison_artifact_path, `${itemLabel}.comparison_artifact_path`),
-        };
-    });
-}
-function parseSymbolicMethodBindings(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "method",
-            "assertion_ref",
-            "artifact_path",
-            "observation_path",
-            "rule_expectations",
-        ]);
-        return {
-            method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${itemLabel}.method`),
-            assertion_ref: key(row.assertion_ref, `${itemLabel}.assertion_ref`),
-            artifact_path: repositoryFile(row.artifact_path, `${itemLabel}.artifact_path`),
-            observation_path: repositoryFile(row.observation_path, `${itemLabel}.observation_path`),
-            rule_expectations: array(row.rule_expectations, `${itemLabel}.rule_expectations`).map((expectation, expectationIndex) => parseSymbolicRuleExpectation(expectation, `${itemLabel}.rule_expectations[${expectationIndex}]`)),
-        };
-    });
-}
-function parseSymbolicRuleExpectation(value, label) {
-    const row = object(value, label, [
-        "obligation_ref",
-        "fact_rule_ref",
-        "region_sha256",
-        "subject_or_relation_ref",
-        "property_ref",
-        "population_ref",
-        "quantifier",
-        "observation_sensitivity",
-        "expected",
-        "proof_surface",
-        "observation_boundary",
-        "comparison",
-        "oracle",
-        "environment",
-        "protected_value_policy",
-        "completion_effect",
-    ]);
-    const comparison = object(row.comparison, `${label}.comparison`, [
-        "comparator",
-        "mode",
-        "parameters",
-        "tolerance",
-        "mask",
-    ]);
-    const comparator = string(comparison.comparator, `${label}.comparison.comparator`);
-    if (!DESIGN_RESOURCE_COMPARATORS.includes(comparator) &&
-        !/^custom\.[a-z0-9][a-z0-9._-]*$/u.test(comparator))
-        fail(`${label}.comparison.comparator`, "must be a standard comparator or custom.*");
-    const oracle = object(row.oracle, `${label}.oracle`, [
-        "key",
-        "trust",
-        "identity",
-        "version",
-        "sha256",
-    ]);
-    const environment = object(row.environment, `${label}.environment`, [
-        "key",
-        "identity",
-        "definition",
-    ]);
-    const quantifier = object(row.quantifier, `${label}.quantifier`, [
-        "kind",
-        "minimum",
-        "maximum",
-    ]);
-    return {
-        obligation_ref: designFactRef(row.obligation_ref, `${label}.obligation_ref`),
-        fact_rule_ref: designFactRef(row.fact_rule_ref, `${label}.fact_rule_ref`),
-        region_sha256: digest(row.region_sha256, `${label}.region_sha256`),
-        subject_or_relation_ref: designFactRef(row.subject_or_relation_ref, `${label}.subject_or_relation_ref`),
-        property_ref: designFactRef(row.property_ref, `${label}.property_ref`),
-        population_ref: nullable(row.population_ref, (entry) => designFactRef(entry, `${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, (entry) => nonnegativeInteger(entry, `${label}.quantifier.minimum`)),
-            maximum: nullable(quantifier.maximum, (entry) => nonnegativeInteger(entry, `${label}.quantifier.maximum`)),
-        },
-        observation_sensitivity: literal(row.observation_sensitivity, ["plain", "protected"], `${label}.observation_sensitivity`),
-        expected: parseDesignResourceLocatedDigest(row.expected, `${label}.expected`),
-        proof_surface: string(row.proof_surface, `${label}.proof_surface`),
-        observation_boundary: string(row.observation_boundary, `${label}.observation_boundary`),
-        comparison: {
-            comparator,
-            mode: literal(comparison.mode, ["exact", "tolerance"], `${label}.comparison.mode`),
-            parameters: parseDesignResourceLocatedDigest(comparison.parameters, `${label}.comparison.parameters`),
-            tolerance: nullable(comparison.tolerance, (entry) => parseDesignResourceLocatedDigest(entry, `${label}.comparison.tolerance`)),
-            mask: nullable(comparison.mask, (entry) => parseDesignResourceLocatedDigest(entry, `${label}.comparison.mask`)),
-        },
-        oracle: {
-            key: designFactRef(oracle.key, `${label}.oracle.key`),
-            trust: literal(oracle.trust, ["frozen_executable", "named_external_tcb"], `${label}.oracle.trust`),
-            identity: string(oracle.identity, `${label}.oracle.identity`),
-            version: string(oracle.version, `${label}.oracle.version`),
-            sha256: nullable(oracle.sha256, (entry) => digest(entry, `${label}.oracle.sha256`)),
-        },
-        environment: {
-            key: designFactRef(environment.key, `${label}.environment.key`),
-            identity: string(environment.identity, `${label}.environment.identity`),
-            definition: parseDesignResourceLocatedDigest(environment.definition, `${label}.environment.definition`),
-        },
-        protected_value_policy: string(row.protected_value_policy, `${label}.protected_value_policy`),
-        completion_effect: string(row.completion_effect, `${label}.completion_effect`),
-    };
-}
-function parseSymbolicCertificateBinding(value, label) {
-    const row = object(value, label, [
-        "assertion_ref",
-        "artifact_path",
-        "expectations",
-        "metrics",
-    ]);
-    const metrics = object(row.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 {
-        assertion_ref: key(row.assertion_ref, `${label}.assertion_ref`),
-        artifact_path: repositoryFile(row.artifact_path, `${label}.artifact_path`),
-        expectations: array(row.expectations, `${label}.expectations`).map((item, index) => {
-            const itemLabel = `${label}.expectations[${index}]`;
-            const expectation = object(item, itemLabel, [
-                "certificate_ref",
-                "fact_rule_refs",
-                "omitted_axis_refs",
-                "dependency_edge_refs",
-                "canonical_rule_dag_sha256",
-            ], [
-                "source_noninterference_proof_sha256",
-                "production_noninterference_proof_sha256",
-            ]);
-            return {
-                certificate_ref: designFactRef(expectation.certificate_ref, `${itemLabel}.certificate_ref`),
-                fact_rule_refs: designFactRefs(expectation.fact_rule_refs, `${itemLabel}.fact_rule_refs`),
-                omitted_axis_refs: designFactRefs(expectation.omitted_axis_refs, `${itemLabel}.omitted_axis_refs`),
-                dependency_edge_refs: designFactRefs(expectation.dependency_edge_refs, `${itemLabel}.dependency_edge_refs`),
-                canonical_rule_dag_sha256: digest(expectation.canonical_rule_dag_sha256, `${itemLabel}.canonical_rule_dag_sha256`),
-                ...(expectation.source_noninterference_proof_sha256 === undefined
-                    ? {}
-                    : {
-                        source_noninterference_proof_sha256: digest(expectation.source_noninterference_proof_sha256, `${itemLabel}.source_noninterference_proof_sha256`),
-                    }),
-                ...(expectation.production_noninterference_proof_sha256 === undefined
-                    ? {}
-                    : {
-                        production_noninterference_proof_sha256: digest(expectation.production_noninterference_proof_sha256, `${itemLabel}.production_noninterference_proof_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: string(metrics.theoretical_ground_cardinality, `${label}.metrics.theoretical_ground_cardinality`),
-        },
-    };
-}
-function parseAcceptanceBlockers(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "status",
-            "refs",
-            "source_item_refs",
-            "verification_methods",
-            "required_capabilities",
-            "rationale",
-        ]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            status: literal(row.status, ["machine_claim", "external_confirmation"], `${itemLabel}.status`),
-            refs: strings(row.refs, `${itemLabel}.refs`),
-            source_item_refs: strings(row.source_item_refs, `${itemLabel}.source_item_refs`),
-            verification_methods: array(row.verification_methods, `${itemLabel}.verification_methods`).map((method, methodIndex) => literal(method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${itemLabel}.verification_methods[${methodIndex}]`)),
-            required_capabilities: array(row.required_capabilities, `${itemLabel}.required_capabilities`).map((capability, capabilityIndex) => literal(capability, EXECUTION_TARGET_CAPABILITIES, `${itemLabel}.required_capabilities[${capabilityIndex}]`)),
-            rationale: string(row.rationale, `${itemLabel}.rationale`),
-        };
-    });
-}
-function parseVerificationMethodBindings(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "method",
-            "assertion_ref",
-            "evidence_artifacts",
-        ]);
-        return {
-            method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${itemLabel}.method`),
-            assertion_ref: key(row.assertion_ref, `${itemLabel}.assertion_ref`),
-            evidence_artifacts: array(row.evidence_artifacts, `${itemLabel}.evidence_artifacts`).map((artifact, artifactIndex) => {
-                const artifactLabel = `${itemLabel}.evidence_artifacts[${artifactIndex}]`;
-                const entry = object(artifact, artifactLabel, [
-                    "condition_key",
-                    "path",
-                    "observation_path",
-                    "fact_refs",
-                    "fact_expectations",
-                ]);
-                return {
-                    condition_key: key(entry.condition_key, `${artifactLabel}.condition_key`),
-                    path: repositoryFile(entry.path, `${artifactLabel}.path`),
-                    observation_path: repositoryFile(entry.observation_path, `${artifactLabel}.observation_path`),
-                    fact_refs: designFactRefs(entry.fact_refs, `${artifactLabel}.fact_refs`),
-                    fact_expectations: parseDesignFactExpectations(entry.fact_expectations, `${artifactLabel}.fact_expectations`),
-                };
-            }),
-        };
-    });
-}
-function parseDesignFactExpectations(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "fact_ref",
-            "subject_ref",
-            "variation_ref",
-            "property_ref",
-            "observation_sensitivity",
-            "expected",
-            "comparison",
-            "oracle",
-            "environment",
-        ]);
-        const comparison = object(row.comparison, `${itemLabel}.comparison`, [
-            "comparator",
-            "mode",
-            "parameters",
-            "tolerance",
-            "mask",
-        ]);
-        const comparator = string(comparison.comparator, `${itemLabel}.comparison.comparator`);
-        if (!DESIGN_RESOURCE_COMPARATORS.includes(comparator) &&
-            !/^custom\.[a-z0-9][a-z0-9._-]*$/u.test(comparator))
-            fail(`${itemLabel}.comparison.comparator`, "must be a standard comparator or custom.*");
-        const oracle = object(row.oracle, `${itemLabel}.oracle`, [
-            "key",
-            "trust",
-            "identity",
-            "version",
-            "sha256",
-        ]);
-        const environment = object(row.environment, `${itemLabel}.environment`, [
-            "key",
-            "identity",
-            "definition",
-        ]);
-        return {
-            fact_ref: designFactRef(row.fact_ref, `${itemLabel}.fact_ref`),
-            subject_ref: designFactRef(row.subject_ref, `${itemLabel}.subject_ref`),
-            variation_ref: designFactRef(row.variation_ref, `${itemLabel}.variation_ref`),
-            property_ref: designFactRef(row.property_ref, `${itemLabel}.property_ref`),
-            observation_sensitivity: literal(row.observation_sensitivity, ["plain", "protected"], `${itemLabel}.observation_sensitivity`),
-            expected: parseDesignResourceLocatedDigest(row.expected, `${itemLabel}.expected`),
-            comparison: {
-                comparator,
-                mode: literal(comparison.mode, ["exact", "tolerance"], `${itemLabel}.comparison.mode`),
-                parameters: parseDesignResourceLocatedDigest(comparison.parameters, `${itemLabel}.comparison.parameters`),
-                tolerance: nullable(comparison.tolerance, (entry) => parseDesignResourceLocatedDigest(entry, `${itemLabel}.comparison.tolerance`)),
-                mask: nullable(comparison.mask, (entry) => parseDesignResourceLocatedDigest(entry, `${itemLabel}.comparison.mask`)),
-            },
-            oracle: {
-                key: designFactRef(oracle.key, `${itemLabel}.oracle.key`),
-                trust: literal(oracle.trust, ["frozen_executable", "named_external_tcb"], `${itemLabel}.oracle.trust`),
-                identity: string(oracle.identity, `${itemLabel}.oracle.identity`),
-                version: string(oracle.version, `${itemLabel}.oracle.version`),
-                sha256: nullable(oracle.sha256, (entry) => digest(entry, `${itemLabel}.oracle.sha256`)),
-            },
-            environment: {
-                key: designFactRef(environment.key, `${itemLabel}.environment.key`),
-                identity: string(environment.identity, `${itemLabel}.environment.identity`),
-                definition: parseDesignResourceLocatedDigest(environment.definition, `${itemLabel}.environment.definition`),
-            },
-        };
-    });
-}
-function keys(value, label) {
-    return array(value, label).map((item, index) => key(item, `${label}[${index}]`));
-}
-function designFactRefs(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const result = string(item, itemLabel);
-        if (!/^[a-z0-9][a-z0-9._-]*$/u.test(result))
-            fail(itemLabel, "must match ^[a-z0-9][a-z0-9._-]*$");
-        return result;
-    });
-}
-function designFactRef(value, label) {
-    const result = string(value, label);
-    if (!/^[a-z0-9][a-z0-9._-]*$/u.test(result))
-        fail(label, "must match ^[a-z0-9][a-z0-9._-]*$");
-    return result;
-}
-function digest(value, label) {
-    const result = string(value, label);
-    if (!/^[a-f0-9]{64}$/u.test(result))
-        fail(label, "must be a lowercase SHA-256");
-    return result;
-}

package/dist/lib/long-task-ui-surface-types.d.ts

@@ -1,134 +0,0 @@
-import type { DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
-import type { DesignResourceComparator, DesignResourceLocatedDigestV1 } from "./design-resource-fact-manifest-types.js";
-import type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
-import type { SymbolicExtensionalPointV1 } from "./symbolic-denotation-types.js";
-export type DesignTargetInterpretationV2 = "exact_target" | "constraint";
-export interface DeliveryDesignFactExpectationV2 {
-    fact_ref: string;
-    subject_ref: string;
-    variation_ref: string;
-    property_ref: string;
-    observation_sensitivity: "plain" | "protected";
-    expected: DesignResourceLocatedDigestV1;
-    comparison: {
-        comparator: DesignResourceComparator | string;
-        mode: "exact" | "tolerance";
-        parameters: DesignResourceLocatedDigestV1;
-        tolerance: DesignResourceLocatedDigestV1 | null;
-        mask: DesignResourceLocatedDigestV1 | null;
-    };
-    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 DeliveryDesignVerificationBindingV2 {
-    method: DesignResourceVerificationMethod;
-    assertion_ref: string;
-    evidence_artifacts: Array<{
-        condition_key: string;
-        path: string;
-        observation_path: string;
-        fact_refs: string[];
-        fact_expectations: DeliveryDesignFactExpectationV2[];
-    }>;
-}
-export interface DeliveryDesignSymbolicRuleExpectationV2 {
-    obligation_ref: string;
-    fact_rule_ref: string;
-    region_sha256: string;
-    subject_or_relation_ref: string;
-    property_ref: string;
-    population_ref: string | null;
-    quantifier: SymbolicExtensionalPointV1["quantifier"];
-    observation_sensitivity: "plain" | "protected";
-    expected: DesignResourceLocatedDigestV1;
-    proof_surface: string;
-    observation_boundary: string;
-    comparison: DeliveryDesignFactExpectationV2["comparison"];
-    oracle: DeliveryDesignFactExpectationV2["oracle"];
-    environment: DeliveryDesignFactExpectationV2["environment"];
-    protected_value_policy: string;
-    completion_effect: string;
-}
-export interface DeliveryDesignSymbolicVerificationBindingV2 {
-    method: DesignResourceVerificationMethod;
-    assertion_ref: string;
-    artifact_path: string;
-    observation_path: string;
-    rule_expectations: DeliveryDesignSymbolicRuleExpectationV2[];
-}
-export interface DeliveryDesignSymbolicCertificateExpectationV2 {
-    certificate_ref: string;
-    fact_rule_refs: string[];
-    omitted_axis_refs: string[];
-    dependency_edge_refs: string[];
-    canonical_rule_dag_sha256: string;
-    source_noninterference_proof_sha256?: string;
-    production_noninterference_proof_sha256?: string;
-}
-export interface DeliveryDesignSymbolicCertificateBindingV2 {
-    assertion_ref: string;
-    artifact_path: string;
-    expectations: DeliveryDesignSymbolicCertificateExpectationV2[];
-    metrics: {
-        semantic_obligations: number;
-        certificate_obligations: number;
-        certificate_covered_omitted_axes: number;
-        certificate_covered_dependency_edges: number;
-        canonical_dag_nodes: number;
-        canonical_partition_edges: number;
-        canonical_bytes: number;
-        theoretical_ground_cardinality: string;
-    };
-}
-export interface DeliveryDesignTargetV2 {
-    key: string;
-    fact_model?: "symbolic_rules_v2";
-    interpretation: DesignTargetInterpretationV2;
-    source_paths: string[];
-    condition_keys: string[];
-    claim_refs: string[];
-    conformance_check_ref: string;
-    conformance_assertion_ref: string;
-    verification_method_bindings: DeliveryDesignVerificationBindingV2[];
-    symbolic_method_bindings?: DeliveryDesignSymbolicVerificationBindingV2[];
-    symbolic_certificate_binding?: DeliveryDesignSymbolicCertificateBindingV2;
-    actual_artifact_path: string;
-    comparison_artifact_path: string;
-}
-export type DesignAcceptanceBlockerStatusV2 = "machine_claim" | "external_confirmation";
-export interface DeliveryDesignAcceptanceBlockerV2 {
-    key: string;
-    status: DesignAcceptanceBlockerStatusV2;
-    refs: string[];
-    source_item_refs: string[];
-    verification_methods: DesignResourceVerificationMethod[];
-    required_capabilities: ExecutionTargetCapabilityV2[];
-    rationale: string;
-}
-export interface DeliverySurfaceBindingV2 {
-    key: string;
-    surface_ref: string;
-    target_ref: string;
-    control_refs: string[];
-    route_binding_ref: string;
-    component_binding_refs: string[];
-    root_journey_check_ref: string;
-    entry_action_ref: string;
-    design_targets: DeliveryDesignTargetV2[];
-    acceptance_blockers: DeliveryDesignAcceptanceBlockerV2[];
-}
-export interface CompiledDesignTargetV2 extends DeliveryDesignTargetV2 {
-    surface_binding_ref: string;
-    surface_ref: string;
-    target_ref: string;
-}

package/dist/lib/long-task-ui-surface-types.js

@@ -1 +0,0 @@
-export {};

package/dist/lib/long-task-ui-surface-validation.d.ts

@@ -1,13 +0,0 @@
-import type { CompiledClaimsV2 } from "./long-task-claims.js";
-import type { DeliveryCheckV2, DeliveryOutcomeV2, ProductClaimV2, ProofSurface } from "./long-task-delivery-types.js";
-export type Reporter = (message: string) => void;
-export declare function bindingCarriers(routeRef: string, componentRefs: string[], bindings: Map<string, DeliveryOutcomeV2["technical"]["bindings"][number]>, label: string, report?: Reporter, options?: {
-    allowEmptyComponentRefs?: boolean;
-}): string[];
-export declare function validateRootJourney(binding: DeliveryOutcomeV2["product"]["surface_bindings"][number], check: DeliveryCheckV2, label: string, report?: Reporter): void;
-export declare function validateTargetLocalClaimProof(outcome: DeliveryOutcomeV2, claim: ProductClaimV2, targetRef: string, expectedSurface: ProofSurface | null, claims: CompiledClaimsV2, checks: Map<string, DeliveryCheckV2>, label: string, report?: Reporter): void;
-export declare function expectedControlProofSurface(runtimeFamily: string | undefined): ProofSurface;
-export declare function controlClaims(claims: Map<string, ProductClaimV2>, controlRef: string): ProductClaimV2[];
-export declare function validateCarrierInputs(check: DeliveryCheckV2, carriers: string[], label: string, report?: Reporter): void;
-export declare function unique(values: string[], code: string, detail: string, report?: Reporter): void;
-export declare function issue(report: Reporter | undefined, code: string, detail: string): void;

package/dist/lib/long-task-ui-surface-validation.js

@@ -1,62 +0,0 @@
-import { proveRepositoryPatternSubset } from "./long-task-paths.js";
-export function bindingCarriers(routeRef, componentRefs, bindings, label, report, options = {}) {
-    if (!componentRefs.length && !options.allowEmptyComponentRefs)
-        issue(report, "ui_surface_binding_component_ref_required", label);
-    unique(componentRefs, "ui_surface_binding_component_ref_duplicate", label, report);
-    const carriers = [];
-    for (const ref of [routeRef, ...componentRefs]) {
-        const binding = bindings.get(ref);
-        if (!binding) {
-            issue(report, "ui_surface_binding_technical_binding_unknown", `${label}:${ref}`);
-            continue;
-        }
-        if (!binding.carrier_paths.length)
-            issue(report, "ui_surface_binding_carrier_required", `${label}:${ref}`);
-        carriers.push(...binding.carrier_paths);
-    }
-    return [...new Set(carriers)].sort();
-}
-export function validateRootJourney(binding, check, label, report) {
-    if (check.execution_target.target_ref !== binding.target_ref ||
-        check.execution_target.entrypoint !== "root")
-        issue(report, "ui_surface_binding_root_target_mismatch", label);
-    if (!check.journey_roles.includes("success"))
-        issue(report, "ui_surface_binding_root_success_required", label);
-    if (!check.scenario.when.some((step) => step.key === binding.entry_action_ref))
-        issue(report, "ui_surface_binding_entry_action_unknown", `${label}:${binding.entry_action_ref}`);
-}
-export function validateTargetLocalClaimProof(outcome, claim, targetRef, expectedSurface, claims, checks, label, report) {
-    const proofs = claims.summary.claims_by_outcome[outcome.key]?.[claim.local_key]?.proofs ??
-        [];
-    const matched = proofs.some((proof) => {
-        const check = checks.get(proof.check_key);
-        return (check?.execution_target.target_ref === targetRef &&
-            (expectedSurface === null || proof.proof_surface === expectedSurface));
-    });
-    if (!matched)
-        issue(report, "ui_surface_binding_target_claim_proof_missing", `${label}:${claim.local_key}:${targetRef}:${expectedSurface ?? "any"}`);
-}
-export function expectedControlProofSurface(runtimeFamily) {
-    return runtimeFamily === "browser" ? "ui_browser" : "runtime_behavior";
-}
-export function controlClaims(claims, controlRef) {
-    return [...claims.values()].filter((claim) => claim.kind === "control" &&
-        claim.local_key.startsWith(`control.${controlRef}.`));
-}
-export function validateCarrierInputs(check, carriers, label, report) {
-    for (const carrier of carriers)
-        if (!check.input_paths.some((input) => proveRepositoryPatternSubset(carrier, input).status ===
-            "proven_subset"))
-            issue(report, "ui_surface_binding_carrier_outside_check_inputs", `${label}:${check.key}:${carrier}`);
-}
-export function unique(values, code, detail, report) {
-    if (new Set(values).size !== values.length)
-        issue(report, code, detail);
-}
-export function issue(report, code, detail) {
-    const message = `delivery_contract_invalid:${code}:${detail}`;
-    if (report)
-        report(message);
-    else
-        throw new Error(message);
-}