project-tiny-context-harness 0.8.4 → 0.8.6

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

@@ -0,0 +1,151 @@
+import { DESIGN_RESOURCE_STANDARD_PROPERTIES, DESIGN_RESOURCE_STANDARD_PROPERTY_BY_KEY, } from "./design-resource-fact-manifest-catalog.js";
+import { designFactMethodIsCompatible } from "./design-resource-fact-policy.js";
+import { factCellFingerprint, invalid, nonempty, refsKnown, sameSet, sameSetValue, unique, validateBasis, } from "./design-resource-fact-universe-helpers.js";
+export function validateManifestPropertyCatalog(manifest, census) {
+    const properties = new Map(manifest.properties.map((property) => [property.key, property]));
+    for (const standard of DESIGN_RESOURCE_STANDARD_PROPERTIES) {
+        const actual = properties.get(standard.key);
+        if (!actual)
+            invalid("manifest_standard_property_missing", standard.key);
+        if (!actual.standard ||
+            actual.family !== standard.family ||
+            actual.dimension !== standard.dimension ||
+            actual.value_kind !== standard.value_kind ||
+            !sameSetValue(actual.required_methods, standard.required_methods) ||
+            !sameSetValue(actual.inspector_capability_refs, standard.inspector_capability_refs))
+            invalid("manifest_standard_property_definition_mismatch", standard.key);
+    }
+    for (const property of manifest.properties)
+        validateProperty(property, manifest, census);
+}
+function validateProperty(property, manifest, census) {
+    unique(property.required_methods, `manifest_property_required_method_duplicate:${property.key}`);
+    nonempty(property.required_methods, `manifest_property_required_method_required:${property.key}`);
+    for (const method of property.required_methods)
+        if (!designFactMethodIsCompatible(property.dimension, method))
+            invalid("manifest_property_required_method_incompatible", `${property.key}:${property.dimension}:${method}`);
+    unique(property.inspector_capability_refs, `manifest_property_capability_duplicate:${property.key}`);
+    nonempty(property.inspector_capability_refs, `manifest_property_capability_required:${property.key}`);
+    for (const capability of property.inspector_capability_refs)
+        if (!manifest.inspector.capability_refs.includes(capability))
+            invalid("manifest_inspector_property_capability_missing", `${property.key}:${capability}`);
+    if (property.standard) {
+        if (!DESIGN_RESOURCE_STANDARD_PROPERTY_BY_KEY.has(property.key))
+            invalid("manifest_unknown_standard_property", property.key);
+    }
+    else {
+        if (!property.key.startsWith("custom."))
+            invalid("manifest_custom_property_namespace_required", property.key);
+        nonempty(property.census_refs, `manifest_custom_property_census_required:${property.key}`);
+    }
+    refsKnown(property.census_refs, census, "manifest_property_census_unknown", property.key);
+}
+export function validateManifestCensusOwnership(manifest) {
+    const ownership = censusOwnershipSets(manifest);
+    for (const entry of manifest.inspector.census) {
+        if (entry.disposition !== "covered")
+            continue;
+        if (!censusEntryHasOwner(entry, ownership))
+            invalid("manifest_census_semantic_owner_missing", `${entry.key}:${entry.kind}`);
+    }
+}
+function censusOwnershipSets(manifest) {
+    return {
+        inspectorInputs: new Set(manifest.inspector.input_resources.map((item) => item.resource_ref)),
+        subject: new Set(manifest.subjects.flatMap((subject) => subject.census_refs)),
+        condition: new Set(manifest.axis_dispositions.flatMap((axis) => axis.values.flatMap((value) => value.census_refs))),
+        variation: new Set(manifest.variation_axis_dispositions.flatMap((axis) => axis.values.flatMap((value) => value.census_refs))),
+        property: new Set(manifest.properties.flatMap((property) => property.census_refs)),
+        lineage: new Set(manifest.lineage_nodes.flatMap((node) => node.census_refs)),
+        dynamic: new Set(manifest.subjects.flatMap((subject) => [subject.presence_rule_ref, subject.population_ref].filter((ref) => ref !== null))),
+    };
+}
+function censusEntryHasOwner(entry, sets) {
+    if (entry.kind === "resource")
+        return sets.inspectorInputs.has(entry.resource_ref);
+    if (entry.kind === "node")
+        return sets.subject.has(entry.key);
+    if (entry.kind === "declaration")
+        return [
+            sets.condition,
+            sets.variation,
+            sets.property,
+            sets.lineage,
+            sets.dynamic,
+        ].some((set) => set.has(entry.key));
+    if (entry.kind === "variant" ||
+        entry.kind === "state" ||
+        entry.kind === "interaction_phase")
+        return sets.variation.has(entry.key) || sets.dynamic.has(entry.key);
+    if (entry.kind === "token")
+        return sets.lineage.has(entry.key);
+    if (entry.kind === "custom_property")
+        return sets.property.has(entry.key) || sets.lineage.has(entry.key);
+    if (entry.kind === "asset_reference" || entry.kind === "relation")
+        return sets.subject.has(entry.key) || sets.property.has(entry.key);
+    return entry.kind === "dynamic_population" && sets.dynamic.has(entry.key);
+}
+export function validateManifestFactCells(manifest, sourceItems, census) {
+    const subjects = new Map(manifest.subjects.map((subject) => [subject.key, subject]));
+    const conditions = new Set(manifest.conditions.map((item) => item.key));
+    const variations = new Map(manifest.variations.map((item) => [item.key, item]));
+    const properties = new Set(manifest.properties.map((item) => item.key));
+    const actual = new Map();
+    const coveredFacts = [];
+    for (const cell of manifest.fact_cells) {
+        validateFactCellReferences(cell, manifest, subjects, conditions, variations, properties);
+        validateBasis(cell, sourceItems, census, `manifest_fact_cell:${cell.key}`);
+        const fingerprint = factCellFingerprint(cell);
+        if (actual.has(fingerprint))
+            invalid("manifest_fact_cell_duplicate", `${actual.get(fingerprint)}:${cell.key}`);
+        actual.set(fingerprint, cell.key);
+        validateFactCellDisposition(cell, coveredFacts);
+    }
+    sameSet([...actual.keys()], expectedFactCellFingerprints(manifest), "manifest_expected_fact_cell_universe_mismatch", manifest.target_key);
+    unique(coveredFacts, "manifest_fact_ref_reused_by_cells");
+    sameSet(coveredFacts, manifest.facts.map((fact) => fact.key), "manifest_expected_canonical_fact_set_mismatch", manifest.target_key);
+}
+function validateFactCellReferences(cell, manifest, subjects, conditions, variations, properties) {
+    const subject = subjects.get(cell.subject_ref);
+    const variation = variations.get(cell.variation_ref);
+    if (!subject)
+        invalid("manifest_fact_cell_subject_unknown", cell.key);
+    if (!subject.target_refs.includes(cell.target_ref))
+        invalid("manifest_fact_cell_target_outside_subject", cell.key);
+    if (cell.target_ref !== manifest.target_key)
+        invalid("manifest_fact_cell_target_mismatch", cell.key);
+    if (!conditions.has(cell.condition_ref))
+        invalid("manifest_fact_cell_condition_unknown", cell.key);
+    if (!variation || variation.subject_ref !== cell.subject_ref)
+        invalid("manifest_fact_cell_variation_mismatch", cell.key);
+    if (!properties.has(cell.property_ref))
+        invalid("manifest_fact_cell_property_unknown", cell.key);
+}
+function validateFactCellDisposition(cell, coveredFacts) {
+    if (cell.disposition === "covered") {
+        if (cell.fact_ref === null)
+            invalid("manifest_covered_fact_ref_required", cell.key);
+        coveredFacts.push(cell.fact_ref);
+        return;
+    }
+    if (cell.fact_ref !== null)
+        invalid("manifest_noncovered_fact_ref_forbidden", cell.key);
+    if (cell.disposition === "decision_required" ||
+        cell.disposition === "unavailable")
+        invalid("manifest_fact_cell_unresolved", cell.key);
+}
+function expectedFactCellFingerprints(manifest) {
+    const expected = [];
+    for (const subject of manifest.subjects)
+        for (const condition of manifest.conditions)
+            for (const variation of manifest.variations.filter((item) => item.subject_ref === subject.key))
+                for (const property of manifest.properties)
+                    expected.push(factCellFingerprint({
+                        subject_ref: subject.key,
+                        target_ref: manifest.target_key,
+                        condition_ref: condition.key,
+                        variation_ref: variation.key,
+                        property_ref: property.key,
+                    }));
+    return expected;
+}

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

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

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

