project-tiny-context-harness 0.8.17 → 0.12.0

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

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

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

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

@@ -1,161 +0,0 @@
-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);
-    }
-    assertExpectedFactCellFingerprints(manifest, actual);
-    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 assertExpectedFactCellFingerprints(manifest, actual) {
-    const variationsBySubject = new Map();
-    for (const variation of manifest.variations) {
-        const rows = variationsBySubject.get(variation.subject_ref) ?? [];
-        rows.push(variation.key);
-        variationsBySubject.set(variation.subject_ref, rows);
-    }
-    let expectedCount = 0;
-    for (const subject of manifest.subjects)
-        for (const condition of manifest.conditions)
-            for (const variationRef of variationsBySubject.get(subject.key) ?? [])
-                for (const property of manifest.properties)
-                    if (!actual.has(factCellFingerprint({
-                        subject_ref: subject.key,
-                        target_ref: manifest.target_key,
-                        condition_ref: condition.key,
-                        variation_ref: variationRef,
-                        property_ref: property.key,
-                    })))
-                        invalid("manifest_expected_fact_cell_universe_mismatch", `${manifest.target_key}:missing:${subject.key}:${condition.key}:${variationRef}:${property.key}`);
-                    else
-                        expectedCount += 1;
-    if (actual.size !== expectedCount)
-        invalid("manifest_expected_fact_cell_universe_mismatch", `${manifest.target_key}:count:${actual.size}:${expectedCount}`);
-}

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

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

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

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

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

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

@@ -1,171 +0,0 @@
-import { createHash } from "node:crypto";
-import { DESIGN_RESOURCE_STANDARD_CONDITION_AXES, } from "./design-resource-fact-manifest-types.js";
-import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
-export function manifestIdentityDigest(rows) {
-    const hash = createHash("sha256");
-    const identities = rows.map((row) => stableJson(row)).sort();
-    for (let index = 0; index < identities.length; index += 1) {
-        if (index > 0)
-            hash.update("\n");
-        hash.update(identities[index]);
-    }
-    return hash.digest("hex");
-}
-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);
-}