project-tiny-context-harness 0.8.4 → 0.8.6

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

@@ -1,4 +1,4 @@
-import { DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION, DESIGN_RESOURCE_METHODS_BY_DIMENSION, } from "./design-resource-handoff-policy.js";
+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,
@@ -12,6 +12,20 @@ export const DESIGN_RESOURCE_FACT_INVARIANTS = Object.freeze({
     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,
@@ -23,6 +37,53 @@ 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");
@@ -33,3 +94,13 @@ export function designFactMethodIsCompatible(dimension, 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

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

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

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

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

@@ -0,0 +1,164 @@
+import type { DesignResourceCoverageDisposition, DesignResourceDimension, DesignResourceLocatorKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
+import type { DesignResourceComparator, DesignResourceInspectorCapability, DesignResourceLineageNodeKind, 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: DesignResourceInspectorCapability[];
+}
+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-types.js

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

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

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

package/dist/lib/design-resource-fact-universe-assets.js

@@ -0,0 +1,71 @@
+import { DESIGN_RESOURCE_MANIFEST_COLLECTIONS, } from "./design-resource-fact-manifest-types.js";
+import { invalid, manifestCollectionRows, manifestIdentityDigest, nonempty, refsKnown, sameSet, unique, } from "./design-resource-fact-universe-helpers.js";
+export function validateManifestAssets(manifest, resources) {
+    const subjects = new Map(manifest.subjects.map((subject) => [subject.key, subject]));
+    const assetSubjects = manifest.subjects.filter((subject) => subject.kind === "asset");
+    const bound = new Set();
+    for (const binding of manifest.asset_bindings) {
+        validateAssetBinding(binding, manifest, subjects, resources);
+        if (bound.has(binding.asset_subject_ref))
+            invalid("manifest_asset_subject_binding_duplicate", binding.asset_subject_ref);
+        bound.add(binding.asset_subject_ref);
+    }
+    for (const subject of assetSubjects)
+        if (!bound.has(subject.key))
+            invalid("manifest_asset_subject_binding_missing", subject.key);
+}
+function validateAssetBinding(binding, manifest, subjects, resources) {
+    const subject = subjects.get(binding.asset_subject_ref);
+    if (!subject || subject.kind !== "asset")
+        invalid("manifest_asset_binding_subject_invalid", binding.key);
+    if (!resources.has(binding.resource_ref))
+        invalid("manifest_asset_binding_resource_unknown", binding.key);
+    for (const [name, refs] of [
+        ["target", binding.target_refs],
+        ["condition", binding.condition_refs],
+        ["fact", binding.fact_refs],
+        ["consumer", binding.consumer_subject_refs],
+    ]) {
+        nonempty(refs, `manifest_asset_binding_${name}s_required:${binding.key}`);
+        unique(refs, `manifest_asset_binding_${name}_duplicate:${binding.key}`);
+    }
+    refsKnown(binding.target_refs, new Map([[manifest.target_key, true]]), "manifest_asset_binding_target_unknown", binding.key);
+    const assetFacts = manifest.facts.filter((fact) => fact.subject_ref === binding.asset_subject_ref);
+    sameSet(binding.fact_refs, assetFacts.map((fact) => fact.key), "manifest_asset_binding_fact_set_mismatch", binding.key);
+    sameSet(binding.condition_refs, [...new Set(assetFacts.map((fact) => fact.condition_ref))], "manifest_asset_binding_condition_set_mismatch", binding.key);
+    sameSet(binding.target_refs, subject.target_refs, "manifest_asset_binding_target_set_mismatch", binding.key);
+    validateAssetFacts(binding, manifest, assetFacts);
+    refsKnown(binding.condition_refs, new Map(manifest.conditions.map((item) => [item.key, item])), "manifest_asset_binding_condition_unknown", binding.key);
+    refsKnown(binding.fact_refs, new Map(manifest.facts.map((item) => [item.key, item])), "manifest_asset_binding_fact_unknown", binding.key);
+    refsKnown(binding.consumer_subject_refs, subjects, "manifest_asset_binding_consumer_unknown", binding.key);
+}
+function validateAssetFacts(binding, manifest, facts) {
+    for (const fact of facts) {
+        if (fact.dimension !== "assets")
+            invalid("manifest_asset_fact_dimension_invalid", `${binding.key}:${fact.key}:${fact.dimension}`);
+        const resourceBound = fact.value.locator.resource_ref === binding.resource_ref ||
+            fact.lineage.resolved_value.locator.resource_ref ===
+                binding.resource_ref ||
+            fact.evidence_refs.some((ref) => manifest.evidence.find((item) => item.key === ref)?.resource_ref ===
+                binding.resource_ref);
+        if (!resourceBound)
+            invalid("manifest_asset_binding_resource_unattributed", `${binding.key}:${fact.key}:${binding.resource_ref}`);
+    }
+}
+export function validateManifestGeneration(manifest) {
+    const generation = manifest.generation;
+    if (generation.chunk_indexes.length !== generation.chunk_count ||
+        generation.chunk_indexes.some((value, index) => value !== index))
+        invalid("manifest_generation_chunk_closure_mismatch", manifest.target_key);
+    unique(generation.collections.map((item) => item.name), "manifest_generation_collection_duplicate");
+    sameSet(generation.collections.map((item) => item.name), [...DESIGN_RESOURCE_MANIFEST_COLLECTIONS], "manifest_generation_collection_set_mismatch", manifest.target_key);
+    const rowsByCollection = manifestCollectionRows(manifest);
+    for (const declaration of generation.collections) {
+        const rows = rowsByCollection.get(declaration.name);
+        if (rows.length !== declaration.expected_count)
+            invalid("manifest_generation_count_mismatch", `${declaration.name}:${rows.length}:${declaration.expected_count}`);
+        const actual = manifestIdentityDigest(rows);
+        if (actual !== declaration.identity_sha256)
+            invalid("manifest_generation_identity_mismatch", `${declaration.name}:${declaration.identity_sha256}:${actual}`);
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
+export declare function validateManifestPropertyCatalog(manifest: DesignResourceObservableFactManifestV1, census: Map<string, DesignResourceObservableFactManifestV1["inspector"]["census"][number]>): void;
+export declare function validateManifestCensusOwnership(manifest: DesignResourceObservableFactManifestV1): void;
+export declare function validateManifestFactCells(manifest: DesignResourceObservableFactManifestV1, sourceItems: Map<string, string>, census: Map<string, DesignResourceObservableFactManifestV1["inspector"]["census"][number]>): void;