@@ -0,0 +1,92 @@
+import { DESIGN_RESOURCE_STANDARD_CONDITION_AXES, } from "./design-resource-fact-manifest-types.js";
+import { axisFingerprint, cartesian, conditionAxisValue, exactAxisPairs, invalid, nonempty, refsKnown, sameSet, unique, validateBasis, } from "./design-resource-fact-universe-helpers.js";
+export function validateManifestConditionUniverse(manifest, census, sourceItems) {
+    const axes = manifest.axis_dispositions;
+    const byAxis = new Map(axes.map((axis) => [axis.axis, axis]));
+    for (const axis of DESIGN_RESOURCE_STANDARD_CONDITION_AXES)
+        if (!byAxis.has(axis))
+            invalid("manifest_standard_axis_missing", axis);
+    unique(axes.map((axis) => axis.axis), "manifest_axis_duplicate");
+    for (const axis of axes)
+        validateAxis(axis, manifest, census, sourceItems);
+    const fingerprints = validateConditions(manifest, axes, byAxis);
+    const excluded = validateConditionExclusions(manifest, axes, byAxis, fingerprints, census, sourceItems);
+    const expected = cartesian(axes.map((axis) => axis.values.map((value) => [axis.axis, value.key]))).map(axisFingerprint);
+    sameSet([...fingerprints.keys(), ...excluded.keys()], expected, "manifest_condition_universe_mismatch", manifest.target_key);
+}
+function validateAxis(axis, manifest, census, sourceItems) {
+    if (axis.target_ref !== manifest.target_key)
+        invalid("manifest_axis_target_mismatch", `${axis.key}:${axis.target_ref}:${manifest.target_key}`);
+    validateBasis(axis, sourceItems, census, `manifest_axis:${axis.key}`);
+    nonempty(axis.values, `manifest_axis_values_required:${axis.key}`);
+    unique(axis.values.map((value) => value.key), `manifest_axis_value_duplicate:${axis.key}`);
+    if (axis.disposition === "not_applicable" &&
+        (axis.values.length !== 1 || axis.values[0].key !== "not-applicable"))
+        invalid("manifest_axis_not_applicable_value_invalid", axis.key);
+    if (axis.disposition === "applicable" &&
+        axis.values.some((value) => value.key === "not-applicable"))
+        invalid("manifest_axis_applicable_value_invalid", axis.key);
+    for (const value of axis.values) {
+        if (axis.disposition === "applicable")
+            nonempty(value.census_refs, `manifest_axis_value_census_required:${axis.key}:${value.key}`);
+        refsKnown(value.census_refs, census, "manifest_axis_value_census_unknown", `${axis.key}:${value.key}`);
+    }
+}
+function validateConditions(manifest, axes, byAxis) {
+    const fingerprints = new Map();
+    const profileByAxisValue = new Map();
+    for (const condition of manifest.conditions) {
+        const values = axes.map((axis) => [axis.axis, conditionAxisValue(condition, axis.axis)]);
+        for (const [axis, value] of values)
+            if (!byAxis.get(axis).values.some((candidate) => candidate.key === value))
+                invalid("manifest_condition_axis_value_unknown", `${condition.key}:${axis}:${value}`);
+        const fingerprint = axisFingerprint(values);
+        if (fingerprints.has(fingerprint))
+            invalid("manifest_condition_combination_duplicate", `${fingerprints.get(fingerprint)}:${condition.key}`);
+        fingerprints.set(fingerprint, condition.key);
+        validateConditionProfiles(condition, profileByAxisValue);
+    }
+    return fingerprints;
+}
+function validateConditionProfiles(condition, profileByAxisValue) {
+    for (const [key, profile] of [
+        [
+            `viewport:${condition.viewport.key}`,
+            `${condition.viewport.width}:${condition.viewport.height}:${condition.viewport.unit}`,
+        ],
+        [`density:${condition.density.key}`, String(condition.density.pixel_ratio)],
+        [
+            `safe_area:${condition.safe_area.key}`,
+            `${condition.safe_area.top}:${condition.safe_area.right}:${condition.safe_area.bottom}:${condition.safe_area.left}:${condition.safe_area.unit}`,
+        ],
+        [
+            `text_scale:${condition.text_scale.key}`,
+            String(condition.text_scale.multiplier),
+        ],
+    ]) {
+        const previous = profileByAxisValue.get(key);
+        if (previous !== undefined && previous !== profile)
+            invalid("manifest_condition_profile_ambiguous", `${key}:${previous}:${profile}`);
+        profileByAxisValue.set(key, profile);
+    }
+}
+function validateConditionExclusions(manifest, axes, byAxis, fingerprints, census, sourceItems) {
+    const excluded = new Map();
+    for (const row of manifest.condition_exclusions) {
+        if (row.target_ref !== manifest.target_key)
+            invalid("manifest_condition_exclusion_target_mismatch", row.key);
+        validateBasis(row, sourceItems, census, `manifest_condition_exclusion:${row.key}`);
+        if (row.disposition === "decision_required" ||
+            row.disposition === "unavailable")
+            invalid("manifest_condition_exclusion_unresolved", row.key);
+        const values = exactAxisPairs(row.axis_values, axes.map((axis) => axis.axis), `manifest_condition_exclusion:${row.key}`);
+        for (const [axis, value] of values)
+            if (!byAxis.get(axis).values.some((candidate) => candidate.key === value))
+                invalid("manifest_condition_exclusion_value_unknown", `${row.key}:${axis}:${value}`);
+        const fingerprint = axisFingerprint(values);
+        if (fingerprints.has(fingerprint) || excluded.has(fingerprint))
+            invalid("manifest_condition_exclusion_duplicate", row.key);
+        excluded.set(fingerprint, row.key);
+    }
+    return excluded;
+}

