project-tiny-context-harness 0.8.17 → 0.12.0

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

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

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

@@ -1,119 +0,0 @@
-import { resolveDesignResourceLocatorValue, validateDesignResourceLocatedDigest, } from "./design-resource-fact-locator-validation.js";
-import { invalid, nonempty, refsKnown, sameSet, unique, validateBasis, } from "./design-resource-fact-universe-helpers.js";
-export function validateManifestLineageNodes(manifest, census, resources, contents) {
-    const nodes = new Map(manifest.lineage_nodes.map((node) => [node.key, node]));
-    for (const node of manifest.lineage_nodes) {
-        unique(node.predecessor_refs, `manifest_lineage_predecessor_duplicate:${node.key}`);
-        refsKnown(node.predecessor_refs, nodes, "manifest_lineage_predecessor_unknown", node.key);
-        if (node.predecessor_refs.includes(node.key))
-            invalid("manifest_lineage_self_reference", node.key);
-        if (["base_token", "direct_value"].includes(node.kind) &&
-            node.predecessor_refs.length)
-            invalid("manifest_lineage_root_predecessor_forbidden", node.key);
-        if (!["base_token", "direct_value"].includes(node.kind) &&
-            node.predecessor_refs.length === 0)
-            invalid("manifest_lineage_predecessor_required", node.key);
-        nonempty(node.census_refs, `manifest_lineage_census_required:${node.key}`);
-        refsKnown(node.census_refs, census, "manifest_lineage_census_unknown", node.key);
-        for (const ref of node.census_refs)
-            if (!["token", "declaration"].includes(census.get(ref).kind))
-                invalid("manifest_lineage_census_kind_invalid", `${node.key}:${ref}:${census.get(ref).kind}`);
-        validateDesignResourceLocatedDigest(node.value, resources, contents, `manifest.lineage_node.${node.key}.value`);
-    }
-    validateLineageAcyclic(manifest, nodes);
-}
-function validateLineageAcyclic(manifest, nodes) {
-    for (const node of manifest.lineage_nodes) {
-        const visiting = new Set();
-        const visited = new Set();
-        const walk = (ref) => {
-            if (visiting.has(ref))
-                invalid("manifest_lineage_cycle", node.key);
-            if (visited.has(ref))
-                return;
-            visiting.add(ref);
-            for (const predecessor of nodes.get(ref).predecessor_refs)
-                walk(predecessor);
-            visiting.delete(ref);
-            visited.add(ref);
-        };
-        walk(node.key);
-    }
-}
-export function validateManifestInspector(manifest, handoff, target, resources, contents, sourceItems) {
-    const inspector = manifest.inspector;
-    validateInspectorIdentity(inspector);
-    if (inspector.entry_resource_ref !== target.source_profile.entry_resource_ref)
-        invalid("manifest_inspector_entry_mismatch", `${manifest.target_key}:${inspector.entry_resource_ref}:${target.source_profile.entry_resource_ref}`);
-    validateInspectorInputs(manifest, target, resources);
-    validateInspectorCensus(manifest, resources, contents, sourceItems);
-    const expectedInspectorIdentity = `${inspector.identity}@${inspector.version}`;
-    for (const resourceRef of target.resource_refs) {
-        const closure = handoff.resource_fact_closure.find((item) => item.resource_ref === resourceRef);
-        if (!closure || closure.inspection.inspector !== expectedInspectorIdentity)
-            invalid("manifest_resource_closure_inspector_mismatch", `${resourceRef}:${closure?.inspection.inspector ?? "missing"}:${expectedInspectorIdentity}`);
-    }
-}
-function validateInspectorIdentity(inspector) {
-    if (inspector.trust === "frozen_executable" &&
-        inspector.implementation_sha256 === null)
-        invalid("manifest_inspector_digest_required", inspector.identity);
-    if (inspector.trust === "named_external_tcb" &&
-        inspector.implementation_sha256 !== null)
-        invalid("manifest_external_inspector_digest_forbidden", inspector.identity);
-    nonempty(inspector.capability_refs, "manifest_inspector_capabilities_required");
-    unique(inspector.capability_refs, "manifest_inspector_capability_duplicate");
-}
-function validateInspectorInputs(manifest, target, resources) {
-    const manifestResourceRef = target.source_profile.fact_manifest_resource_ref;
-    const expectedInputs = target.resource_refs
-        .filter((ref) => ref !== manifestResourceRef)
-        .map((ref) => {
-        const resource = resources.get(ref);
-        return `${ref}\0${resource.path}\0${resource.sha256}`;
-    });
-    const actualInputs = manifest.inspector.input_resources.map((item) => `${item.resource_ref}\0${item.path}\0${item.sha256}`);
-    sameSet(actualInputs, expectedInputs, "manifest_inspector_input_resource_mismatch", manifest.target_key);
-    unique(manifest.inspector.input_resources.map((item) => item.resource_ref), "manifest_inspector_input_resource_duplicate");
-}
-function validateInspectorCensus(manifest, resources, contents, sourceItems) {
-    const inputRefs = new Set(manifest.inspector.input_resources.map((item) => item.resource_ref));
-    const censusByResource = new Map();
-    const censusFactRefs = new Set();
-    const censusFactCellRefs = new Set();
-    const facts = new Map(manifest.facts.map((fact) => [fact.key, fact]));
-    const factCells = new Map(manifest.fact_cells.map((cell) => [cell.key, cell]));
-    const censusEntries = new Map(manifest.inspector.census.map((entry) => [entry.key, entry]));
-    for (const entry of manifest.inspector.census) {
-        validateCensusEntry(entry, inputRefs, censusByResource, facts, factCells, censusEntries, resources, contents, sourceItems);
-        for (const ref of entry.fact_refs)
-            censusFactRefs.add(ref);
-        for (const ref of entry.fact_cell_refs)
-            censusFactCellRefs.add(ref);
-    }
-    for (const ref of inputRefs)
-        if (!censusByResource.has(ref))
-            invalid("manifest_census_resource_missing", ref);
-    sameSet([...censusFactRefs], manifest.facts.map((fact) => fact.key), "manifest_census_fact_set_mismatch", manifest.target_key);
-    sameSet([...censusFactCellRefs], manifest.fact_cells.map((cell) => cell.key), "manifest_census_fact_cell_set_mismatch", manifest.target_key);
-}
-function validateCensusEntry(entry, inputRefs, censusByResource, facts, factCells, censusEntries, resources, contents, sourceItems) {
-    validateBasis(entry, sourceItems, censusEntries, `manifest_census:${entry.key}`);
-    if (entry.basis_refs.includes(entry.key))
-        invalid("manifest_census_self_basis_forbidden", entry.key);
-    if (!inputRefs.has(entry.resource_ref))
-        invalid("manifest_census_resource_outside_inputs", `${entry.key}:${entry.resource_ref}`);
-    censusByResource.set(entry.resource_ref, (censusByResource.get(entry.resource_ref) ?? 0) + 1);
-    resolveDesignResourceLocatorValue({ resource_ref: entry.resource_ref, ...entry.locator }, resources.get(entry.resource_ref), contents.get(entry.resource_ref), `manifest.census.${entry.key}`);
-    unique(entry.fact_refs, `manifest_census_fact_ref_duplicate:${entry.key}`);
-    unique(entry.fact_cell_refs, `manifest_census_fact_cell_ref_duplicate:${entry.key}`);
-    refsKnown(entry.fact_refs, facts, "manifest_census_fact_ref_unknown", entry.key);
-    refsKnown(entry.fact_cell_refs, factCells, "manifest_census_fact_cell_ref_unknown", entry.key);
-    if (entry.disposition === "covered" &&
-        entry.fact_refs.length === 0 &&
-        entry.fact_cell_refs.length === 0)
-        invalid("manifest_census_covered_binding_required", entry.key);
-    if (entry.disposition === "non_material" &&
-        (entry.fact_refs.length > 0 || entry.fact_cell_refs.length > 0))
-        invalid("manifest_census_non_material_binding_forbidden", entry.key);
-}

