project-tiny-context-harness 0.11.0 → 0.12.1

package/dist/lib/design-resource-handoff-shape-evidence.js

@@ -1,187 +0,0 @@
-import { DESIGN_RESOURCE_VALUE_KINDS } from "./design-resource-fact-manifest-types.js";
-import { parseDesignResourceLocatedDigest } from "./design-resource-fact-shape-primitives.js";
-import { DESIGN_RESOURCE_DIMENSIONS, DESIGN_RESOURCE_EVIDENCE_KINDS, DESIGN_RESOURCE_LOCATOR_KINDS, } from "./design-resource-handoff-types.js";
-import { contractKey, contractKeys, sourceItemKeys, stableKey, stableKeys, verificationMethods, } from "./design-resource-handoff-shape-primitives.js";
-import { array, literal, nullable, object, string, text, } from "./long-task-shape-primitives.js";
-import { EXECUTION_TARGET_CAPABILITIES } from "./execution-target-capabilities.js";
-export function parseDesignResourceHandoffEvidence(value) {
-    return array(value, "design_resource_handoff.evidence").map((item, index) => {
-        const label = `design_resource_handoff.evidence[${index}]`;
-        const row = object(item, label, [
-            "key",
-            "resource_ref",
-            "kind",
-            "locator",
-            "condition_refs",
-        ]);
-        const locator = object(row.locator, `${label}.locator`, ["kind", "value"]);
-        return {
-            key: stableKey(row.key, `${label}.key`),
-            resource_ref: stableKey(row.resource_ref, `${label}.resource_ref`),
-            kind: literal(row.kind, DESIGN_RESOURCE_EVIDENCE_KINDS, `${label}.kind`),
-            locator: {
-                kind: literal(locator.kind, DESIGN_RESOURCE_LOCATOR_KINDS, `${label}.locator.kind`),
-                value: string(locator.value, `${label}.locator.value`),
-            },
-            condition_refs: contractKeys(row.condition_refs, `${label}.condition_refs`),
-        };
-    });
-}
-export function parseDesignResourceHandoffCoverage(value) {
-    return array(value, "design_resource_handoff.coverage").map((item, index) => {
-        const label = `design_resource_handoff.coverage[${index}]`;
-        const row = object(item, label, [
-            "key",
-            "subject_refs",
-            "dimension",
-            "disposition",
-            "target_refs",
-            "condition_refs",
-            "variation_refs",
-            "property_refs",
-            "evidence_refs",
-            "fact_cell_refs",
-            "fact_refs",
-            "proof_obligation_refs",
-            "source_item_refs",
-            "verification_methods",
-            "rationale",
-        ]);
-        return {
-            key: stableKey(row.key, `${label}.key`),
-            subject_refs: stableKeys(row.subject_refs, `${label}.subject_refs`),
-            dimension: literal(row.dimension, DESIGN_RESOURCE_DIMENSIONS, `${label}.dimension`),
-            disposition: literal(row.disposition, [
-                "covered",
-                "not_applicable",
-                "excluded_by_scope",
-                "decision_required",
-                "unavailable",
-            ], `${label}.disposition`),
-            target_refs: contractKeys(row.target_refs, `${label}.target_refs`),
-            condition_refs: contractKeys(row.condition_refs, `${label}.condition_refs`),
-            variation_refs: stableKeys(row.variation_refs, `${label}.variation_refs`),
-            property_refs: stableKeys(row.property_refs, `${label}.property_refs`),
-            evidence_refs: stableKeys(row.evidence_refs, `${label}.evidence_refs`),
-            fact_cell_refs: stableKeys(row.fact_cell_refs, `${label}.fact_cell_refs`),
-            fact_refs: stableKeys(row.fact_refs, `${label}.fact_refs`),
-            proof_obligation_refs: stableKeys(row.proof_obligation_refs, `${label}.proof_obligation_refs`),
-            source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
-            verification_methods: verificationMethods(row.verification_methods, `${label}.verification_methods`),
-            rationale: string(row.rationale, `${label}.rationale`),
-        };
-    });
-}
-export function parseDesignResourceHandoffFacts(value) {
-    return array(value, "design_resource_handoff.facts").map((item, index) => {
-        const label = `design_resource_handoff.facts[${index}]`;
-        const row = object(item, label, [
-            "key",
-            "cell_ref",
-            "subject_ref",
-            "target_ref",
-            "condition_ref",
-            "variation_ref",
-            "property_ref",
-            "dimension",
-            "observation_scope",
-            "observation_sensitivity",
-            "value_kind",
-            "value",
-            "evidence_refs",
-            "source_item_refs",
-            "lineage",
-        ]);
-        const lineage = object(row.lineage, `${label}.lineage`, [
-            "design_system_ref",
-            "token_chain_refs",
-            "override_chain_refs",
-            "resolved_value",
-            "conflict_status",
-            "conflict_resolution",
-        ]);
-        return {
-            key: stableKey(row.key, `${label}.key`),
-            cell_ref: stableKey(row.cell_ref, `${label}.cell_ref`),
-            subject_ref: stableKey(row.subject_ref, `${label}.subject_ref`),
-            target_ref: contractKey(row.target_ref, `${label}.target_ref`),
-            condition_ref: contractKey(row.condition_ref, `${label}.condition_ref`),
-            variation_ref: stableKey(row.variation_ref, `${label}.variation_ref`),
-            property_ref: stableKey(row.property_ref, `${label}.property_ref`),
-            dimension: literal(row.dimension, DESIGN_RESOURCE_DIMENSIONS, `${label}.dimension`),
-            observation_scope: literal(row.observation_scope, ["subject", "full_target"], `${label}.observation_scope`),
-            observation_sensitivity: literal(row.observation_sensitivity, ["plain", "protected"], `${label}.observation_sensitivity`),
-            value_kind: literal(row.value_kind, DESIGN_RESOURCE_VALUE_KINDS, `${label}.value_kind`),
-            value: parseDesignResourceLocatedDigest(row.value, `${label}.value`),
-            evidence_refs: stableKeys(row.evidence_refs, `${label}.evidence_refs`),
-            source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
-            lineage: {
-                design_system_ref: nullable(lineage.design_system_ref, (item) => stableKey(item, `${label}.lineage.design_system_ref`)),
-                token_chain_refs: stableKeys(lineage.token_chain_refs, `${label}.lineage.token_chain_refs`),
-                override_chain_refs: stableKeys(lineage.override_chain_refs, `${label}.lineage.override_chain_refs`),
-                resolved_value: parseDesignResourceLocatedDigest(lineage.resolved_value, `${label}.lineage.resolved_value`),
-                conflict_status: literal(lineage.conflict_status, ["none", "resolved"], `${label}.lineage.conflict_status`),
-                conflict_resolution: text(lineage.conflict_resolution, `${label}.lineage.conflict_resolution`),
-            },
-        };
-    });
-}
-export function parseDesignResourceHandoffResourceFactClosure(value) {
-    return array(value, "design_resource_handoff.resource_fact_closure").map((item, index) => {
-        const label = `design_resource_handoff.resource_fact_closure[${index}]`;
-        const row = object(item, label, [
-            "key",
-            "resource_ref",
-            "disposition",
-            "fact_refs",
-            "inspection",
-            "rationale",
-        ]);
-        const inspection = object(row.inspection, `${label}.inspection`, [
-            "status",
-            "inspector",
-        ]);
-        return {
-            key: stableKey(row.key, `${label}.key`),
-            resource_ref: stableKey(row.resource_ref, `${label}.resource_ref`),
-            disposition: literal(row.disposition, ["material_with_facts", "supporting_only"], `${label}.disposition`),
-            fact_refs: stableKeys(row.fact_refs, `${label}.fact_refs`),
-            inspection: {
-                status: literal(inspection.status, ["complete"], `${label}.inspection.status`),
-                inspector: string(inspection.inspector, `${label}.inspection.inspector`),
-            },
-            rationale: string(row.rationale, `${label}.rationale`),
-        };
-    });
-}
-export function parseDesignResourceHandoffBlockers(value) {
-    return array(value, "design_resource_handoff.acceptance_blockers").map((item, index) => {
-        const label = `design_resource_handoff.acceptance_blockers[${index}]`;
-        const row = object(item, label, [
-            "key",
-            "target_refs",
-            "subject_refs",
-            "dimensions",
-            "fact_cell_refs",
-            "fact_refs",
-            "proof_obligation_refs",
-            "source_item_refs",
-            "verification_methods",
-            "required_capabilities",
-            "description",
-        ]);
-        return {
-            key: contractKey(row.key, `${label}.key`),
-            target_refs: contractKeys(row.target_refs, `${label}.target_refs`),
-            subject_refs: stableKeys(row.subject_refs, `${label}.subject_refs`),
-            dimensions: array(row.dimensions, `${label}.dimensions`).map((dimension, itemIndex) => literal(dimension, DESIGN_RESOURCE_DIMENSIONS, `${label}.dimensions[${itemIndex}]`)),
-            fact_cell_refs: stableKeys(row.fact_cell_refs, `${label}.fact_cell_refs`),
-            fact_refs: stableKeys(row.fact_refs, `${label}.fact_refs`),
-            proof_obligation_refs: stableKeys(row.proof_obligation_refs, `${label}.proof_obligation_refs`),
-            source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
-            verification_methods: verificationMethods(row.verification_methods, `${label}.verification_methods`),
-            required_capabilities: array(row.required_capabilities, `${label}.required_capabilities`).map((capability, capabilityIndex) => literal(capability, EXECUTION_TARGET_CAPABILITIES, `${label}.required_capabilities[${capabilityIndex}]`)),
-            description: string(row.description, `${label}.description`),
-        };
-    });
-}

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