package/dist/lib/design-resource-fact-universe-facts.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";
+import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function validateManifestFacts(manifest: DesignResourceObservableFactManifestV1, handoff: DesignResourceHandoffV1, resources: Map<string, DesignResource>, contents: Map<string, Buffer>, sourceItems: Map<string, string>): void;

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

@@ -0,0 +1,108 @@
+import { validateDesignResourceLocatedDigest, validateDesignResourceValueKind, } from "./design-resource-fact-locator-validation.js";
+import { invalid, nonempty, refsKnown, stableJson, unique, } from "./design-resource-fact-universe-helpers.js";
+export function validateManifestFacts(manifest, handoff, resources, contents, sourceItems) {
+    const cells = new Map(manifest.fact_cells.map((cell) => [cell.key, cell]));
+    const properties = new Map(manifest.properties.map((property) => [property.key, property]));
+    const evidence = new Map(manifest.evidence.map((item) => [item.key, item]));
+    const lineageNodes = new Map(manifest.lineage_nodes.map((item) => [item.key, item]));
+    for (const fact of manifest.facts) {
+        const property = validateFactIdentity(fact, cells, properties);
+        validateFactSourceAndEvidence(fact, evidence, sourceItems);
+        validateFactValue(fact, resources, contents);
+        validateFactLineage(fact, property.family, manifest, handoff, lineageNodes);
+    }
+}
+function validateFactIdentity(fact, cells, properties) {
+    const cell = cells.get(fact.cell_ref);
+    const property = properties.get(fact.property_ref);
+    if (!cell ||
+        cell.fact_ref !== fact.key ||
+        cell.subject_ref !== fact.subject_ref ||
+        cell.target_ref !== fact.target_ref ||
+        cell.condition_ref !== fact.condition_ref ||
+        cell.variation_ref !== fact.variation_ref ||
+        cell.property_ref !== fact.property_ref)
+        invalid("manifest_fact_cell_mismatch", fact.key);
+    if (!property ||
+        property.dimension !== fact.dimension ||
+        property.value_kind !== fact.value_kind)
+        invalid("manifest_fact_property_mismatch", fact.key);
+    return property;
+}
+function validateFactSourceAndEvidence(fact, evidence, sourceItems) {
+    nonempty(fact.evidence_refs, `manifest_fact_evidence_required:${fact.key}`);
+    nonempty(fact.source_item_refs, `manifest_fact_source_item_required:${fact.key}`);
+    unique(fact.evidence_refs, `manifest_fact_evidence_duplicate:${fact.key}`);
+    refsKnown(fact.evidence_refs, evidence, "manifest_fact_evidence_unknown", fact.key);
+    refsKnown(fact.source_item_refs, sourceItems, "manifest_fact_source_item_unknown", fact.key);
+}
+function validateFactValue(fact, resources, contents) {
+    const resolvedFactValue = validateDesignResourceLocatedDigest(fact.value, resources, contents, `manifest.fact.${fact.key}.value`);
+    validateDesignResourceValueKind(fact.value_kind, resolvedFactValue, `manifest.fact.${fact.key}.value`);
+    validateDesignResourceLocatedDigest(fact.lineage.resolved_value, resources, contents, `manifest.fact.${fact.key}.lineage.resolved_value`);
+    if (fact.value.sha256 !== fact.lineage.resolved_value.sha256 ||
+        stableJson(fact.value.locator) !==
+            stableJson(fact.lineage.resolved_value.locator))
+        invalid("manifest_fact_resolved_value_mismatch", fact.key);
+}
+function validateFactLineage(fact, family, manifest, handoff, nodes) {
+    if (handoff.scope.style_dependency !== "non-fidelity" &&
+        ["typography", "color", "decoration", "icon"].includes(family) &&
+        fact.lineage.design_system_ref === null)
+        invalid("manifest_style_fact_design_system_lineage_required", fact.key);
+    if (fact.lineage.conflict_status === "none" &&
+        fact.lineage.conflict_resolution !== "")
+        invalid("manifest_fact_conflict_resolution_forbidden", fact.key);
+    if (fact.lineage.conflict_status === "resolved" &&
+        !fact.lineage.conflict_resolution.trim())
+        invalid("manifest_fact_conflict_resolution_required", fact.key);
+    if (fact.lineage.design_system_ref !== null &&
+        fact.lineage.design_system_ref !== manifest.design_system.id)
+        invalid("manifest_fact_design_system_lineage_mismatch", fact.key);
+    validateLineageRefs(fact, nodes);
+    validateLineageChain(fact, nodes);
+}
+function validateLineageRefs(fact, nodes) {
+    unique(fact.lineage.token_chain_refs, `manifest_fact_token_chain_duplicate:${fact.key}`);
+    unique(fact.lineage.override_chain_refs, `manifest_fact_override_chain_duplicate:${fact.key}`);
+    refsKnown(fact.lineage.token_chain_refs, nodes, "manifest_fact_token_lineage_unknown", fact.key);
+    refsKnown(fact.lineage.override_chain_refs, nodes, "manifest_fact_override_lineage_unknown", fact.key);
+    for (const ref of fact.lineage.token_chain_refs)
+        if (![
+            "base_token",
+            "alias_token",
+            "semantic_token",
+            "component_token",
+        ].includes(nodes.get(ref).kind))
+            invalid("manifest_fact_token_lineage_kind_invalid", `${fact.key}:${ref}`);
+    for (const ref of fact.lineage.override_chain_refs)
+        if (![
+            "platform_override",
+            "mode_override",
+            "state_override",
+            "instance_override",
+            "slot_override",
+            "direct_value",
+        ].includes(nodes.get(ref).kind))
+            invalid("manifest_fact_override_lineage_kind_invalid", `${fact.key}:${ref}`);
+}
+function validateLineageChain(fact, nodes) {
+    const chain = [
+        ...fact.lineage.token_chain_refs,
+        ...fact.lineage.override_chain_refs,
+    ];
+    if (fact.lineage.design_system_ref === null && chain.length)
+        invalid("manifest_fact_lineage_without_design_system", fact.key);
+    if (fact.lineage.design_system_ref !== null && chain.length === 0)
+        invalid("manifest_fact_design_system_chain_required", fact.key);
+    for (let index = 1; index < chain.length; index += 1)
+        if (!nodes.get(chain[index]).predecessor_refs.includes(chain[index - 1]))
+            invalid("manifest_fact_lineage_chain_disconnected", `${fact.key}:${chain[index - 1]}:${chain[index]}`);
+    if (!chain.length)
+        return;
+    const effective = nodes.get(chain.at(-1)).value;
+    if (effective.sha256 !== fact.lineage.resolved_value.sha256 ||
+        stableJson(effective.locator) !==
+            stableJson(fact.lineage.resolved_value.locator))
+        invalid("manifest_fact_lineage_effective_value_mismatch", fact.key);
+}

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

