project-tiny-context-harness 0.8.16 → 0.11.0

package/dist/lib/design-md-tool-normalization.js

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { stableJson } from "./stable-json.js";
+export function loadDesignMdToolIdentity() {
+    let directory = path.dirname(fileURLToPath(import.meta.resolve("@google/design.md")));
+    for (let depth = 0; depth < 4; depth += 1) {
+        const packagePath = path.join(directory, "package.json");
+        if (existsSync(packagePath)) {
+            const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
+            if (parsed.name === "@google/design.md" &&
+                typeof parsed.version === "string") {
+                return {
+                    package_name: "@google/design.md",
+                    package_version: parsed.version,
+                    api_surface: "@google/design.md/linter",
+                };
+            }
+        }
+        directory = path.dirname(directory);
+    }
+    throw new Error("unable to resolve @google/design.md package identity");
+}
+export function normalizeDesignMdFinding(finding) {
+    return {
+        severity: finding.severity,
+        ...(finding.path ? { path: finding.path } : {}),
+        message: finding.message,
+        ...(finding.rule ? { rule: finding.rule } : {}),
+    };
+}
+export function snapshotDesignSystem(state) {
+    return {
+        ...(state.name ? { name: state.name } : {}),
+        ...(state.description ? { description: state.description } : {}),
+        colors: mapToRecord(state.colors),
+        typography: mapToRecord(state.typography),
+        rounded: mapToRecord(state.rounded),
+        spacing: mapToRecord(state.spacing),
+        components: Object.fromEntries([...state.components.entries()]
+            .sort(([left], [right]) => compareText(left, right))
+            .map(([key, component]) => [
+            key,
+            {
+                properties: mapToRecord(component.properties),
+                unresolved_refs: [...component.unresolvedRefs].sort(compareText),
+            },
+        ])),
+        sections: [...(state.sections ?? [])],
+        unknown_keys: [...(state.unknownKeys ?? [])].sort(compareText),
+    };
+}
+export function componentProperties(components) {
+    return Object.fromEntries(Object.entries(components).map(([key, component]) => [
+        key,
+        component.properties,
+    ]));
+}
+export function diffDesignMdRecords(before, after) {
+    const beforeKeys = Object.keys(before).sort(compareText);
+    const afterKeys = Object.keys(after).sort(compareText);
+    return {
+        added: afterKeys.filter((key) => !(key in before)),
+        removed: beforeKeys.filter((key) => !(key in after)),
+        modified: afterKeys.filter((key) => key in before && stableJson(before[key]) !== stableJson(after[key])),
+    };
+}
+function mapToRecord(map) {
+    return Object.fromEntries([...map.entries()]
+        .sort(([left], [right]) => compareText(left, right))
+        .map(([key, value]) => [key, toJsonValue(value)]));
+}
+function toJsonValue(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/lib/design-md-tool-types.d.ts

@@ -0,0 +1,99 @@
+export declare const DESIGN_MD_TOOL_ADAPTER_SCHEMA_VERSION = 1;
+export declare const DESIGN_MD_EXPORT_FORMATS: readonly ["json-tailwind", "css-tailwind", "tailwind", "dtcg", "css-vars"];
+export type DesignMdExportFormat = (typeof DESIGN_MD_EXPORT_FORMATS)[number];
+export type DesignMdValidationMode = "parse-validate" | "lint";
+export type DesignMdFindingSeverity = "error" | "warning" | "info";
+export interface DesignMdToolIdentity {
+    package_name: "@google/design.md";
+    package_version: string;
+    api_surface: "@google/design.md/linter";
+}
+export interface DesignMdFinding {
+    severity: DesignMdFindingSeverity;
+    path?: string;
+    message: string;
+    rule?: string;
+}
+export interface DesignMdFindingSummary {
+    errors: number;
+    warnings: number;
+    infos: number;
+}
+export interface DesignMdComponentSnapshot {
+    properties: Record<string, unknown>;
+    unresolved_refs: string[];
+}
+export interface DesignMdSystemSnapshot {
+    name?: string;
+    description?: string;
+    colors: Record<string, unknown>;
+    typography: Record<string, unknown>;
+    rounded: Record<string, unknown>;
+    spacing: Record<string, unknown>;
+    components: Record<string, DesignMdComponentSnapshot>;
+    sections: string[];
+    unknown_keys: string[];
+}
+export interface DesignMdValidationResult {
+    schema_version: typeof DESIGN_MD_TOOL_ADAPTER_SCHEMA_VERSION;
+    mode: DesignMdValidationMode;
+    tool: DesignMdToolIdentity;
+    valid: boolean;
+    findings: DesignMdFinding[];
+    summary: DesignMdFindingSummary;
+    design_system: DesignMdSystemSnapshot | null;
+}
+export interface DesignMdExportSuccess {
+    success: true;
+    format: DesignMdExportFormat;
+    media_type: "application/json" | "text/css";
+    content: string;
+    options: DesignMdExportOptions;
+    validation: DesignMdValidationResult;
+}
+export interface DesignMdExportFailure {
+    success: false;
+    format: DesignMdExportFormat;
+    error: string;
+    options: DesignMdExportOptions;
+    validation: DesignMdValidationResult;
+}
+export interface DesignMdExportOptions {
+    css_variable_prefix?: string;
+}
+export type DesignMdExportResult = DesignMdExportSuccess | DesignMdExportFailure;
+export interface DesignMdTokenChangeSet {
+    added: string[];
+    removed: string[];
+    modified: string[];
+}
+export interface DesignMdDiffSuccess {
+    success: true;
+    tool: DesignMdToolIdentity;
+    tokens: {
+        colors: DesignMdTokenChangeSet;
+        typography: DesignMdTokenChangeSet;
+        rounded: DesignMdTokenChangeSet;
+        spacing: DesignMdTokenChangeSet;
+        components: DesignMdTokenChangeSet;
+    };
+    findings: {
+        before: DesignMdFindingSummary;
+        after: DesignMdFindingSummary;
+        delta: {
+            errors: number;
+            warnings: number;
+        };
+    };
+    regression: boolean;
+    before_validation: DesignMdValidationResult;
+    after_validation: DesignMdValidationResult;
+}
+export interface DesignMdDiffFailure {
+    success: false;
+    tool: DesignMdToolIdentity;
+    error: string;
+    before_validation: DesignMdValidationResult;
+    after_validation: DesignMdValidationResult;
+}
+export type DesignMdDiffResult = DesignMdDiffSuccess | DesignMdDiffFailure;

package/dist/lib/design-md-tool-types.js

@@ -0,0 +1,8 @@
+export const DESIGN_MD_TOOL_ADAPTER_SCHEMA_VERSION = 1;
+export const DESIGN_MD_EXPORT_FORMATS = [
+    "json-tailwind",
+    "css-tailwind",
+    "tailwind",
+    "dtcg",
+    "css-vars",
+];

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

@@ -43,6 +43,11 @@ export async function publishDesignResourceHandoffBundle(options) {
             if (!declaredManifestPaths.has(manifestResource.path))
                 invalid("target_manifest_not_declared", `${declaredTarget.key}:${manifestResource.path}`);
             const preflight = await preflightParsedDesignResourceHandoff(repository, parsed);
+            const publishedTarget = preflight.handoff.targets[0];
+            if ((publishedTarget.source_profile.kind === "implementation_web" ||
+                publishedTarget.source_profile.kind === "implementation_app") &&
+                preflight.technical_feasibility_identities.length !== 1)
+                invalid("implementation_feasibility_input_required", `${publishedTarget.key}:${preflight.technical_feasibility_identities.length}`);
             handoffSetIntegrity.consume(preflight);
             const targetKey = preflight.handoff.targets[0].key;
             if (seenTargets.has(targetKey))

package/dist/lib/design-resource-handoff-input-types.d.ts

@@ -1,6 +1,6 @@
 import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
 import type { DesignResourceHandoffV2, ParsedDesignResourceHandoffV2 } from "./design-resource-symbolic-fact-types.js";
-export type DesignResourceHandoffManifestBackedV1 = Pick<DesignResourceHandoffV1, "schema_version" | "intent" | "scope" | "provenance" | "resources" | "targets" | "resource_fact_closure" | "coverage" | "proposal"> & {
+export type DesignResourceHandoffManifestBackedV1 = Pick<DesignResourceHandoffV1, "schema_version" | "intent" | "scope" | "provenance" | "project_design_authority" | "technical_feasibility_inputs" | "resources" | "targets" | "resource_fact_closure" | "coverage" | "proposal"> & {
     representation: "manifest_backed";
 };
 export type DesignResourceHandoffInputV1 = DesignResourceHandoffV1 | DesignResourceHandoffManifestBackedV1;

package/dist/lib/design-resource-handoff-manifest-projection.js

@@ -11,6 +11,10 @@ export function hydrateManifestBackedDesignResourceHandoff(descriptor, manifests
         intent: descriptor.intent,
         scope: descriptor.scope,
         provenance: descriptor.provenance,
+        ...(descriptor.project_design_authority === undefined
+            ? {}
+            : { project_design_authority: descriptor.project_design_authority }),
+        technical_feasibility_inputs: descriptor.technical_feasibility_inputs,
         resources: descriptor.resources,
         axis_dispositions: manifest.axis_dispositions,
         condition_exclusions: manifest.condition_exclusions,

package/dist/lib/design-resource-handoff-set-integrity.js

@@ -35,6 +35,7 @@ export function createDesignResourceHandoffSetIntegrity(fail) {
             sharedHeader(scope, "provenance", handoff.provenance);
             sharedHeader(scope, "proposal", handoff.proposal);
             sharedCollection(scope, "resources", handoff.resources);
+            sharedCollection(scope, "technical_feasibility_inputs", handoff.technical_feasibility_inputs);
             sharedCollection(scope, "conditions", handoff.conditions);
             sharedCollection(scope, "properties", handoff.properties);
             sharedCollection(scope, "resource_fact_closure", handoff.resource_fact_closure);

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

@@ -1,4 +1,6 @@
 import { parseDesignResourceSymbolicHandoffShape } from "./design-resource-symbolic-fact-shape.js";
+import { parseDesignResourceTechnicalFeasibilityInputs } from "./design-resource-implementation-feasibility-shape.js";
+import { parseDesignAuthorityHandoffBinding } from "./design-authority-binding.js";
 import { parseDesignResourceAssetBindings, parseDesignResourceAxisDispositions, parseDesignResourceConditionExclusions, parseDesignResourceEnvironments, parseDesignResourceFactCells, parseDesignResourceLineageNodes, parseDesignResourceOracles, parseDesignResourceProofObligations, parseDesignResourceProperties, parseDesignResourceVariationAxisDispositions, parseDesignResourceVariationExclusions, parseDesignResourceVariations, } from "./design-resource-fact-manifest-shape.js";
 import { parseDesignResourceHandoffBlockers, parseDesignResourceHandoffCoverage, parseDesignResourceHandoffEvidence, parseDesignResourceHandoffFacts, parseDesignResourceHandoffResourceFactClosure, } from "./design-resource-handoff-shape-evidence.js";
 import { contractKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
@@ -49,7 +51,7 @@ export function parseDesignResourceHandoffShape(value) {
         "coverage",
         "acceptance_blockers",
         "proposal",
-    ]);
+    ], ["technical_feasibility_inputs", "project_design_authority"]);
     const scope = object(root.scope, "design_resource_handoff.scope", [
         "key",
         "style_dependency",
@@ -92,6 +94,12 @@ export function parseDesignResourceHandoffShape(value) {
             model: string(provenance.model, "design_resource_handoff.provenance.model"),
             design_system_id: string(provenance.design_system_id, "design_resource_handoff.provenance.design_system_id"),
         },
+        ...(root.project_design_authority === undefined
+            ? {}
+            : {
+                project_design_authority: parseDesignAuthorityHandoffBinding(root.project_design_authority, "design_resource_handoff.project_design_authority"),
+            }),
+        technical_feasibility_inputs: parseDesignResourceTechnicalFeasibilityInputs(root.technical_feasibility_inputs ?? []),
         resources: parseDesignResourceHandoffResources(root.resources),
         axis_dispositions: parseDesignResourceAxisDispositions(root.axis_dispositions),
         condition_exclusions: parseDesignResourceConditionExclusions(root.condition_exclusions),
@@ -132,12 +140,16 @@ function parseManifestBackedDesignResourceHandoffShape(value) {
         "resource_fact_closure",
         "coverage",
         "proposal",
-    ]);
+    ], ["technical_feasibility_inputs", "project_design_authority"]);
     const parsed = parseDesignResourceHandoffShape({
         schema_version: root.schema_version,
         intent: root.intent,
         scope: root.scope,
         provenance: root.provenance,
+        ...(root.project_design_authority === undefined
+            ? {}
+            : { project_design_authority: root.project_design_authority }),
+        technical_feasibility_inputs: root.technical_feasibility_inputs ?? [],
         resources: root.resources,
         axis_dispositions: [],
         condition_exclusions: [],
@@ -167,6 +179,10 @@ function parseManifestBackedDesignResourceHandoffShape(value) {
         intent: parsed.intent,
         scope: parsed.scope,
         provenance: parsed.provenance,
+        ...(parsed.project_design_authority === undefined
+            ? {}
+            : { project_design_authority: parsed.project_design_authority }),
+        technical_feasibility_inputs: parsed.technical_feasibility_inputs,
         resources: parsed.resources,
         targets: parsed.targets,
         resource_fact_closure: parsed.resource_fact_closure,

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

@@ -1,5 +1,7 @@
 import type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
 import type { DesignResourceAssetBindingV1, DesignResourceAxisDispositionV1, DesignResourceConditionCombinationDispositionV1, DesignResourceEnvironmentV1, DesignResourceFactCellV1, DesignResourceFactV1, DesignResourceLineageNodeV1, DesignResourceManifestCollectionName, DesignResourceOracleV1, DesignResourcePropertyDefinitionV1, DesignResourceProofObligationV1, DesignResourceRelationEndpointV1, DesignResourceSubjectKind, DesignResourceSubjectPresenceKind, DesignResourceSubjectVariationV1, DesignResourceVariationAxisDispositionV1, DesignResourceVariationCombinationDispositionV1 } from "./design-resource-fact-manifest-types.js";
+import type { DesignResourceImplementationFeasibilityIdentityV1, DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalFeasibilityInputV1 } from "./design-resource-implementation-feasibility-types.js";
+import type { DesignAuthorityHandoffBinding, DesignAuthorityHandoffResolution } from "./design-authority-types.js";
 export declare const DESIGN_RESOURCE_DIMENSIONS: readonly ["surface_flow", "visual_content", "component_control", "state_interaction", "motion", "adaptation_input", "accessibility", "assets"];
 export type DesignResourceDimension = (typeof DESIGN_RESOURCE_DIMENSIONS)[number];
 export declare const DESIGN_RESOURCE_EVIDENCE_KINDS: readonly ["frame", "component_variant", "prototype_state", "prototype_transition", "motion_spec", "motion_capture", "responsive_spec", "input_spec", "accessibility_spec", "semantic_tree", "token_spec", "asset", "annotation", "localization_spec", "system_ui_spec", "haptic_spec", "sound_spec", "sound_capture", "render_environment", "relation_spec"];
@@ -30,6 +32,8 @@ export interface DesignResourceHandoffV1 {
         model: string;
         design_system_id: string;
     };
+    project_design_authority?: DesignAuthorityHandoffBinding;
+    technical_feasibility_inputs: DesignResourceTechnicalFeasibilityInputV1[];
     resources: DesignResourceHandoffResourceV1[];
     axis_dispositions: DesignResourceAxisDispositionV1[];
     condition_exclusions: DesignResourceConditionCombinationDispositionV1[];
@@ -219,7 +223,11 @@ export interface ParsedDesignResourceHandoffV1 {
 export interface DesignResourceHandoffPreflightV1 extends ParsedDesignResourceHandoffV1 {
     schema_version: "design-resource-handoff-preflight-v1";
     status: "ready";
+    project_design_authority_resolution: DesignAuthorityHandoffResolution;
     resource_hashes: Record<string, string>;
+    technical_feasibility_documents: DesignResourceImplementationFeasibilityV1[];
+    technical_feasibility_identities: DesignResourceImplementationFeasibilityIdentityV1[];
+    limitations: string[];
     manifest_identities: Array<{
         resource_ref: string;
         path: string;

package/dist/lib/design-resource-handoff-validation.js

@@ -12,6 +12,9 @@ import { indexDesignResourceItems, invalidDesignResourceHandoff, requireNonempty
 import { validateDesignResourceConditions, validateDesignResourceEvidence, validateDesignResourceScope, validateDesignResourceSubjects, validateDesignResourceTargets, } from "./design-resource-handoff-validation-structure.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { assertDesignResourceV1HandoffCapacity } from "./design-resource-v1-capacity.js";
+import { createV1ImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
+import { readAndValidateDesignResourceImplementationFeasibility } from "./design-resource-implementation-feasibility-validation.js";
+import { resolveDesignAuthorityHandoffBinding } from "./design-authority-binding.js";
 export async function preflightDesignResourceHandoff(repository, handoffPath) {
     const handoffFile = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...handoffPath.split("/")), "design_resource_handoff");
     await assertDesignResourceV1HandoffCapacity(handoffFile);
@@ -28,6 +31,11 @@ function isParsedSymbolicHandoff(parsed) {
 }
 export async function preflightParsedDesignResourceHandoff(repository, parsed) {
     const inputHandoff = parsed.handoff;
+    const authorityResolution = await resolveDesignAuthorityHandoffBinding({
+        repository,
+        style_dependency: inputHandoff.scope.style_dependency,
+        binding: inputHandoff.project_design_authority,
+    });
     if (isManifestBacked(inputHandoff) && inputHandoff.targets.length !== 1)
         invalidDesignResourceHandoff("manifest_backed_one_target_required", String(inputHandoff.targets.length));
     if (!isManifestBacked(inputHandoff))
@@ -46,11 +54,27 @@ export async function preflightParsedDesignResourceHandoff(repository, parsed) {
     validateDesignResourceFiles(normalized, snapshot.contents);
     validateDesignResourceFactManifests(normalized, snapshot.contents, manifests, !isManifestBacked(inputHandoff));
     const resources = new Map(handoff.resources.map((resource) => [resource.key, resource]));
+    const feasibility = await readAndValidateDesignResourceImplementationFeasibility(repository, parsed.handoff_path, handoff.technical_feasibility_inputs, new Map(handoff.targets.map((target) => [
+        target.key,
+        createV1ImplementationFeasibilityTargetModel(handoff, target),
+    ])), new Set(handoff.resources.map((resource) => resource.path)));
     return {
         schema_version: "design-resource-handoff-preflight-v1",
         status: "ready",
+        project_design_authority_resolution: authorityResolution,
         ...normalized,
         resource_hashes: snapshot.hashes,
+        technical_feasibility_documents: feasibility.map((item) => item.document),
+        technical_feasibility_identities: feasibility.map((item) => item.identity),
+        limitations: [
+            ...(authorityResolution.compatibility_derived
+                ? ["project Design Authority identity derived from legacy DESIGN.md"]
+                : []),
+            ...(handoff.targets.some((target) => target.source_profile.kind !== "reference" &&
+                !feasibility.some((item) => item.index.target_ref === target.key))
+                ? ["technical feasibility not declared"]
+                : []),
+        ],
         manifest_identities: handoff.targets.map((target) => {
             const resourceRef = target.source_profile.fact_manifest_resource_ref;
             const resource = resources.get(resourceRef);

package/dist/lib/design-resource-implementation-feasibility-model.d.ts

@@ -0,0 +1,35 @@
+import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+import type { DesignResourceObservableRuleManifestV2, DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicHandoffTargetV2 } from "./design-resource-symbolic-fact-types.js";
+import type { SymbolicDenotationAxisDomain, SymbolicDenotationPredicate } from "./symbolic-denotation-types.js";
+interface FeasibilityTargetModelBase {
+    target_ref: string;
+    source_profile_kind: "implementation_web" | "implementation_app" | "reference";
+    component_family_refs: string[];
+    component_family_subject_refs: Map<string, Set<string>>;
+}
+export interface DesignResourceImplementationFeasibilityV1TargetModel extends FeasibilityTargetModelBase {
+    representation: "fact_cells_v1";
+    condition_refs: string[];
+    facts: Map<string, {
+        target_ref: string;
+        subject_ref: string;
+        condition_ref: string;
+    }>;
+}
+export interface DesignResourceImplementationFeasibilityV2TargetModel extends FeasibilityTargetModelBase {
+    representation: "symbolic_rules_v2";
+    axis_domains: SymbolicDenotationAxisDomain[];
+    reachable_region: SymbolicDenotationPredicate;
+    fact_rules: Map<string, DesignResourceSymbolicFactRuleV2>;
+}
+export type DesignResourceImplementationFeasibilityTargetModel = DesignResourceImplementationFeasibilityV1TargetModel | DesignResourceImplementationFeasibilityV2TargetModel;
+export declare function createV1ImplementationFeasibilityTargetModel(handoff: DesignResourceHandoffV1, target: DesignResourceHandoffV1["targets"][number]): DesignResourceImplementationFeasibilityV1TargetModel;
+export declare function createV2ImplementationFeasibilityTargetModel(target: DesignResourceSymbolicHandoffTargetV2, manifest: DesignResourceObservableRuleManifestV2): DesignResourceImplementationFeasibilityV2TargetModel;
+export declare function deriveComponentFamilySubjectClosure(familyRefs: string[], subjects: Array<{
+    key: string;
+    family_ref: string | null;
+    parent_ref: string | null;
+    instance_of_ref: string | null;
+    override_of_ref: string | null;
+}>): Map<string, Set<string>>;
+export {};

package/dist/lib/design-resource-implementation-feasibility-model.js

@@ -0,0 +1,62 @@
+export function createV1ImplementationFeasibilityTargetModel(handoff, target) {
+    const componentFamilies = handoff.subjects.filter((subject) => subject.kind === "component_family" &&
+        subject.target_refs.includes(target.key));
+    return {
+        representation: "fact_cells_v1",
+        target_ref: target.key,
+        source_profile_kind: target.source_profile.kind,
+        component_family_refs: componentFamilies.map((subject) => subject.key),
+        component_family_subject_refs: deriveComponentFamilySubjectClosure(componentFamilies.map((subject) => subject.key), handoff.subjects),
+        condition_refs: [...target.condition_refs],
+        facts: new Map(handoff.facts.map((fact) => [
+            fact.key,
+            {
+                target_ref: fact.target_ref,
+                subject_ref: fact.subject_ref,
+                condition_ref: fact.condition_ref,
+            },
+        ])),
+    };
+}
+export function createV2ImplementationFeasibilityTargetModel(target, manifest) {
+    const componentFamilies = manifest.subjects.filter((subject) => subject.kind === "component_family" &&
+        subject.target_refs.includes(target.key));
+    return {
+        representation: "symbolic_rules_v2",
+        target_ref: target.key,
+        source_profile_kind: target.source_profile.kind,
+        component_family_refs: componentFamilies.map((subject) => subject.key),
+        component_family_subject_refs: deriveComponentFamilySubjectClosure(componentFamilies.map((subject) => subject.key), manifest.subjects),
+        axis_domains: manifest.axis_domains,
+        reachable_region: manifest.reachable_region,
+        fact_rules: new Map(manifest.fact_rules.map((rule) => [rule.key, rule])),
+    };
+}
+export function deriveComponentFamilySubjectClosure(familyRefs, subjects) {
+    const result = new Map();
+    for (const familyRef of familyRefs) {
+        const closure = new Set(subjects
+            .filter((subject) => subject.key === familyRef ||
+            subject.family_ref === familyRef ||
+            subject.instance_of_ref === familyRef)
+            .map((subject) => subject.key));
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const subject of subjects) {
+                if (closure.has(subject.key))
+                    continue;
+                if ((subject.parent_ref !== null && closure.has(subject.parent_ref)) ||
+                    (subject.instance_of_ref !== null &&
+                        closure.has(subject.instance_of_ref)) ||
+                    (subject.override_of_ref !== null &&
+                        closure.has(subject.override_of_ref))) {
+                    closure.add(subject.key);
+                    changed = true;
+                }
+            }
+        }
+        result.set(familyRef, closure);
+    }
+    return result;
+}

package/dist/lib/design-resource-implementation-feasibility-shape-sections.d.ts

@@ -0,0 +1,43 @@
+import { type DesignResourceImplementationConditionModelV1 } from "./design-resource-implementation-feasibility-types.js";
+export declare function parseConditionModel(value: unknown, label: string): DesignResourceImplementationConditionModelV1;
+export declare function parseComponentFamilyCells(value: unknown, label: string): {
+    key: string;
+    component_family_ref: string;
+    target_ref: string;
+    condition_profile_ref: string;
+    design_fact_refs: string[];
+    feasible_realizations: {
+        key: string;
+        strategy_steps: ("compose_existing" | "create_shared_component" | "extend_shared_component" | "reuse_existing" | "theme_with_tokens")[];
+        primitive_refs: string[];
+        owner_candidates: ({
+            kind: "existing_path";
+            locator: string;
+            existence: "existing";
+            authorization_source_refs?: undefined;
+        } | {
+            kind: "planned_logical_owner";
+            locator: string;
+            existence: "planned";
+            authorization_source_refs: string[];
+        })[];
+        supported_customization_surfaces: ("behavior_slot" | "component_variant" | "composition" | "content_slot" | "icon_slot" | "primitive_props" | "style_api" | "theme_tokens")[];
+        feasibility_basis_refs: string[];
+        observed_costs: string[];
+        observed_risks: string[];
+    }[];
+    required_realization: {
+        realization_ref: string | null;
+        technical_authority_source_refs: string[];
+    };
+    blocker_refs: string[];
+}[];
+export declare function parseBlockers(value: unknown, label: string): {
+    key: string;
+    component_family_ref: string;
+    target_ref: string;
+    condition_profile_ref: string;
+    source_record_refs: string[];
+    substrate_observation_refs: ("component_owner_roots" | "framework_runtime" | "platform" | "route_owner_roots" | "token_theming_adapter" | "ui_system")[];
+    description: string;
+}[];

package/dist/lib/design-resource-implementation-feasibility-shape-sections.js

@@ -0,0 +1,142 @@
+import { DESIGN_RESOURCE_CUSTOMIZATION_SURFACES, DESIGN_RESOURCE_IMPLEMENTATION_STRATEGY_STEPS, DESIGN_RESOURCE_SUBSTRATE_OBSERVATION_KINDS, } from "./design-resource-implementation-feasibility-types.js";
+import { parseSymbolicPredicate } from "./design-resource-symbolic-predicate-shape.js";
+import { contractKey, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { array, literal, nullable, object, repositoryFile, string, strings, } from "./long-task-shape-primitives.js";
+export function parseConditionModel(value, label) {
+    const itemLabel = `${label}.condition_model`;
+    const kind = object(value, itemLabel, ["kind", "profiles"]).kind;
+    if (kind === "explicit_conditions_v1") {
+        const row = object(value, itemLabel, ["kind", "profiles"]);
+        return {
+            kind: literal(row.kind, ["explicit_conditions_v1"], `${itemLabel}.kind`),
+            profiles: array(row.profiles, `${itemLabel}.profiles`).map((profile, index) => {
+                const profileLabel = `${itemLabel}.profiles[${index}]`;
+                const profileRow = object(profile, profileLabel, [
+                    "key",
+                    "condition_refs",
+                ]);
+                return {
+                    key: stableKey(profileRow.key, `${profileLabel}.key`),
+                    condition_refs: stableKeys(profileRow.condition_refs, `${profileLabel}.condition_refs`),
+                };
+            }),
+        };
+    }
+    const row = object(value, itemLabel, ["kind", "profiles"]);
+    return {
+        kind: literal(row.kind, ["symbolic_regions_v2"], `${itemLabel}.kind`),
+        profiles: array(row.profiles, `${itemLabel}.profiles`).map((profile, index) => {
+            const profileLabel = `${itemLabel}.profiles[${index}]`;
+            const profileRow = object(profile, profileLabel, ["key", "region"]);
+            return {
+                key: stableKey(profileRow.key, `${profileLabel}.key`),
+                region: parseSymbolicPredicate(profileRow.region, `${profileLabel}.region`),
+            };
+        }),
+    };
+}
+export function parseComponentFamilyCells(value, label) {
+    return array(value, `${label}.component_family_cells`).map((item, index) => {
+        const itemLabel = `${label}.component_family_cells[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "component_family_ref",
+            "target_ref",
+            "condition_profile_ref",
+            "design_fact_refs",
+            "feasible_realizations",
+            "required_realization",
+            "blocker_refs",
+        ]);
+        const required = object(row.required_realization, `${itemLabel}.required_realization`, ["realization_ref", "technical_authority_source_refs"]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            component_family_ref: stableKey(row.component_family_ref, `${itemLabel}.component_family_ref`),
+            target_ref: contractKey(row.target_ref, `${itemLabel}.target_ref`),
+            condition_profile_ref: stableKey(row.condition_profile_ref, `${itemLabel}.condition_profile_ref`),
+            design_fact_refs: stableKeys(row.design_fact_refs, `${itemLabel}.design_fact_refs`),
+            feasible_realizations: parseRealizations(row.feasible_realizations, itemLabel),
+            required_realization: {
+                realization_ref: nullable(required.realization_ref, (entry) => stableKey(entry, `${itemLabel}.required_realization.realization_ref`)),
+                technical_authority_source_refs: stableKeys(required.technical_authority_source_refs, `${itemLabel}.required_realization.technical_authority_source_refs`),
+            },
+            blocker_refs: stableKeys(row.blocker_refs, `${itemLabel}.blocker_refs`),
+        };
+    });
+}
+function parseRealizations(value, label) {
+    return array(value, `${label}.feasible_realizations`).map((item, index) => {
+        const itemLabel = `${label}.feasible_realizations[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "strategy_steps",
+            "primitive_refs",
+            "owner_candidates",
+            "supported_customization_surfaces",
+            "feasibility_basis_refs",
+            "observed_costs",
+            "observed_risks",
+        ]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            strategy_steps: array(row.strategy_steps, `${itemLabel}.strategy_steps`).map((step, stepIndex) => literal(step, DESIGN_RESOURCE_IMPLEMENTATION_STRATEGY_STEPS, `${itemLabel}.strategy_steps[${stepIndex}]`)),
+            primitive_refs: stableKeys(row.primitive_refs, `${itemLabel}.primitive_refs`),
+            owner_candidates: parseOwnerCandidates(row.owner_candidates, itemLabel),
+            supported_customization_surfaces: array(row.supported_customization_surfaces, `${itemLabel}.supported_customization_surfaces`).map((surface, surfaceIndex) => literal(surface, DESIGN_RESOURCE_CUSTOMIZATION_SURFACES, `${itemLabel}.supported_customization_surfaces[${surfaceIndex}]`)),
+            feasibility_basis_refs: stableKeys(row.feasibility_basis_refs, `${itemLabel}.feasibility_basis_refs`),
+            observed_costs: strings(row.observed_costs, `${itemLabel}.observed_costs`),
+            observed_risks: strings(row.observed_risks, `${itemLabel}.observed_risks`),
+        };
+    });
+}
+function parseOwnerCandidates(value, label) {
+    return array(value, `${label}.owner_candidates`).map((item, index) => {
+        const itemLabel = `${label}.owner_candidates[${index}]`;
+        const kind = object(item, itemLabel, ["kind", "locator", "existence"], ["authorization_source_refs"]).kind;
+        if (kind === "existing_path") {
+            const row = object(item, itemLabel, ["kind", "locator", "existence"]);
+            return {
+                kind: literal(row.kind, ["existing_path"], `${itemLabel}.kind`),
+                locator: repositoryFile(row.locator, `${itemLabel}.locator`),
+                existence: literal(row.existence, ["existing"], `${itemLabel}.existence`),
+            };
+        }
+        const row = object(item, itemLabel, [
+            "kind",
+            "locator",
+            "existence",
+            "authorization_source_refs",
+        ]);
+        return {
+            kind: literal(row.kind, ["planned_logical_owner"], `${itemLabel}.kind`),
+            locator: stableKey(row.locator, `${itemLabel}.locator`),
+            existence: literal(row.existence, ["planned"], `${itemLabel}.existence`),
+            authorization_source_refs: stableKeys(row.authorization_source_refs, `${itemLabel}.authorization_source_refs`),
+        };
+    });
+}
+export function parseBlockers(value, label) {
+    return array(value, `${label}.blockers`).map((item, index) => {
+        const itemLabel = `${label}.blockers[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "component_family_ref",
+            "target_ref",
+            "condition_profile_ref",
+            "source_record_refs",
+            "substrate_observation_refs",
+            "description",
+        ]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            component_family_ref: stableKey(row.component_family_ref, `${itemLabel}.component_family_ref`),
+            target_ref: contractKey(row.target_ref, `${itemLabel}.target_ref`),
+            condition_profile_ref: stableKey(row.condition_profile_ref, `${itemLabel}.condition_profile_ref`),
+            source_record_refs: stableKeys(row.source_record_refs, `${itemLabel}.source_record_refs`),
+            substrate_observation_refs: array(row.substrate_observation_refs, `${itemLabel}.substrate_observation_refs`)
+                .map((observationRef, observationIndex) => literal(observationRef, DESIGN_RESOURCE_SUBSTRATE_OBSERVATION_KINDS, `${itemLabel}.substrate_observation_refs[${observationIndex}]`))
+                .sort(),
+            description: string(row.description, `${itemLabel}.description`),
+        };
+    });
+}