@@ -1,14 +0,0 @@
-import type { DesignResourceHandoffCoverageV1 } from "./design-resource-handoff-types.js";
-export declare function stableKey(value: unknown, label: string): string;
-export declare function stableKeys(value: unknown, label: string): string[];
-export declare function contractKey(value: unknown, label: string): string;
-export declare function contractKeys(value: unknown, label: string): string[];
-export declare function sourceItemKeys(value: unknown, label: string): string[];
-export declare function verificationMethods(value: unknown, label: string): DesignResourceHandoffCoverageV1["verification_methods"];
-export declare function positiveInteger(value: unknown, label: string): number;
-export declare function nonnegativeInteger(value: unknown, label: string): number;
-export declare function positiveNumber(value: unknown, label: string): number;
-export declare function nonnegativeNumber(value: unknown, label: string): number;
-export declare function sha256(value: unknown, label: string): string;
-export declare function atomicAxisValue(value: unknown, label: string): string;
-export declare function designResourceShapeFail(label: string, message: string): never;

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

@@ -1,70 +0,0 @@
-import { DESIGN_RESOURCE_VERIFICATION_METHODS } from "./design-resource-handoff-types.js";
-import { array, literal, string } from "./long-task-shape-primitives.js";
-const KEY = /^[a-z0-9][a-z0-9._-]*$/u;
-const SOURCE_ITEM_KEY = /^[a-z0-9][a-z0-9-]*$/u;
-const SHA256 = /^[a-f0-9]{64}$/u;
-export function stableKey(value, label) {
-    const result = string(value, label);
-    if (!KEY.test(result))
-        designResourceShapeFail(label, "must match ^[a-z0-9][a-z0-9._-]*$");
-    return result;
-}
-export function stableKeys(value, label) {
-    return array(value, label).map((item, index) => stableKey(item, `${label}[${index}]`));
-}
-export function contractKey(value, label) {
-    const result = string(value, label);
-    if (!SOURCE_ITEM_KEY.test(result))
-        designResourceShapeFail(label, "must match ^[a-z0-9][a-z0-9-]*$");
-    return result;
-}
-export function contractKeys(value, label) {
-    return array(value, label).map((item, index) => contractKey(item, `${label}[${index}]`));
-}
-export function sourceItemKeys(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const result = string(item, itemLabel);
-        if (!SOURCE_ITEM_KEY.test(result))
-            designResourceShapeFail(itemLabel, "must be a valid ty-source-item key");
-        return result;
-    });
-}
-export function verificationMethods(value, label) {
-    return array(value, label).map((item, index) => literal(item, DESIGN_RESOURCE_VERIFICATION_METHODS, `${label}[${index}]`));
-}
-export function positiveInteger(value, label) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)
-        designResourceShapeFail(label, "must be a positive safe integer");
-    return value;
-}
-export function nonnegativeInteger(value, label) {
-    if (!Number.isSafeInteger(value) || Number(value) < 0)
-        designResourceShapeFail(label, "must be a non-negative safe integer");
-    return Number(value);
-}
-export function positiveNumber(value, label) {
-    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
-        designResourceShapeFail(label, "must be a positive finite number");
-    return value;
-}
-export function nonnegativeNumber(value, label) {
-    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
-        designResourceShapeFail(label, "must be a non-negative finite number");
-    return value;
-}
-export function sha256(value, label) {
-    const result = string(value, label);
-    if (!SHA256.test(result))
-        designResourceShapeFail(label, "must be a lowercase SHA-256");
-    return result;
-}
-export function atomicAxisValue(value, label) {
-    const result = stableKey(value, label);
-    if (/^all-/u.test(result) || /(?:^|[._-])catalog(?:$|[._-])/u.test(result))
-        designResourceShapeFail(label, "must identify one atomic value, not a compound collection");
-    return result;
-}
-export function designResourceShapeFail(label, message) {
-    throw new Error(`design_resource_handoff_invalid:${label}:${message}`);
-}