@@ -0,0 +1,30 @@
+import { type DesignResourceObservableFactManifestV1, type DesignResourceSubjectVariationV1, type DesignResourceVariationAxis } from "./design-resource-fact-manifest-types.js";
+export declare function manifestIdentityDigest(rows: ReadonlyArray<unknown>): string;
+export declare function manifestCollectionRows(manifest: DesignResourceObservableFactManifestV1): Map<string, ReadonlyArray<unknown>>;
+export declare function conditionAxisValue(condition: DesignResourceObservableFactManifestV1["conditions"][number], axis: string): string;
+export declare function variationValues(variation: DesignResourceSubjectVariationV1): Array<readonly [DesignResourceVariationAxis, string]>;
+export declare function factCellFingerprint(cell: {
+    subject_ref: string;
+    target_ref: string;
+    condition_ref: string;
+    variation_ref: string;
+    property_ref: string;
+}): string;
+export declare function validateBasis(row: {
+    source_item_refs: string[];
+    basis_refs: string[];
+}, sourceItems: Map<string, string>, census: Map<string, unknown>, label: string): void;
+export declare function exactAxisPairs<T extends string>(pairs: Array<{
+    axis_ref: T | string;
+    value_ref: string;
+}>, expectedAxes: readonly T[] | string[], detail: string): Array<readonly [string, string]>;
+export declare function axisFingerprint(values: Array<readonly [string, string]>): string;
+export declare function cartesian<T>(groups: T[][]): T[][];
+export declare function groupBy<T>(rows: T[], key: (row: T) => string): Map<string, T[]>;
+export declare function refsKnown<T>(refs: string[], known: Map<string, T>, code: string, detail: string): void;
+export declare function nonempty(values: unknown[], code: string): void;
+export declare function unique(values: string[], code: string): void;
+export declare function sameSet(actual: string[], expected: string[], code: string, detail: string): void;
+export declare function sameSetValue(left: readonly string[], right: readonly string[]): boolean;
+export declare function stableJson(value: unknown): string;
+export declare function invalid(code: string, detail: string): never;

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