package/dist/lib/design-resource-fact-universe-proof.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 { DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
-export declare function validateManifestProofAndEvidence(manifest: DesignResourceObservableFactManifestV1, target: DesignResourceHandoffTargetV1, resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;

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

@@ -1,113 +0,0 @@
-import { designFactComparatorSupportsMethod, designFactMethodIsCompatible, designFactOracleSupportsMethod, EXACT_TARGET_FULL_TARGET_METHODS, } from "./design-resource-fact-policy.js";
-import { resolveDesignResourceLocatorValue, validateDesignResourceLocatedDigest, } from "./design-resource-fact-locator-validation.js";
-import { invalid, nonempty, unique, } from "./design-resource-fact-universe-helpers.js";
-export function validateManifestProofAndEvidence(manifest, target, resources, contents) {
-    validateOraclesAndEnvironments(manifest, resources, contents);
-    validateProofObligations(manifest, resources, contents);
-    validateExactTargetFullTargetProof(manifest, target);
-    validateEvidence(manifest, resources, contents);
-}
-function validateOraclesAndEnvironments(manifest, resources, contents) {
-    for (const oracle of manifest.oracles) {
-        nonempty(oracle.capability_refs, `manifest_oracle_capabilities_required:${oracle.key}`);
-        unique(oracle.capability_refs, `manifest_oracle_capability_duplicate:${oracle.key}`);
-        if (oracle.trust === "frozen_executable" && oracle.sha256 === null)
-            invalid("manifest_oracle_digest_required", oracle.key);
-        if (oracle.trust === "named_external_tcb" && oracle.sha256 !== null)
-            invalid("manifest_external_oracle_digest_forbidden", oracle.key);
-    }
-    for (const environment of manifest.environments)
-        validateDesignResourceLocatedDigest(environment.definition, resources, contents, `manifest.environment.${environment.key}`);
-}
-function validateProofObligations(manifest, resources, contents) {
-    const properties = new Map(manifest.properties.map((property) => [property.key, property]));
-    const oracles = new Map(manifest.oracles.map((item) => [item.key, item]));
-    const environments = new Map(manifest.environments.map((item) => [item.key, item]));
-    const proofMethodsByFact = new Map();
-    const factMethodIdentities = [];
-    for (const proof of manifest.proof_obligations) {
-        validateProof(proof, manifest, oracles, environments, resources, contents);
-        const identity = `${proof.fact_ref}\0${proof.method}`;
-        factMethodIdentities.push(identity);
-        const methods = proofMethodsByFact.get(proof.fact_ref) ?? new Set();
-        methods.add(proof.method);
-        proofMethodsByFact.set(proof.fact_ref, methods);
-    }
-    unique(factMethodIdentities, "manifest_fact_method_obligation_duplicate");
-    for (const fact of manifest.facts) {
-        const actualMethods = proofMethodsByFact.get(fact.key);
-        if (!actualMethods)
-            invalid("manifest_fact_proof_obligation_required", fact.key);
-        const requiredMethods = new Set(properties.get(fact.property_ref).required_methods);
-        if (fact.lineage.design_system_ref !== null &&
-            (fact.lineage.token_chain_refs.length > 0 ||
-                fact.lineage.override_chain_refs.length > 0))
-            requiredMethods.add("design_token");
-        for (const method of requiredMethods)
-            if (!actualMethods.has(method))
-                invalid("manifest_fact_required_proof_method_missing", `${fact.key}:${method}`);
-    }
-}
-function validateProof(proof, manifest, oracles, environments, resources, contents) {
-    const fact = manifest.facts.find((item) => item.key === proof.fact_ref);
-    if (!fact)
-        invalid("manifest_proof_fact_unknown", proof.key);
-    if (!designFactMethodIsCompatible(fact.dimension, proof.method))
-        invalid("manifest_proof_method_incompatible", `${proof.key}:${fact.dimension}:${proof.method}`);
-    if (!designFactComparatorSupportsMethod(proof.method, proof.comparison.comparator))
-        invalid("manifest_proof_comparator_method_incompatible", `${proof.key}:${proof.method}:${proof.comparison.comparator}`);
-    const oracle = oracles.get(proof.oracle_ref);
-    if (!oracle)
-        invalid("manifest_proof_oracle_unknown", proof.key);
-    if (!designFactOracleSupportsMethod(proof.method, oracle.capability_refs))
-        invalid("manifest_proof_oracle_capability_missing", `${proof.key}:${proof.oracle_ref}:${proof.method}`);
-    if (!environments.has(proof.environment_ref))
-        invalid("manifest_proof_environment_unknown", proof.key);
-    validateComparison(proof, resources, contents);
-}
-function validateComparison(proof, resources, contents) {
-    validateDesignResourceLocatedDigest(proof.comparison.parameters, resources, contents, `manifest.proof.${proof.key}.parameters`);
-    if (proof.comparison.mode === "exact") {
-        if (proof.comparison.tolerance !== null || proof.comparison.mask !== null)
-            invalid("manifest_exact_proof_tolerance_forbidden", proof.key);
-    }
-    else if (proof.comparison.tolerance === null)
-        invalid("manifest_tolerance_proof_tolerance_required", proof.key);
-    if (proof.comparison.tolerance)
-        validateDesignResourceLocatedDigest(proof.comparison.tolerance, resources, contents, `manifest.proof.${proof.key}.tolerance`);
-    if (proof.comparison.mask)
-        validateDesignResourceLocatedDigest(proof.comparison.mask, resources, contents, `manifest.proof.${proof.key}.mask`);
-    if (proof.comparison.mask !== null &&
-        proof.comparison.comparator !== "pixel_diff" &&
-        !proof.comparison.comparator.startsWith("custom."))
-        invalid("manifest_proof_mask_comparator_incompatible", `${proof.key}:${proof.comparison.comparator}`);
-}
-function validateExactTargetFullTargetProof(manifest, target) {
-    if (target.interpretation !== "exact_target")
-        return;
-    for (const condition of manifest.conditions)
-        for (const method of EXACT_TARGET_FULL_TARGET_METHODS)
-            if (!hasFullTargetProof(manifest, condition.key, method))
-                invalid("manifest_exact_target_full_target_proof_missing", `${target.key}:${condition.key}:${method}`);
-}
-function hasFullTargetProof(manifest, conditionRef, method) {
-    return manifest.proof_obligations.some((proof) => {
-        const fact = manifest.facts.find((item) => item.key === proof.fact_ref);
-        return (fact?.condition_ref === conditionRef &&
-            fact.observation_scope === "full_target" &&
-            proof.method === method);
-    });
-}
-function validateEvidence(manifest, resources, contents) {
-    const conditions = new Set(manifest.conditions.map((item) => item.key));
-    for (const evidenceItem of manifest.evidence) {
-        const resource = resources.get(evidenceItem.resource_ref);
-        const bytes = contents.get(evidenceItem.resource_ref);
-        if (!resource || !bytes)
-            invalid("manifest_evidence_resource_unknown", evidenceItem.key);
-        for (const conditionRef of evidenceItem.condition_refs)
-            if (!conditions.has(conditionRef))
-                invalid("manifest_evidence_condition_unknown", `${evidenceItem.key}:${conditionRef}`);
-        resolveDesignResourceLocatorValue({ resource_ref: evidenceItem.resource_ref, ...evidenceItem.locator }, resource, bytes, `manifest.evidence.${evidenceItem.key}`);
-    }
-}

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

@@ -1,5 +0,0 @@
-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";
-export declare function validateManifestDesignSystem(manifest: DesignResourceObservableFactManifestV1, handoff: DesignResourceHandoffV1, target: DesignResourceHandoffTargetV1, resources: Map<string, DesignResource>): void;
-export declare function validateManifestSubjects(manifest: DesignResourceObservableFactManifestV1, census: Map<string, DesignResourceObservableFactManifestV1["inspector"]["census"][number]>): void;

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

@@ -1,97 +0,0 @@
-import { invalid, nonempty, refsKnown, unique, } from "./design-resource-fact-universe-helpers.js";
-export function validateManifestDesignSystem(manifest, handoff, target, resources) {
-    const snapshot = manifest.design_system;
-    const styleBearing = handoff.scope.style_dependency !== "non-fidelity";
-    if (styleBearing && snapshot.disposition !== "used")
-        invalid("manifest_design_system_required", manifest.target_key);
-    if (!styleBearing && snapshot.disposition !== "not_applicable")
-        invalid("manifest_design_system_not_applicable_required", manifest.target_key);
-    if (snapshot.id !== handoff.provenance.design_system_id)
-        invalid("manifest_design_system_id_mismatch", `${snapshot.id}:${handoff.provenance.design_system_id}`);
-    const resource = resources.get(snapshot.resource_ref);
-    if (!resource)
-        invalid("manifest_design_system_resource_unknown", snapshot.resource_ref);
-    if (!target.resource_refs.includes(snapshot.resource_ref))
-        invalid("manifest_design_system_resource_outside_target", `${target.key}:${snapshot.resource_ref}`);
-    if (resource.sha256 !== snapshot.sha256)
-        invalid("manifest_design_system_digest_mismatch", `${snapshot.resource_ref}:${snapshot.sha256}:${resource.sha256}`);
-}
-export function validateManifestSubjects(manifest, census) {
-    const subjects = new Map(manifest.subjects.map((subject) => [subject.key, subject]));
-    const roots = manifest.subjects.filter((subject) => subject.parent_ref === null &&
-        (subject.kind === "surface" || subject.kind === "flow"));
-    if (!roots.length)
-        invalid("manifest_subject_root_required", manifest.target_key);
-    for (const subject of manifest.subjects)
-        validateSubject(subject, subjects, census);
-    validateSubjectParentAcyclic(manifest, subjects);
-}
-function validateSubject(subject, subjects, census) {
-    nonempty(subject.census_refs, `manifest_subject_census_required:${subject.key}`);
-    refsKnown(subject.census_refs, census, "manifest_subject_census_unknown", subject.key);
-    if (subject.presence === "always" && subject.presence_rule_ref !== null)
-        invalid("manifest_always_presence_rule_forbidden", subject.key);
-    if (subject.presence !== "always" && subject.presence_rule_ref === null)
-        invalid("manifest_dynamic_presence_rule_required", subject.key);
-    validatePresenceAndPopulation(subject, census);
-    for (const ref of [
-        subject.parent_ref,
-        subject.instance_of_ref,
-        subject.override_of_ref,
-        subject.family_ref,
-        subject.portal_host_ref,
-    ])
-        if (ref !== null && !subjects.has(ref))
-            invalid("manifest_subject_relation_unknown", `${subject.key}:${ref}`);
-    if (subject.parent_ref === null &&
-        subject.kind !== "surface" &&
-        subject.kind !== "flow")
-        invalid("manifest_subject_parent_required", subject.key);
-    if (subject.presence === "portal" && subject.portal_host_ref === null)
-        invalid("manifest_portal_host_required", subject.key);
-    validateRelationSubject(subject, subjects);
-}
-function validatePresenceAndPopulation(subject, census) {
-    if (subject.presence_rule_ref !== null) {
-        const presenceRule = census.get(subject.presence_rule_ref);
-        if (!presenceRule)
-            invalid("manifest_presence_rule_census_unknown", `${subject.key}:${subject.presence_rule_ref}`);
-        if (!["declaration", "state", "dynamic_population"].includes(presenceRule.kind))
-            invalid("manifest_presence_rule_census_kind_invalid", `${subject.key}:${subject.presence_rule_ref}:${presenceRule.kind}`);
-    }
-    if (subject.presence === "virtualized" && subject.population_ref === null)
-        invalid("manifest_virtualized_population_required", subject.key);
-    if (subject.population_ref === null)
-        return;
-    const population = census.get(subject.population_ref);
-    if (!population)
-        invalid("manifest_population_census_unknown", `${subject.key}:${subject.population_ref}`);
-    if (population.kind !== "dynamic_population")
-        invalid("manifest_population_census_kind_invalid", `${subject.key}:${subject.population_ref}:${population.kind}`);
-}
-function validateRelationSubject(subject, subjects) {
-    if (subject.kind !== "relation") {
-        if (subject.relation_endpoints.length)
-            invalid("manifest_nonrelation_endpoints_forbidden", subject.key);
-        return;
-    }
-    if (subject.relation_endpoints.length < 2)
-        invalid("manifest_relation_endpoints_required", subject.key);
-    unique(subject.relation_endpoints.map((item) => item.role), `manifest_relation_endpoint_role_duplicate:${subject.key}`);
-    for (const endpoint of subject.relation_endpoints)
-        if (endpoint.subject_ref === subject.key ||
-            !subjects.has(endpoint.subject_ref))
-            invalid("manifest_relation_endpoint_invalid", `${subject.key}:${endpoint.role}:${endpoint.subject_ref}`);
-}
-function validateSubjectParentAcyclic(manifest, subjects) {
-    for (const subject of manifest.subjects) {
-        const visited = new Set();
-        let current = subject;
-        while (current?.parent_ref) {
-            if (visited.has(current.key))
-                invalid("manifest_subject_parent_cycle", subject.key);
-            visited.add(current.key);
-            current = subjects.get(current.parent_ref);
-        }
-    }
-}

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

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

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

@@ -1,75 +0,0 @@
-import { DESIGN_RESOURCE_VARIATION_AXES, } from "./design-resource-fact-manifest-types.js";
-import { axisFingerprint, cartesian, exactAxisPairs, groupBy, invalid, nonempty, refsKnown, sameSet, unique, validateBasis, variationValues, } from "./design-resource-fact-universe-helpers.js";
-export function validateManifestVariationUniverse(manifest, census, sourceItems) {
-    const subjects = new Set(manifest.subjects.map((item) => item.key));
-    const variationsBySubject = groupBy(manifest.variations, (item) => item.subject_ref);
-    const axesBySubject = groupBy(manifest.variation_axis_dispositions, (item) => item.subject_ref);
-    const exclusionsBySubject = groupBy(manifest.variation_exclusions, (item) => item.subject_ref);
-    for (const subjectRef of subjects) {
-        validateSubjectVariations(subjectRef, variationsBySubject.get(subjectRef) ?? [], axesBySubject.get(subjectRef) ?? [], exclusionsBySubject.get(subjectRef) ?? [], census, sourceItems);
-    }
-    for (const ref of [
-        ...variationsBySubject.keys(),
-        ...axesBySubject.keys(),
-        ...exclusionsBySubject.keys(),
-    ])
-        if (!subjects.has(ref))
-            invalid("manifest_variation_subject_unknown", ref);
-}
-function validateSubjectVariations(subjectRef, variations, axes, exclusions, census, sourceItems) {
-    unique(axes.map((axis) => axis.axis), `manifest_variation_axis_duplicate:${subjectRef}`);
-    for (const axis of DESIGN_RESOURCE_VARIATION_AXES)
-        if (!axes.some((item) => item.axis === axis))
-            invalid("manifest_variation_standard_axis_missing", `${subjectRef}:${axis}`);
-    for (const axis of axes)
-        validateVariationAxis(axis, census, sourceItems);
-    const byAxis = new Map(axes.map((axis) => [axis.axis, axis]));
-    const actual = validateVariations(variations, byAxis);
-    const excluded = validateVariationExclusions(exclusions, census, sourceItems, actual);
-    const expected = cartesian(axes.map((axis) => axis.values.map((value) => [axis.axis, value.key]))).map(axisFingerprint);
-    sameSet([...actual.keys(), ...excluded.keys()], expected, "manifest_variation_universe_mismatch", subjectRef);
-    if (!actual.size)
-        invalid("manifest_subject_variation_required", subjectRef);
-}
-function validateVariationAxis(axis, census, sourceItems) {
-    validateBasis(axis, sourceItems, census, `manifest_variation_axis:${axis.key}`);
-    nonempty(axis.values, `manifest_variation_axis_values_required:${axis.key}`);
-    unique(axis.values.map((value) => value.key), `manifest_variation_axis_value_duplicate:${axis.key}`);
-    if (axis.disposition === "not_applicable" &&
-        (axis.values.length !== 1 || axis.values[0].key !== "not-applicable"))
-        invalid("manifest_variation_axis_not_applicable_invalid", axis.key);
-    for (const value of axis.values) {
-        if (axis.disposition === "applicable")
-            nonempty(value.census_refs, `manifest_variation_value_census_required:${axis.key}:${value.key}`);
-        refsKnown(value.census_refs, census, "manifest_variation_value_census_unknown", `${axis.key}:${value.key}`);
-    }
-}
-function validateVariations(variations, byAxis) {
-    const actual = new Map();
-    for (const variation of variations) {
-        const values = variationValues(variation);
-        for (const [axis, value] of values)
-            if (!byAxis.get(axis).values.some((candidate) => candidate.key === value))
-                invalid("manifest_variation_axis_value_unknown", `${variation.key}:${axis}:${value}`);
-        const fingerprint = axisFingerprint(values);
-        if (actual.has(fingerprint))
-            invalid("manifest_variation_combination_duplicate", `${actual.get(fingerprint)}:${variation.key}`);
-        actual.set(fingerprint, variation.key);
-    }
-    return actual;
-}
-function validateVariationExclusions(exclusions, census, sourceItems, actual) {
-    const excluded = new Map();
-    for (const row of exclusions) {
-        validateBasis(row, sourceItems, census, `manifest_variation_exclusion:${row.key}`);
-        if (row.disposition === "decision_required" ||
-            row.disposition === "unavailable")
-            invalid("manifest_variation_exclusion_unresolved", row.key);
-        const values = exactAxisPairs(row.axis_values, [...DESIGN_RESOURCE_VARIATION_AXES], `manifest_variation_exclusion:${row.key}`);
-        const fingerprint = axisFingerprint(values);
-        if (actual.has(fingerprint) || excluded.has(fingerprint))
-            invalid("manifest_variation_exclusion_duplicate", row.key);
-        excluded.set(fingerprint, row.key);
-    }
-    return excluded;
-}

package/dist/lib/design-resource-fact-value-validation.d.ts

@@ -1,2 +0,0 @@
-import type { DesignResourceValueKind } from "./design-resource-fact-manifest-types.js";
-export declare function validateDesignResourceValueKind(kind: DesignResourceValueKind, value: Buffer, label: string): void;

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

@@ -1,80 +0,0 @@
-import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
-const VALUE_VALIDATORS = {
-    boolean: (text) => /^(?:true|false)$/u.test(text),
-    color: (text) => !text.includes("|") &&
-        (/^#[a-f0-9]{3,8}$/iu.test(text) ||
-            /^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark|var)\(.+\)$/iu.test(text) ||
-            /^(?:transparent|currentcolor|[a-z]+)$/iu.test(text)),
-    digest: (text) => /^[a-f0-9]{64}$/u.test(text),
-    enum: (text) => /^[a-z0-9][a-z0-9._:-]*$/iu.test(text),
-    length: (text, structured) => isLength(text, structured),
-    list: (text, structured) => structured === null
-        ? !text.includes("|")
-        : Array.isArray(structured) || typeof structured === "object",
-    locator: () => true,
-    number: (text) => isFiniteNumber(text),
-    ratio: (text, structured) => isRatio(text, structured),
-    relation: (_text, structured) => isStructuredCollection(structured),
-    semantic: (text, structured) => structured !== null || /^[a-z0-9][a-z0-9._:-]*$/iu.test(text),
-    string: () => true,
-    timeline: (_text, structured) => isStructuredCollection(structured),
-    token_ref: (text, structured) => structured !== null ||
-        /^(?:--[a-z0-9_-]+|[a-z0-9][a-z0-9._/-]*)$/iu.test(text),
-    trace: (_text, structured) => isStructuredCollection(structured),
-};
-export function validateDesignResourceValueKind(kind, value, label) {
-    const text = value.toString("utf8").trim();
-    const structured = text ? parseStructuredValue(text) : null;
-    if (!text || !VALUE_VALIDATORS[kind](text, structured)) {
-        invalidDesignResourceHandoff("located_value_kind_mismatch", `${label}:${kind}`);
-    }
-}
-function parseStructuredValue(value) {
-    if (!value.startsWith("{") && !value.startsWith("["))
-        return null;
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return null;
-    }
-}
-function isStructuredCollection(value) {
-    return value !== null && typeof value === "object";
-}
-function isFiniteNumber(value) {
-    if (!/^-?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/iu.test(value))
-        return false;
-    return Number.isFinite(Number(value));
-}
-function isLength(value, structured) {
-    if (structured &&
-        typeof structured === "object" &&
-        !Array.isArray(structured)) {
-        const row = structured;
-        return (typeof row.value === "number" &&
-            Number.isFinite(row.value) &&
-            typeof row.unit === "string" &&
-            /^[a-z%][a-z0-9%_-]*$/iu.test(row.unit));
-    }
-    return (/^(?:0|-?(?:\d+\.?\d*|\.\d+)(?:px|dp|sp|pt|pc|in|cm|mm|q|em|rem|ex|ch|cap|ic|lh|rlh|vw|vh|vi|vb|vmin|vmax|svw|svh|lvw|lvh|dvw|dvh|cqw|cqh|cqi|cqb|cqmin|cqmax|%))$/iu.test(value) ||
-        /^(?:calc|min|max|clamp|fit-content|var|env)\(.+\)$/iu.test(value) ||
-        /^(?:auto|min-content|max-content|stretch|normal|hairline)$/iu.test(value));
-}
-function isRatio(value, structured) {
-    if (isFiniteNumber(value))
-        return true;
-    if (/^-?(?:\d+\.?\d*|\.\d+)\s*\/\s*-?(?:\d+\.?\d*|\.\d+)$/u.test(value))
-        return true;
-    if (Array.isArray(structured)) {
-        return (structured.length === 2 &&
-            structured.every((item) => typeof item === "number" && Number.isFinite(item)));
-    }
-    if (!structured || typeof structured !== "object")
-        return false;
-    const row = structured;
-    return (typeof row.width === "number" &&
-        Number.isFinite(row.width) &&
-        typeof row.height === "number" &&
-        Number.isFinite(row.height));
-}