package/dist/lib/design-resource-handoff-shape-structure.d.ts

@@ -1,5 +0,0 @@
-import type { DesignResourceHandoffConditionV1, DesignResourceHandoffResourceV1, DesignResourceHandoffSubjectV1, DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
-export declare function parseDesignResourceHandoffResources(value: unknown): DesignResourceHandoffResourceV1[];
-export declare function parseDesignResourceHandoffConditions(value: unknown): DesignResourceHandoffConditionV1[];
-export declare function parseDesignResourceHandoffSubjects(value: unknown): DesignResourceHandoffSubjectV1[];
-export declare function parseDesignResourceHandoffTargets(value: unknown): DesignResourceHandoffTargetV1[];

package/dist/lib/design-resource-handoff-shape-structure.js

@@ -1,239 +0,0 @@
-import { DESIGN_RESOURCE_SUBJECT_KINDS, DESIGN_RESOURCE_SUBJECT_PRESENCE_KINDS, } from "./design-resource-fact-manifest-types.js";
-import { atomicAxisValue, contractKey, contractKeys, designResourceShapeFail, nonnegativeNumber, positiveInteger, positiveNumber, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
-import { array, literal, nullable, object, repositoryFile, string, } from "./long-task-shape-primitives.js";
-const SHA256 = /^[a-f0-9]{64}$/u;
-export function parseDesignResourceHandoffResources(value) {
-    return array(value, "design_resource_handoff.resources").map((item, index) => {
-        const label = `design_resource_handoff.resources[${index}]`;
-        const row = object(item, label, [
-            "key",
-            "role",
-            "path",
-            "media_type",
-            "sha256",
-            "editable_upstream",
-        ]);
-        const upstream = object(row.editable_upstream, `${label}.editable_upstream`, ["owner", "locator", "update_route"]);
-        const digest = string(row.sha256, `${label}.sha256`);
-        if (!SHA256.test(digest))
-            designResourceShapeFail(`${label}.sha256`, "must be a lowercase SHA-256");
-        return {
-            key: stableKey(row.key, `${label}.key`),
-            role: literal(row.role, ["exact_target", "constraint", "supporting"], `${label}.role`),
-            path: repositoryFile(row.path, `${label}.path`),
-            media_type: string(row.media_type, `${label}.media_type`),
-            sha256: digest,
-            editable_upstream: {
-                owner: string(upstream.owner, `${label}.editable_upstream.owner`),
-                locator: string(upstream.locator, `${label}.editable_upstream.locator`),
-                update_route: string(upstream.update_route, `${label}.editable_upstream.update_route`),
-            },
-        };
-    });
-}
-export function parseDesignResourceHandoffConditions(value) {
-    return array(value, "design_resource_handoff.conditions").map((item, index) => {
-        const label = `design_resource_handoff.conditions[${index}]`;
-        const row = object(item, label, [
-            "key",
-            "platform",
-            "os_version",
-            "device_profile",
-            "form_factor",
-            "viewport",
-            "orientation",
-            "density",
-            "safe_area",
-            "window_state",
-            "fold_state",
-            "display_mode",
-            "color_scheme",
-            "locale",
-            "language",
-            "script",
-            "direction",
-            "pseudo_localization",
-            "content_case",
-            "data_case",
-            "text_scale",
-            "input_method",
-            "assistive_technology",
-            "motion",
-            "transparency",
-            "contrast",
-            "bold_text",
-            "button_shapes",
-            "system_ui",
-            "ime",
-            "permission",
-            "capability",
-            "connectivity",
-            "lifecycle",
-            "custom_axes",
-        ]);
-        const viewport = object(row.viewport, `${label}.viewport`, [
-            "key",
-            "width",
-            "height",
-            "unit",
-        ]);
-        const density = object(row.density, `${label}.density`, [
-            "key",
-            "pixel_ratio",
-        ]);
-        const safeArea = object(row.safe_area, `${label}.safe_area`, [
-            "key",
-            "top",
-            "right",
-            "bottom",
-            "left",
-            "unit",
-        ]);
-        const textScale = object(row.text_scale, `${label}.text_scale`, [
-            "key",
-            "multiplier",
-        ]);
-        return {
-            key: contractKey(row.key, `${label}.key`),
-            platform: atomicAxisValue(row.platform, `${label}.platform`),
-            os_version: atomicAxisValue(row.os_version, `${label}.os_version`),
-            device_profile: atomicAxisValue(row.device_profile, `${label}.device_profile`),
-            form_factor: atomicAxisValue(row.form_factor, `${label}.form_factor`),
-            viewport: {
-                key: atomicAxisValue(viewport.key, `${label}.viewport.key`),
-                width: positiveInteger(viewport.width, `${label}.viewport.width`),
-                height: positiveInteger(viewport.height, `${label}.viewport.height`),
-                unit: literal(viewport.unit, ["px"], `${label}.viewport.unit`),
-            },
-            orientation: atomicAxisValue(row.orientation, `${label}.orientation`),
-            density: {
-                key: atomicAxisValue(density.key, `${label}.density.key`),
-                pixel_ratio: positiveNumber(density.pixel_ratio, `${label}.density.pixel_ratio`),
-            },
-            safe_area: {
-                key: atomicAxisValue(safeArea.key, `${label}.safe_area.key`),
-                top: nonnegativeNumber(safeArea.top, `${label}.safe_area.top`),
-                right: nonnegativeNumber(safeArea.right, `${label}.safe_area.right`),
-                bottom: nonnegativeNumber(safeArea.bottom, `${label}.safe_area.bottom`),
-                left: nonnegativeNumber(safeArea.left, `${label}.safe_area.left`),
-                unit: literal(safeArea.unit, ["px"], `${label}.safe_area.unit`),
-            },
-            window_state: atomicAxisValue(row.window_state, `${label}.window_state`),
-            fold_state: atomicAxisValue(row.fold_state, `${label}.fold_state`),
-            display_mode: atomicAxisValue(row.display_mode, `${label}.display_mode`),
-            color_scheme: atomicAxisValue(row.color_scheme, `${label}.color_scheme`),
-            locale: atomicAxisValue(row.locale, `${label}.locale`),
-            language: atomicAxisValue(row.language, `${label}.language`),
-            script: atomicAxisValue(row.script, `${label}.script`),
-            direction: literal(row.direction, ["ltr", "rtl", "not_applicable"], `${label}.direction`),
-            pseudo_localization: atomicAxisValue(row.pseudo_localization, `${label}.pseudo_localization`),
-            content_case: atomicAxisValue(row.content_case, `${label}.content_case`),
-            data_case: atomicAxisValue(row.data_case, `${label}.data_case`),
-            text_scale: {
-                key: atomicAxisValue(textScale.key, `${label}.text_scale.key`),
-                multiplier: positiveNumber(textScale.multiplier, `${label}.text_scale.multiplier`),
-            },
-            input_method: atomicAxisValue(row.input_method, `${label}.input_method`),
-            assistive_technology: atomicAxisValue(row.assistive_technology, `${label}.assistive_technology`),
-            motion: atomicAxisValue(row.motion, `${label}.motion`),
-            transparency: atomicAxisValue(row.transparency, `${label}.transparency`),
-            contrast: atomicAxisValue(row.contrast, `${label}.contrast`),
-            bold_text: atomicAxisValue(row.bold_text, `${label}.bold_text`),
-            button_shapes: atomicAxisValue(row.button_shapes, `${label}.button_shapes`),
-            system_ui: atomicAxisValue(row.system_ui, `${label}.system_ui`),
-            ime: atomicAxisValue(row.ime, `${label}.ime`),
-            permission: atomicAxisValue(row.permission, `${label}.permission`),
-            capability: atomicAxisValue(row.capability, `${label}.capability`),
-            connectivity: atomicAxisValue(row.connectivity, `${label}.connectivity`),
-            lifecycle: atomicAxisValue(row.lifecycle, `${label}.lifecycle`),
-            custom_axes: array(row.custom_axes, `${label}.custom_axes`).map((item, itemIndex) => {
-                const itemLabel = `${label}.custom_axes[${itemIndex}]`;
-                const custom = object(item, itemLabel, ["axis_ref", "value_ref"]);
-                return {
-                    axis_ref: stableKey(custom.axis_ref, `${itemLabel}.axis_ref`),
-                    value_ref: atomicAxisValue(custom.value_ref, `${itemLabel}.value_ref`),
-                };
-            }),
-        };
-    });
-}
-export function parseDesignResourceHandoffSubjects(value) {
-    return array(value, "design_resource_handoff.subjects").map((item, index) => {
-        const label = `design_resource_handoff.subjects[${index}]`;
-        const row = object(item, label, [
-            "key",
-            "kind",
-            "stable_keys",
-            "target_refs",
-            "parent_ref",
-            "instance_of_ref",
-            "slot_key",
-            "override_of_ref",
-            "family_ref",
-            "presence",
-            "presence_rule_ref",
-            "population_ref",
-            "portal_host_ref",
-            "relation_endpoints",
-            "census_refs",
-        ]);
-        return {
-            key: stableKey(row.key, `${label}.key`),
-            kind: literal(row.kind, DESIGN_RESOURCE_SUBJECT_KINDS, `${label}.kind`),
-            stable_keys: stableKeys(row.stable_keys, `${label}.stable_keys`),
-            target_refs: contractKeys(row.target_refs, `${label}.target_refs`),
-            parent_ref: nullable(row.parent_ref, (item) => stableKey(item, `${label}.parent_ref`)),
-            instance_of_ref: nullable(row.instance_of_ref, (item) => stableKey(item, `${label}.instance_of_ref`)),
-            slot_key: nullable(row.slot_key, (item) => stableKey(item, `${label}.slot_key`)),
-            override_of_ref: nullable(row.override_of_ref, (item) => stableKey(item, `${label}.override_of_ref`)),
-            family_ref: nullable(row.family_ref, (item) => stableKey(item, `${label}.family_ref`)),
-            presence: literal(row.presence, DESIGN_RESOURCE_SUBJECT_PRESENCE_KINDS, `${label}.presence`),
-            presence_rule_ref: nullable(row.presence_rule_ref, (item) => stableKey(item, `${label}.presence_rule_ref`)),
-            population_ref: nullable(row.population_ref, (item) => stableKey(item, `${label}.population_ref`)),
-            portal_host_ref: nullable(row.portal_host_ref, (item) => stableKey(item, `${label}.portal_host_ref`)),
-            relation_endpoints: array(row.relation_endpoints, `${label}.relation_endpoints`).map((endpoint, endpointIndex) => {
-                const endpointLabel = `${label}.relation_endpoints[${endpointIndex}]`;
-                const parsed = object(endpoint, endpointLabel, ["role", "subject_ref"]);
-                return {
-                    role: stableKey(parsed.role, `${endpointLabel}.role`),
-                    subject_ref: stableKey(parsed.subject_ref, `${endpointLabel}.subject_ref`),
-                };
-            }),
-            census_refs: stableKeys(row.census_refs, `${label}.census_refs`),
-        };
-    });
-}
-export function parseDesignResourceHandoffTargets(value) {
-    return array(value, "design_resource_handoff.targets").map((item, index) => {
-        const label = `design_resource_handoff.targets[${index}]`;
-        const row = object(item, label, [
-            "key",
-            "interpretation",
-            "resource_refs",
-            "condition_refs",
-            "source_profile",
-            "selection_basis",
-        ]);
-        const sourceProfile = object(row.source_profile, `${label}.source_profile`, [
-            "kind",
-            "entry_resource_ref",
-            "dependency_resource_refs",
-            "fact_manifest_resource_ref",
-            "acquisition",
-        ]);
-        return {
-            key: contractKey(row.key, `${label}.key`),
-            interpretation: literal(row.interpretation, ["exact_target", "constraint"], `${label}.interpretation`),
-            resource_refs: stableKeys(row.resource_refs, `${label}.resource_refs`),
-            condition_refs: contractKeys(row.condition_refs, `${label}.condition_refs`),
-            source_profile: {
-                kind: literal(sourceProfile.kind, ["implementation_web", "implementation_app", "reference"], `${label}.source_profile.kind`),
-                entry_resource_ref: stableKey(sourceProfile.entry_resource_ref, `${label}.source_profile.entry_resource_ref`),
-                dependency_resource_refs: stableKeys(sourceProfile.dependency_resource_refs, `${label}.source_profile.dependency_resource_refs`),
-                fact_manifest_resource_ref: stableKey(sourceProfile.fact_manifest_resource_ref, `${label}.source_profile.fact_manifest_resource_ref`),
-                acquisition: literal(sourceProfile.acquisition, ["complete"], `${label}.source_profile.acquisition`),
-            },
-            selection_basis: string(row.selection_basis, `${label}.selection_basis`),
-        };
-    });
-}

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

@@ -1,6 +0,0 @@
-import type { DesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
-import type { DesignResourceHandoffInput } from "./design-resource-handoff-input-types.js";
-import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
-export declare function parseDesignResourceHandoffInputShape(value: unknown): DesignResourceHandoffInputV1;
-export declare function parseAnyDesignResourceHandoffInputShape(value: unknown): DesignResourceHandoffInput;
-export declare function parseDesignResourceHandoffShape(value: unknown): DesignResourceHandoffV1;