@@ -0,0 +1,167 @@
+import { DESIGN_RESOURCE_STANDARD_CONDITION_AXES, } from "./design-resource-fact-manifest-types.js";
+import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
+import { sha256Hex } from "./strict-codec.js";
+export function manifestIdentityDigest(rows) {
+    return sha256Hex(rows
+        .map((row) => stableJson(row))
+        .sort()
+        .join("\n"));
+}
+export function manifestCollectionRows(manifest) {
+    return new Map([
+        ["inspector_inputs", manifest.inspector.input_resources],
+        ["inspector_census", manifest.inspector.census],
+        ["axis_dispositions", manifest.axis_dispositions],
+        ["condition_exclusions", manifest.condition_exclusions],
+        ["conditions", manifest.conditions],
+        ["subjects", manifest.subjects],
+        ["variation_axis_dispositions", manifest.variation_axis_dispositions],
+        ["variation_exclusions", manifest.variation_exclusions],
+        ["variations", manifest.variations],
+        ["properties", manifest.properties],
+        ["lineage_nodes", manifest.lineage_nodes],
+        ["fact_cells", manifest.fact_cells],
+        ["facts", manifest.facts],
+        ["evidence", manifest.evidence],
+        ["proof_obligations", manifest.proof_obligations],
+        ["oracles", manifest.oracles],
+        ["environments", manifest.environments],
+        ["asset_bindings", manifest.asset_bindings],
+        ["acceptance_blockers", manifest.acceptance_blockers],
+    ]);
+}
+export function conditionAxisValue(condition, axis) {
+    const standard = {
+        platform: condition.platform,
+        os_version: condition.os_version,
+        device_profile: condition.device_profile,
+        form_factor: condition.form_factor,
+        viewport: condition.viewport.key,
+        orientation: condition.orientation,
+        density: condition.density.key,
+        safe_area: condition.safe_area.key,
+        window_state: condition.window_state,
+        fold_state: condition.fold_state,
+        display_mode: condition.display_mode,
+        color_scheme: condition.color_scheme,
+        locale: condition.locale,
+        language: condition.language,
+        script: condition.script,
+        direction: condition.direction,
+        pseudo_localization: condition.pseudo_localization,
+        content_case: condition.content_case,
+        data_case: condition.data_case,
+        text_scale: condition.text_scale.key,
+        input_method: condition.input_method,
+        assistive_technology: condition.assistive_technology,
+        motion: condition.motion,
+        transparency: condition.transparency,
+        contrast: condition.contrast,
+        bold_text: condition.bold_text,
+        button_shapes: condition.button_shapes,
+        system_ui: condition.system_ui,
+        ime: condition.ime,
+        permission: condition.permission,
+        capability: condition.capability,
+        connectivity: condition.connectivity,
+        lifecycle: condition.lifecycle,
+    };
+    if (DESIGN_RESOURCE_STANDARD_CONDITION_AXES.includes(axis))
+        return standard[axis];
+    const custom = condition.custom_axes.filter((item) => item.axis_ref === axis);
+    if (custom.length !== 1)
+        invalid("manifest_condition_custom_axis_missing_or_duplicate", `${condition.key}:${axis}`);
+    return custom[0].value_ref;
+}
+export function variationValues(variation) {
+    return [
+        ["variant", variation.variant],
+        ["state", variation.state],
+        ["interaction_phase", variation.interaction_phase],
+        ["presence_phase", variation.presence_phase],
+        ["instance_case", variation.instance_case],
+    ];
+}
+export function factCellFingerprint(cell) {
+    return [
+        cell.subject_ref,
+        cell.target_ref,
+        cell.condition_ref,
+        cell.variation_ref,
+        cell.property_ref,
+    ].join("\0");
+}
+export function validateBasis(row, sourceItems, census, label) {
+    nonempty(row.source_item_refs, `${label}:source_item_refs_required`);
+    nonempty(row.basis_refs, `${label}:basis_refs_required`);
+    unique(row.source_item_refs, `${label}:source_item_ref_duplicate`);
+    unique(row.basis_refs, `${label}:basis_ref_duplicate`);
+    refsKnown(row.source_item_refs, sourceItems, "manifest_source_item_unknown", label);
+    for (const ref of row.basis_refs)
+        if (!sourceItems.has(ref) && !census.has(ref))
+            invalid("manifest_basis_ref_unknown", `${label}:${ref}`);
+}
+export function exactAxisPairs(pairs, expectedAxes, detail) {
+    unique(pairs.map((pair) => pair.axis_ref), `${detail}:axis_duplicate`);
+    sameSet(pairs.map((pair) => pair.axis_ref), [...expectedAxes], "manifest_combination_axes_mismatch", detail);
+    const byAxis = new Map(pairs.map((pair) => [String(pair.axis_ref), pair.value_ref]));
+    return [...expectedAxes].map((axis) => [String(axis), byAxis.get(String(axis))]);
+}
+export function axisFingerprint(values) {
+    return values
+        .map(([axis, value]) => `${axis}=${value}`)
+        .sort()
+        .join("\0");
+}
+export function cartesian(groups) {
+    let result = [[]];
+    for (const group of groups)
+        result = result.flatMap((prefix) => group.map((item) => [...prefix, item]));
+    return result;
+}
+export function groupBy(rows, key) {
+    const result = new Map();
+    for (const row of rows) {
+        const value = key(row);
+        const group = result.get(value) ?? [];
+        group.push(row);
+        result.set(value, group);
+    }
+    return result;
+}
+export function refsKnown(refs, known, code, detail) {
+    for (const ref of refs)
+        if (!known.has(ref))
+            invalid(code, `${detail}:${ref}`);
+}
+export function nonempty(values, code) {
+    if (!values.length)
+        invalid(code, "");
+}
+export function unique(values, code) {
+    if (new Set(values).size !== values.length)
+        invalid(code, values.join(","));
+}
+export function sameSet(actual, expected, code, detail) {
+    if (!sameSetValue(actual, expected))
+        invalid(code, `${detail}:${[...new Set(actual)].sort().join(",")}:${[...new Set(expected)].sort().join(",")}`);
+}
+export function sameSetValue(left, right) {
+    const actual = [...new Set(left)].sort();
+    const expected = [...new Set(right)].sort();
+    return (actual.length === expected.length &&
+        actual.every((item, index) => item === expected[index]));
+}
+export function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableJson(item)).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+export function invalid(code, detail) {
+    invalidDesignResourceHandoff(code, detail);
+}

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

@@ -0,0 +1,7 @@
+import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
+import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
+import type { DesignResourceHandoffTargetV1, DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+type Census = Map<string, DesignResourceObservableFactManifestV1["inspector"]["census"][number]>;
+export declare function validateManifestLineageNodes(manifest: DesignResourceObservableFactManifestV1, census: Census, resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;
+export declare function validateManifestInspector(manifest: DesignResourceObservableFactManifestV1, handoff: DesignResourceHandoffV1, target: DesignResourceHandoffTargetV1, resources: Map<string, DesignResource>, contents: Map<string, Buffer>, sourceItems: Map<string, string>): void;
+export {};