project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/design-resource-fact-manifest-validation.js

@@ -1,111 +0,0 @@
-import { parseDesignResourceFactManifestJson } from "./design-resource-fact-manifest-shape.js";
-import { validateDesignResourceFactManifestUniverse } from "./design-resource-fact-manifest-universe.js";
-import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
-export function parseDesignResourceFactManifests(parsed, contents) {
-    const resources = new Map(parsed.handoff.resources.map((resource) => [resource.key, resource]));
-    const manifests = new Map();
-    for (const target of parsed.handoff.targets) {
-        const manifestRef = target.source_profile.fact_manifest_resource_ref;
-        const manifestResource = resources.get(manifestRef);
-        if (!manifestResource)
-            invalid("fact_manifest_resource_unknown", `${target.key}:${manifestRef}`);
-        if (manifestResource.media_type !== "application/json")
-            invalid("fact_manifest_media_type_invalid", `${target.key}:${manifestResource.media_type}`);
-        if (manifestResource.role !== "supporting")
-            invalid("fact_manifest_supporting_role_required", `${target.key}:${manifestResource.role}`);
-        if (target.source_profile.entry_resource_ref === manifestRef)
-            invalid("fact_manifest_must_not_be_entry", target.key);
-        if (!target.source_profile.dependency_resource_refs.includes(manifestRef))
-            invalid("fact_manifest_dependency_required", target.key);
-        const manifest = parseDesignResourceFactManifestJson(contents.get(manifestRef).toString("utf8"));
-        if (manifests.has(manifest.target_key))
-            invalid("fact_manifest_target_duplicate", manifest.target_key);
-        if (manifest.target_key !== target.key ||
-            manifest.scope_key !== parsed.handoff.scope.key)
-            invalid("fact_manifest_identity_mismatch", `${target.key}:${manifest.scope_key}:${manifest.target_key}`);
-        manifests.set(target.key, manifest);
-    }
-    sameSet([...manifests.keys()], parsed.handoff.targets.map((target) => target.key), "fact_manifest_target_set_mismatch", "handoff");
-    return manifests;
-}
-export function validateDesignResourceFactManifests(parsed, contents, manifests, validateProjection) {
-    const resources = new Map(parsed.handoff.resources.map((resource) => [resource.key, resource]));
-    const sourceItems = new Map(Object.entries(parsed.source_item_kinds));
-    for (const target of parsed.handoff.targets) {
-        const manifest = manifests.get(target.key);
-        if (!manifest)
-            invalid("fact_manifest_target_missing", target.key);
-        validateDesignResourceFactManifestUniverse(manifest, parsed.handoff, target, resources, contents, sourceItems);
-        if (validateProjection)
-            validateManifestProjection(parsed.handoff, target.key, manifest);
-    }
-}
-function validateManifestProjection(handoff, targetKey, manifest) {
-    const target = handoff.targets.find((item) => item.key === targetKey);
-    const targetConditions = new Set(target.condition_refs);
-    const targetSubjects = new Set(handoff.subjects
-        .filter((subject) => subject.target_refs.includes(targetKey))
-        .map((subject) => subject.key));
-    const targetVariations = new Set(handoff.variations
-        .filter((variation) => targetSubjects.has(variation.subject_ref))
-        .map((variation) => variation.key));
-    const targetFacts = handoff.facts.filter((fact) => fact.target_ref === targetKey);
-    const targetFactRefs = new Set(targetFacts.map((fact) => fact.key));
-    const targetEvidenceRefs = new Set(targetFacts.flatMap((fact) => fact.evidence_refs));
-    const targetProof = handoff.proof_obligations.filter((proof) => targetFactRefs.has(proof.fact_ref));
-    const targetOracleRefs = new Set(targetProof.map((proof) => proof.oracle_ref));
-    const targetEnvironmentRefs = new Set(targetProof.map((proof) => proof.environment_ref));
-    exactRows(handoff.axis_dispositions.filter((row) => row.target_ref === targetKey), manifest.axis_dispositions, "axis_dispositions", targetKey);
-    exactRows(handoff.condition_exclusions.filter((row) => row.target_ref === targetKey), manifest.condition_exclusions, "condition_exclusions", targetKey);
-    exactRows(handoff.conditions.filter((row) => targetConditions.has(row.key)), manifest.conditions, "conditions", targetKey);
-    exactRows(handoff.subjects.filter((row) => targetSubjects.has(row.key)), manifest.subjects, "subjects", targetKey);
-    exactRows(handoff.variation_axis_dispositions.filter((row) => targetSubjects.has(row.subject_ref)), manifest.variation_axis_dispositions, "variation_axis_dispositions", targetKey);
-    exactRows(handoff.variation_exclusions.filter((row) => targetSubjects.has(row.subject_ref)), manifest.variation_exclusions, "variation_exclusions", targetKey);
-    exactRows(handoff.variations.filter((row) => targetVariations.has(row.key)), manifest.variations, "variations", targetKey);
-    exactRows(handoff.properties, manifest.properties, "properties", targetKey);
-    const targetLineageRefs = new Set(targetFacts.flatMap((fact) => [
-        ...fact.lineage.token_chain_refs,
-        ...fact.lineage.override_chain_refs,
-    ]));
-    exactRows(handoff.lineage_nodes.filter((row) => targetLineageRefs.has(row.key)), manifest.lineage_nodes, "lineage_nodes", targetKey);
-    exactRows(handoff.fact_cells.filter((row) => row.target_ref === targetKey), manifest.fact_cells, "fact_cells", targetKey);
-    exactRows(targetFacts, manifest.facts, "facts", targetKey);
-    exactRows(handoff.evidence.filter((row) => targetEvidenceRefs.has(row.key)), manifest.evidence, "evidence", targetKey);
-    exactRows(targetProof, manifest.proof_obligations, "proof_obligations", targetKey);
-    exactRows(handoff.oracles.filter((row) => targetOracleRefs.has(row.key)), manifest.oracles, "oracles", targetKey);
-    exactRows(handoff.environments.filter((row) => targetEnvironmentRefs.has(row.key)), manifest.environments, "environments", targetKey);
-    exactRows(handoff.asset_bindings.filter((row) => row.target_refs.includes(targetKey)), manifest.asset_bindings, "asset_bindings", targetKey);
-    exactRows(handoff.acceptance_blockers.filter((row) => row.target_refs.includes(targetKey)), manifest.acceptance_blockers, "acceptance_blockers", targetKey);
-}
-function exactRows(handoffRows, manifestRows, collection, targetKey) {
-    const handoff = new Map(handoffRows.map((row) => [row.key, row]));
-    if (handoff.size !== manifestRows.length)
-        invalid(`manifest_handoff_${collection}_set_mismatch`, `${targetKey}:count:${handoff.size}:${manifestRows.length}`);
-    for (const manifestRow of manifestRows) {
-        const handoffRow = handoff.get(manifestRow.key);
-        if (!handoffRow)
-            invalid(`manifest_handoff_${collection}_set_mismatch`, `${targetKey}:missing:${manifestRow.key}`);
-        if (canonicalJson(handoffRow) !== canonicalJson(manifestRow))
-            invalid(`manifest_handoff_${collection}_row_mismatch`, `${targetKey}:${manifestRow.key}`);
-    }
-}
-function canonicalJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
-    if (value && typeof value === "object")
-        return `{${Object.entries(value)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`)
-            .join(",")}}`;
-    return JSON.stringify(value);
-}
-function sameSet(actual, expected, code, detail) {
-    const left = [...new Set(actual)].sort();
-    const right = [...new Set(expected)].sort();
-    if (left.length !== right.length ||
-        left.some((item, index) => item !== right[index]))
-        invalid(code, `${detail}:${left.join(",")}:${right.join(",")}`);
-}
-function invalid(code, detail) {
-    invalidDesignResourceHandoff(code, detail);
-}

package/dist/lib/design-resource-fact-policy.d.ts

@@ -1,43 +0,0 @@
-import type { DesignResourceDimension, DesignResourceEvidenceKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
-import type { DesignResourceOracleCapability } from "./design-resource-fact-manifest-types.js";
-export declare const DESIGN_RESOURCE_FACT_INVARIANTS: Readonly<{
-    readonly complete_observable_design_fact_delivery: true;
-    readonly resource_fact_inventory_closure_required: true;
-    readonly exact_target_visual_pixel_required: true;
-    readonly exact_fact_set_conservation_required: true;
-    readonly design_fact_expression_boundary: true;
-    readonly unsupported_design_fact_blocks: true;
-    readonly control_granularity_is_not_design_fact_granularity: true;
-    readonly public_design_fact_guidance_required: true;
-    readonly design_fact_values_stay_in_canonical_resources: true;
-    readonly no_second_design_fact_authority: true;
-    readonly fact_inventory_required: true;
-    readonly contract_evidence_fact_binding_required: true;
-    readonly authoring_obligation_universe_precedes_generation: true;
-    readonly frozen_inspector_census_required: true;
-    readonly first_class_condition_variation_property_axes_required: true;
-    readonly atomic_fact_cell_identity_required: true;
-    readonly expected_canonical_handoff_fact_universe_equality_required: true;
-    readonly aggregate_state_or_condition_labels_forbidden: true;
-    readonly complete_generation_without_sampling_or_truncation_required: true;
-    readonly fact_identity_and_proof_method_obligation_separation_required: true;
-    readonly property_required_methods_cannot_be_weakened: true;
-    readonly design_system_effective_value_lineage_required: true;
-    readonly dynamic_relation_and_asset_fact_closure_required: true;
-    readonly per_fact_expected_comparison_authority_required: true;
-    readonly per_fact_current_result_required: true;
-    readonly protected_fact_observation_redaction_required: true;
-    readonly selected_design_fact_antidegradation_required: true;
-    readonly design_fact_distribution_context_cost: true;
-    readonly forbidden_design_fact_shortcuts_absent: true;
-    readonly preflight_is_not_production_conformance: true;
-    readonly unsupported_facts_block: true;
-    readonly control_relations_unchanged: true;
-}>;
-export declare const EXACT_TARGET_FULL_TARGET_METHODS: readonly ["layout_geometry", "visual_pixel"];
-export declare function assertDesignResourceFactPolicyEnabled(): void;
-export declare function designFactMethodIsCompatible(dimension: DesignResourceDimension, method: DesignResourceVerificationMethod): boolean;
-export declare function designFactEvidenceIsCompatible(dimension: DesignResourceDimension, kind: DesignResourceEvidenceKind): boolean;
-export declare function designFactEvidenceSupportsMethod(method: DesignResourceVerificationMethod, kind: DesignResourceEvidenceKind): boolean;
-export declare function designFactComparatorSupportsMethod(method: DesignResourceVerificationMethod, comparator: string): boolean;
-export declare function designFactOracleSupportsMethod(method: DesignResourceVerificationMethod, capabilities: readonly DesignResourceOracleCapability[]): boolean;

package/dist/lib/design-resource-fact-policy.js

@@ -1,106 +0,0 @@
-import { DESIGN_RESOURCE_EVIDENCE_BY_METHOD, DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION, DESIGN_RESOURCE_METHODS_BY_DIMENSION, } from "./design-resource-handoff-policy.js";
-export const DESIGN_RESOURCE_FACT_INVARIANTS = Object.freeze({
-    complete_observable_design_fact_delivery: true,
-    resource_fact_inventory_closure_required: true,
-    exact_target_visual_pixel_required: true,
-    exact_fact_set_conservation_required: true,
-    design_fact_expression_boundary: true,
-    unsupported_design_fact_blocks: true,
-    control_granularity_is_not_design_fact_granularity: true,
-    public_design_fact_guidance_required: true,
-    design_fact_values_stay_in_canonical_resources: true,
-    no_second_design_fact_authority: true,
-    fact_inventory_required: true,
-    contract_evidence_fact_binding_required: true,
-    authoring_obligation_universe_precedes_generation: true,
-    frozen_inspector_census_required: true,
-    first_class_condition_variation_property_axes_required: true,
-    atomic_fact_cell_identity_required: true,
-    expected_canonical_handoff_fact_universe_equality_required: true,
-    aggregate_state_or_condition_labels_forbidden: true,
-    complete_generation_without_sampling_or_truncation_required: true,
-    fact_identity_and_proof_method_obligation_separation_required: true,
-    property_required_methods_cannot_be_weakened: true,
-    design_system_effective_value_lineage_required: true,
-    dynamic_relation_and_asset_fact_closure_required: true,
-    per_fact_expected_comparison_authority_required: true,
-    per_fact_current_result_required: true,
-    protected_fact_observation_redaction_required: true,
-    selected_design_fact_antidegradation_required: true,
-    design_fact_distribution_context_cost: true,
-    forbidden_design_fact_shortcuts_absent: true,
-    preflight_is_not_production_conformance: true,
-    unsupported_facts_block: true,
-    control_relations_unchanged: true,
-});
-export const EXACT_TARGET_FULL_TARGET_METHODS = [
-    "layout_geometry",
-    "visual_pixel",
-];
-const STANDARD_COMPARATORS_BY_METHOD = {
-    layout_geometry: ["exact_value", "numeric_delta", "geometry_delta"],
-    visual_pixel: ["pixel_diff"],
-    design_token: ["token_resolution"],
-    content: ["exact_value", "content_equal"],
-    component_state: ["exact_value", "state_equal"],
-    interaction_trace: ["trace_equal", "state_equal"],
-    motion_timeline: ["timeline_equal", "trace_equal"],
-    responsive_reflow: ["reflow_equal", "geometry_delta"],
-    input_method: ["state_equal", "trace_equal"],
-    accessibility_semantics: ["semantic_equal", "state_equal"],
-    accessibility_navigation: ["semantic_equal", "trace_equal"],
-    accessibility_visual: ["pixel_diff", "semantic_equal"],
-    gesture_trace: ["trace_equal"],
-    scroll_navigation: ["trace_equal"],
-    localization: ["content_equal", "semantic_equal"],
-    system_ui: ["semantic_equal", "state_equal", "pixel_diff"],
-    haptic_feedback: ["timeline_equal", "trace_equal"],
-    sound_feedback: ["timeline_equal", "trace_equal"],
-    asset_integrity: ["asset_equal"],
-};
-const ORACLE_CAPABILITIES_BY_METHOD = {
-    layout_geometry: [
-        "geometry_measurement",
-        "component_anatomy",
-        "css_cascade",
-        "relations",
-    ],
-    visual_pixel: ["render_capture", "css_cascade", "html_dom", "system_ui"],
-    design_token: ["design_tokens"],
-    content: ["html_dom", "localization"],
-    component_state: ["component_anatomy", "prototype_transitions"],
-    interaction_trace: ["prototype_transitions", "input_rules"],
-    motion_timeline: ["motion", "prototype_transitions"],
-    responsive_reflow: ["responsive_rules", "geometry_measurement"],
-    input_method: ["input_rules"],
-    accessibility_semantics: ["accessibility"],
-    accessibility_navigation: ["accessibility", "input_rules"],
-    accessibility_visual: ["accessibility", "render_capture"],
-    gesture_trace: ["input_rules", "prototype_transitions"],
-    scroll_navigation: ["input_rules", "prototype_transitions"],
-    localization: ["localization"],
-    system_ui: ["system_ui"],
-    haptic_feedback: ["haptics"],
-    sound_feedback: ["audio"],
-    asset_integrity: ["assets"],
-};
-export function assertDesignResourceFactPolicyEnabled() {
-    if (Object.values(DESIGN_RESOURCE_FACT_INVARIANTS).some((enabled) => enabled !== true))
-        throw new Error("design_resource_fact_policy_disabled");
-}
-export function designFactMethodIsCompatible(dimension, method) {
-    return DESIGN_RESOURCE_METHODS_BY_DIMENSION[dimension].includes(method);
-}
-export function designFactEvidenceIsCompatible(dimension, kind) {
-    return DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION[dimension].includes(kind);
-}
-export function designFactEvidenceSupportsMethod(method, kind) {
-    return DESIGN_RESOURCE_EVIDENCE_BY_METHOD[method].includes(kind);
-}
-export function designFactComparatorSupportsMethod(method, comparator) {
-    return (comparator.startsWith("custom.") ||
-        STANDARD_COMPARATORS_BY_METHOD[method].includes(comparator));
-}
-export function designFactOracleSupportsMethod(method, capabilities) {
-    return ORACLE_CAPABILITIES_BY_METHOD[method].some((capability) => capabilities.includes(capability));
-}

package/dist/lib/design-resource-fact-property-methods.d.ts

@@ -1,3 +0,0 @@
-import type { DesignResourcePropertyFamily } from "./design-resource-fact-manifest-types.js";
-import type { DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
-export declare function designResourceRequiredMethods(key: string, family: DesignResourcePropertyFamily): DesignResourceVerificationMethod[];

package/dist/lib/design-resource-fact-property-methods.js

@@ -1,158 +0,0 @@
-const LAYOUT_PIXEL_KEYS = new Set([
-    "layout.transform",
-    "layout.transform-origin",
-    "layout.elevation",
-    "layout.clip",
-    "layout.mask",
-]);
-const CONTENT_LOCALIZATION_KEYS = new Set([
-    "content.date-format",
-    "content.time-format",
-    "content.number-format",
-    "content.unit-format",
-]);
-const CONTENT_REFLOW_KEYS = new Set([
-    "content.max-lines",
-    "content.truncation",
-    "content.wrapping",
-]);
-const CONTENT_STATE_KEYS = new Set([
-    "content.visibility",
-    "content.availability",
-    "content.population-identity",
-    "content.population-item-identity",
-    "content.population-cardinality",
-    "content.population-ordering",
-    "content.population-edge-cases",
-]);
-const GESTURE_KEYS = new Set([
-    "interaction.drag-threshold",
-    "interaction.drag-axis",
-    "interaction.drag-bounds",
-    "interaction.velocity-threshold",
-    "interaction.snap-points",
-    "interaction.long-press-threshold",
-    "interaction.double-tap-window",
-]);
-const INPUT_KEYS = new Set([
-    "interaction.input-type",
-    "interaction.return-action",
-    "interaction.autocorrect",
-    "interaction.autocapitalization",
-    "interaction.input-mask",
-    "interaction.secure-entry",
-    "interaction.clipboard",
-    "interaction.password-manager",
-    "interaction.keyboard-traversal",
-]);
-const ACCESSIBILITY_NAVIGATION_KEYS = new Set([
-    "accessibility.reading-order",
-    "accessibility.focus-order",
-    "accessibility.screen-reader",
-    "accessibility.switch-control",
-    "accessibility.voice-control",
-]);
-const ACCESSIBILITY_VISUAL_KEYS = new Set([
-    "accessibility.focus-visibility",
-    "accessibility.non-color-cue",
-    "accessibility.contrast",
-    "accessibility.text-scale-reflow",
-    "accessibility.preference-adaptation",
-]);
-export function designResourceRequiredMethods(key, family) {
-    const resolver = FAMILY_METHODS[family];
-    return resolver ? resolver(key) : ["visual_pixel"];
-}
-const FAMILY_METHODS = {
-    geometry: (key) => key === "geometry.pixel-snapping" ? ["visual_pixel"] : ["layout_geometry"],
-    layout: (key) => {
-        if (key === "layout.safe-area-insets")
-            return ["layout_geometry", "responsive_reflow"];
-        return LAYOUT_PIXEL_KEYS.has(key)
-            ? ["layout_geometry", "visual_pixel"]
-            : ["layout_geometry"];
-    },
-    scroll: (key) => {
-        if (key === "scroll.indicator")
-            return ["visual_pixel"];
-        return key === "scroll.content-inset"
-            ? ["responsive_reflow", "scroll_navigation"]
-            : ["scroll_navigation"];
-    },
-    typography: (key) => new Set([
-        "typography.numeral-style",
-        "typography.hyphenation",
-        "typography.formatting",
-    ]).has(key)
-        ? ["visual_pixel", "content"]
-        : ["layout_geometry", "visual_pixel"],
-    color: () => ["visual_pixel"],
-    decoration: () => ["visual_pixel"],
-    content: contentMethods,
-    icon: (key) => new Set(["icon.position", "icon.text-gap"]).has(key)
-        ? ["layout_geometry"]
-        : ["visual_pixel"],
-    media: () => ["asset_integrity"],
-    asset: () => ["asset_integrity"],
-    interaction: interactionMethods,
-    navigation: () => ["interaction_trace"],
-    motion: () => ["motion_timeline"],
-    feedback: feedbackMethods,
-    responsive: () => ["responsive_reflow"],
-    accessibility: accessibilityMethods,
-    system: systemMethods,
-    relation: relationMethods,
-};
-function contentMethods(key) {
-    if (CONTENT_LOCALIZATION_KEYS.has(key))
-        return ["content", "localization"];
-    if (CONTENT_REFLOW_KEYS.has(key))
-        return ["content", "responsive_reflow"];
-    if (key === "content.virtualization-window")
-        return ["responsive_reflow"];
-    if (key === "content.layout-impact")
-        return ["component_state", "layout_geometry"];
-    return CONTENT_STATE_KEYS.has(key) ? ["component_state"] : ["content"];
-}
-function interactionMethods(key) {
-    if (GESTURE_KEYS.has(key))
-        return ["gesture_trace"];
-    if (INPUT_KEYS.has(key))
-        return ["input_method"];
-    return key === "interaction.trigger"
-        ? ["component_state", "interaction_trace"]
-        : ["interaction_trace"];
-}
-function feedbackMethods(key) {
-    if (key === "feedback.spoken")
-        return ["accessibility_semantics"];
-    if (key === "feedback.sound-type-time")
-        return ["sound_feedback"];
-    if (key === "feedback.haptic-type-time")
-        return ["haptic_feedback"];
-    return ["component_state"];
-}
-function accessibilityMethods(key) {
-    if (ACCESSIBILITY_NAVIGATION_KEYS.has(key))
-        return ["accessibility_navigation"];
-    return ACCESSIBILITY_VISUAL_KEYS.has(key)
-        ? ["accessibility_visual"]
-        : ["accessibility_semantics"];
-}
-function systemMethods(key) {
-    if (new Set(["system.font-rasterization", "system.render-environment"]).has(key))
-        return ["visual_pixel"];
-    return key === "system.keyboard-ime-avoidance"
-        ? ["input_method"]
-        : ["system_ui"];
-}
-function relationMethods(key) {
-    if (key === "relation.synchronized-state-motion")
-        return ["interaction_trace"];
-    return new Set([
-        "relation.family-instance-consistency",
-        "relation.cross-surface-consistency",
-    ]).has(key)
-        ? ["component_state"]
-        : ["layout_geometry"];
-}

package/dist/lib/design-resource-fact-shape-primitives.d.ts

@@ -1,3 +0,0 @@
-import type { DesignResourceLocatedDigestV1, DesignResourceTypedLocatorV1 } from "./design-resource-fact-manifest-types.js";
-export declare function parseDesignResourceTypedLocator(value: unknown, label: string): DesignResourceTypedLocatorV1;
-export declare function parseDesignResourceLocatedDigest(value: unknown, label: string): DesignResourceLocatedDigestV1;

package/dist/lib/design-resource-fact-shape-primitives.js

@@ -1,18 +0,0 @@
-import { DESIGN_RESOURCE_LOCATOR_KINDS } from "./design-resource-handoff-types.js";
-import { sha256, stableKey, } from "./design-resource-handoff-shape-primitives.js";
-import { literal, object, string } from "./long-task-shape-primitives.js";
-export function parseDesignResourceTypedLocator(value, label) {
-    const row = object(value, label, ["resource_ref", "kind", "value"]);
-    return {
-        resource_ref: stableKey(row.resource_ref, `${label}.resource_ref`),
-        kind: literal(row.kind, DESIGN_RESOURCE_LOCATOR_KINDS, `${label}.kind`),
-        value: string(row.value, `${label}.value`),
-    };
-}
-export function parseDesignResourceLocatedDigest(value, label) {
-    const row = object(value, label, ["locator", "sha256"]);
-    return {
-        locator: parseDesignResourceTypedLocator(row.locator, `${label}.locator`),
-        sha256: sha256(row.sha256, `${label}.sha256`),
-    };
-}

package/dist/lib/design-resource-fact-types.d.ts

@@ -1,164 +0,0 @@
-import type { DesignResourceCoverageDisposition, DesignResourceDimension, DesignResourceLocatorKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
-import type { DesignResourceComparator, DesignResourceInspectorCapability, DesignResourceLineageNodeKind, DesignResourceOracleCapability, DesignResourcePropertyFamily, DesignResourceStandardConditionAxis, DesignResourceSubjectKind, DesignResourceSubjectPresenceKind, DesignResourceValueKind, DesignResourceVariationAxis } from "./design-resource-fact-enums.js";
-export interface DesignResourceTypedLocatorV1 {
-    resource_ref: string;
-    kind: DesignResourceLocatorKind;
-    value: string;
-}
-export interface DesignResourceLocatedDigestV1 {
-    locator: DesignResourceTypedLocatorV1;
-    sha256: string;
-}
-export interface DesignResourceAxisValueV1 {
-    key: string;
-    census_refs: string[];
-}
-export interface DesignResourceAxisDispositionV1 {
-    key: string;
-    target_ref: string;
-    axis: DesignResourceStandardConditionAxis | string;
-    disposition: "applicable" | "not_applicable";
-    values: DesignResourceAxisValueV1[];
-    source_item_refs: string[];
-    basis_refs: string[];
-    rationale: string;
-}
-export interface DesignResourceConditionCombinationDispositionV1 {
-    key: string;
-    target_ref: string;
-    axis_values: Array<{
-        axis_ref: string;
-        value_ref: string;
-    }>;
-    disposition: Exclude<DesignResourceCoverageDisposition, "covered">;
-    source_item_refs: string[];
-    basis_refs: string[];
-    rationale: string;
-}
-export interface DesignResourceVariationAxisDispositionV1 {
-    key: string;
-    subject_ref: string;
-    axis: DesignResourceVariationAxis;
-    disposition: "applicable" | "not_applicable";
-    values: DesignResourceAxisValueV1[];
-    source_item_refs: string[];
-    basis_refs: string[];
-    rationale: string;
-}
-export interface DesignResourceVariationCombinationDispositionV1 {
-    key: string;
-    subject_ref: string;
-    axis_values: Array<{
-        axis_ref: DesignResourceVariationAxis;
-        value_ref: string;
-    }>;
-    disposition: Exclude<DesignResourceCoverageDisposition, "covered">;
-    source_item_refs: string[];
-    basis_refs: string[];
-    rationale: string;
-}
-export interface DesignResourceSubjectVariationV1 {
-    key: string;
-    subject_ref: string;
-    variant: string;
-    state: string;
-    interaction_phase: string;
-    presence_phase: string;
-    instance_case: string;
-}
-export interface DesignResourceRelationEndpointV1 {
-    role: string;
-    subject_ref: string;
-}
-export interface DesignResourcePropertyDefinitionV1 {
-    key: string;
-    family: DesignResourcePropertyFamily;
-    dimension: DesignResourceDimension;
-    value_kind: DesignResourceValueKind;
-    required_methods: DesignResourceVerificationMethod[];
-    standard: boolean;
-    inspector_capability_refs: DesignResourceInspectorCapability[];
-    census_refs: string[];
-}
-export interface DesignResourceFactCellV1 {
-    key: string;
-    subject_ref: string;
-    target_ref: string;
-    condition_ref: string;
-    variation_ref: string;
-    property_ref: string;
-    disposition: DesignResourceCoverageDisposition;
-    fact_ref: string | null;
-    source_item_refs: string[];
-    basis_refs: string[];
-    rationale: string;
-}
-export interface DesignResourceFactLineageV1 {
-    design_system_ref: string | null;
-    token_chain_refs: string[];
-    override_chain_refs: string[];
-    resolved_value: DesignResourceLocatedDigestV1;
-    conflict_status: "none" | "resolved";
-    conflict_resolution: string;
-}
-export interface DesignResourceLineageNodeV1 {
-    key: string;
-    kind: DesignResourceLineageNodeKind;
-    predecessor_refs: string[];
-    value: DesignResourceLocatedDigestV1;
-    census_refs: string[];
-}
-export interface DesignResourceFactV1 {
-    key: string;
-    cell_ref: string;
-    subject_ref: string;
-    target_ref: string;
-    condition_ref: string;
-    variation_ref: string;
-    property_ref: string;
-    dimension: DesignResourceDimension;
-    observation_scope: "subject" | "full_target";
-    observation_sensitivity: "plain" | "protected";
-    value_kind: DesignResourceValueKind;
-    value: DesignResourceLocatedDigestV1;
-    evidence_refs: string[];
-    source_item_refs: string[];
-    lineage: DesignResourceFactLineageV1;
-}
-export interface DesignResourceOracleV1 {
-    key: string;
-    trust: "frozen_executable" | "named_external_tcb";
-    identity: string;
-    version: string;
-    sha256: string | null;
-    capability_refs: DesignResourceOracleCapability[];
-}
-export interface DesignResourceEnvironmentV1 {
-    key: string;
-    identity: string;
-    definition: DesignResourceLocatedDigestV1;
-}
-export interface DesignResourceProofObligationV1 {
-    key: string;
-    fact_ref: string;
-    method: DesignResourceVerificationMethod;
-    comparison: {
-        comparator: DesignResourceComparator | string;
-        mode: "exact" | "tolerance";
-        parameters: DesignResourceLocatedDigestV1;
-        tolerance: DesignResourceLocatedDigestV1 | null;
-        mask: DesignResourceLocatedDigestV1 | null;
-    };
-    oracle_ref: string;
-    environment_ref: string;
-}
-export interface DesignResourceAssetBindingV1 {
-    key: string;
-    asset_subject_ref: string;
-    resource_ref: string;
-    target_refs: string[];
-    condition_refs: string[];
-    fact_refs: string[];
-    consumer_subject_refs: string[];
-}
-export type { DesignResourceSubjectKind, DesignResourceSubjectPresenceKind };

package/dist/lib/design-resource-fact-universe-assets.d.ts

@@ -1,4 +0,0 @@
-import { type DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
-import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
-export declare function validateManifestAssets(manifest: DesignResourceObservableFactManifestV1, resources: Map<string, DesignResource>): void;
-export declare function validateManifestGeneration(manifest: DesignResourceObservableFactManifestV1): void;