package/dist/lib/design-resource-handoff-bundle-draft.d.ts

@@ -1,11 +0,0 @@
-import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
-import type { DesignResourceHandoffResourceV1, DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
-type BundleFailure = (code: string, detail: string) => never;
-export interface StagedDesignResourceHandoffDraft {
-    bytes: Buffer;
-    parsed: ParsedDesignResourceHandoffInputV1;
-    target: DesignResourceHandoffTargetV1;
-    manifest_resource: DesignResourceHandoffResourceV1;
-}
-export declare function stageDesignResourceHandoffDraft(repository: string, draftDirectory: string, temporaryDirectory: string, entryName: string, maxBytes: number, fail: BundleFailure): Promise<StagedDesignResourceHandoffDraft>;
-export {};

package/dist/lib/design-resource-handoff-bundle-draft.js

@@ -1,40 +0,0 @@
-import { lstat, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { parseDesignResourceHandoffMarkdown } from "./design-resource-handoff-parser.js";
-import { repoRelative } from "./long-task-workspace.js";
-export async function stageDesignResourceHandoffDraft(repository, draftDirectory, temporaryDirectory, entryName, maxBytes, fail) {
-    const draftFile = path.join(draftDirectory, entryName);
-    const info = await lstat(draftFile);
-    if (typeof info.nlink === "number" && info.nlink > 1)
-        fail("draft_hardlink_not_allowed", entryName);
-    assertByteLimit(entryName, info.size, maxBytes, fail);
-    const bytes = await readFile(draftFile);
-    assertByteLimit(entryName, bytes.length, maxBytes, fail);
-    const content = bytes.toString("utf8");
-    if (!Buffer.from(content, "utf8").equals(bytes))
-        fail("handoff_utf8_invalid", entryName);
-    const stagedFile = path.join(temporaryDirectory, entryName);
-    await writeFile(stagedFile, bytes, { flag: "wx" });
-    const stagedPath = repoRelative(repository, stagedFile);
-    const parsed = parseDesignResourceHandoffMarkdown(stagedPath, content);
-    if (parsed.handoff.schema_version !== "design-resource-handoff-v1" ||
-        !("representation" in parsed.handoff) ||
-        parsed.handoff.representation !== "manifest_backed")
-        fail("manifest_backed_representation_required", entryName);
-    if (parsed.handoff.targets.length !== 1)
-        fail("one_target_per_handoff_required", `${entryName}:${parsed.handoff.targets.length}`);
-    const target = parsed.handoff.targets[0];
-    const manifestResource = parsed.handoff.resources.find((resource) => resource.key === target.source_profile.fact_manifest_resource_ref);
-    if (!manifestResource)
-        fail("target_manifest_resource_missing", target.key);
-    return {
-        bytes,
-        parsed: parsed,
-        target,
-        manifest_resource: manifestResource,
-    };
-}
-function assertByteLimit(entryName, actual, maximum, fail) {
-    if (actual > maximum)
-        fail("handoff_byte_limit_exceeded", `${entryName}:${actual}:${maximum}`);
-}

package/dist/lib/design-resource-handoff-bundle.d.ts

@@ -1,31 +0,0 @@
-import type { DesignResourceManifestCollectionName } from "./design-resource-fact-manifest-types.js";
-export interface DesignResourceHandoffBundleOptions {
-    repository: string;
-    draft_directory: string;
-    output_directory: string;
-    manifest_paths: string[];
-    max_handoff_bytes: number;
-}
-export interface DesignResourceHandoffBundleResult {
-    status: "published";
-    output_directory: string;
-    handoffs: Array<{
-        path: string;
-        sha256: string;
-        bytes: number;
-        scope_key: string;
-        target_key: string;
-    }>;
-    manifests: Array<{
-        path: string;
-        sha256: string;
-        scope_key: string;
-        target_key: string;
-        collections: Array<{
-            name: DesignResourceManifestCollectionName;
-            expected_count: number;
-            identity_sha256: string;
-        }>;
-    }>;
-}
-export declare function publishDesignResourceHandoffBundle(options: DesignResourceHandoffBundleOptions): Promise<DesignResourceHandoffBundleResult>;