project-tiny-context-harness 0.8.16 → 0.11.0

package/dist/lib/design-resource-implementation-feasibility-validation-cells.js

@@ -0,0 +1,125 @@
+import { validateDesignFactRefs } from "./design-resource-implementation-feasibility-validation-facts.js";
+import { validateFeasibleRealization, validateRequiredRealization, } from "./design-resource-implementation-feasibility-validation-realizations.js";
+import { assertSameSet, cellPair, invalidFeasibility, requireKnownRefs, unique, } from "./design-resource-implementation-feasibility-validation-support.js";
+import { DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA, deriveDesignResourceFeasibilityConditionScopeSha256, requireExactFeasibilityDecisionProjection, } from "./design-resource-implementation-feasibility-source-decision.js";
+export async function validateFeasibilityCells(repository, document, model, profileRefs, sources, decisionSources) {
+    unique(document.component_family_cells.map((item) => item.key), "cell_key_duplicate");
+    unique(document.blockers.map((item) => item.key), "blocker_key_duplicate");
+    const families = new Set(model.component_family_refs);
+    const blockers = new Map(document.blockers.map((item) => [item.key, item]));
+    const componentOwnerObservation = document.substrate_observations.find((observation) => observation.kind === "component_owner_roots");
+    const componentOwnerRoots = componentOwnerObservation?.value?.kind === "repository_paths"
+        ? componentOwnerObservation.value.paths
+        : [];
+    const usedBlockers = new Set();
+    const cellPairs = [];
+    const realizationKeys = [];
+    for (const cell of document.component_family_cells) {
+        cellPairs.push(cellPair(cell.component_family_ref, cell.condition_profile_ref));
+        await validateCell(repository, cell, document, model, families, profileRefs, sources, decisionSources, componentOwnerRoots, blockers, usedBlockers, realizationKeys);
+    }
+    unique(cellPairs, "component_family_condition_cell_duplicate");
+    unique(realizationKeys, "realization_key_duplicate");
+    if (document.realization_mode !== "reference") {
+        const expected = model.component_family_refs.flatMap((familyRef) => [...profileRefs].map((profileRef) => cellPair(familyRef, profileRef)));
+        assertSameSet(cellPairs, expected, "component_family_condition_cell_set_mismatch");
+    }
+    validateBlockers(document, model, families, profileRefs, sources, decisionSources, usedBlockers);
+    validateSubstrateObservationBlockerCoverage(document, model);
+}
+export function validateSubstrateObservationBlockerCoverage(document, model) {
+    const observations = new Map(document.substrate_observations.map((observation) => [
+        observation.kind,
+        observation,
+    ]));
+    const blockers = new Map(document.blockers.map((blocker) => [blocker.key, blocker]));
+    for (const blocker of document.blockers) {
+        unique(blocker.substrate_observation_refs, "blocker_substrate_observation_ref_duplicate", blocker.key);
+        for (const observationRef of blocker.substrate_observation_refs) {
+            const observation = observations.get(observationRef);
+            if (!observation ||
+                !["decision_required", "unavailable"].includes(observation.disposition))
+                invalidFeasibility("blocker_substrate_observation_not_unresolved", `${blocker.key}:${observationRef}`);
+        }
+    }
+    const unresolved = document.substrate_observations.filter((observation) => ["decision_required", "unavailable"].includes(observation.disposition));
+    if (unresolved.length && model.component_family_refs.length === 0)
+        invalidFeasibility("unresolved_substrate_without_family_carrier", unresolved.map((observation) => observation.kind).join(","));
+    for (const cell of document.component_family_cells)
+        for (const observation of unresolved)
+            if (!cell.blocker_refs.some((blockerRef) => blockers
+                .get(blockerRef)
+                ?.substrate_observation_refs.includes(observation.kind)))
+                invalidFeasibility("unresolved_substrate_observation_cell_uncovered", `${observation.kind}:${cell.key}`);
+}
+async function validateCell(repository, cell, document, model, families, profileRefs, sources, decisionSources, componentOwnerRoots, blockers, usedBlockers, realizationKeys) {
+    validateCellIdentity(cell, document.target_ref, families, profileRefs);
+    unique(cell.design_fact_refs, "cell_design_fact_ref_duplicate", cell.key);
+    if (!cell.design_fact_refs.length &&
+        document.realization_mode !== "reference")
+        invalidFeasibility("cell_design_fact_refs_required", cell.key);
+    validateDesignFactRefs(cell, model, document);
+    const conditionScopeSha256 = deriveDesignResourceFeasibilityConditionScopeSha256(document, model, cell.condition_profile_ref);
+    validateCellBlockers(cell, blockers, usedBlockers);
+    if (!cell.feasible_realizations.length && !cell.blocker_refs.length)
+        invalidFeasibility("cell_candidate_or_blocker_required", cell.key);
+    unique(cell.feasible_realizations.map((item) => item.key), "cell_realization_key_duplicate", cell.key);
+    for (const realization of cell.feasible_realizations) {
+        realizationKeys.push(realization.key);
+        await validateFeasibleRealization(repository, realization, sources, decisionSources, componentOwnerRoots, {
+            target_ref: cell.target_ref,
+            component_family_ref: cell.component_family_ref,
+            condition_scope_sha256: conditionScopeSha256,
+        });
+    }
+    validateRequiredRealization(cell, sources, decisionSources, conditionScopeSha256);
+}
+function validateCellBlockers(cell, blockers, usedBlockers) {
+    unique(cell.blocker_refs, "cell_blocker_ref_duplicate", cell.key);
+    for (const blockerRef of cell.blocker_refs) {
+        const blocker = blockers.get(blockerRef);
+        if (!blocker)
+            invalidFeasibility("cell_blocker_unknown", `${cell.key}:${blockerRef}`);
+        if (blocker.target_ref !== cell.target_ref ||
+            blocker.component_family_ref !== cell.component_family_ref ||
+            blocker.condition_profile_ref !== cell.condition_profile_ref)
+            invalidFeasibility("cell_blocker_scope_mismatch", `${cell.key}:${blockerRef}`);
+        usedBlockers.add(blockerRef);
+    }
+}
+function validateBlockers(document, model, families, profileRefs, sources, decisionSources, usedBlockers) {
+    for (const blocker of document.blockers) {
+        if (blocker.target_ref !== document.target_ref)
+            invalidFeasibility("blocker_target_mismatch", blocker.key);
+        if (!families.has(blocker.component_family_ref))
+            invalidFeasibility("blocker_component_family_unknown", blocker.key);
+        if (!profileRefs.has(blocker.condition_profile_ref))
+            invalidFeasibility("blocker_condition_profile_unknown", blocker.key);
+        if (!blocker.source_record_refs.length)
+            invalidFeasibility("blocker_source_required", blocker.key);
+        unique(blocker.source_record_refs, "blocker_source_duplicate", blocker.key);
+        requireKnownRefs(blocker.source_record_refs, sources, "blocker_source_unknown", blocker.key);
+        requireExactFeasibilityDecisionProjection(blocker.source_record_refs, decisionSources, {
+            schema_version: DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA,
+            mode: "feasibility_blocker",
+            target_ref: blocker.target_ref,
+            component_family_ref: blocker.component_family_ref,
+            condition_scope_sha256: deriveDesignResourceFeasibilityConditionScopeSha256(document, model, blocker.condition_profile_ref),
+            blocker_ref: blocker.key,
+            substrate_observation_refs: blocker.substrate_observation_refs,
+        }, `blocker:${blocker.key}`, {
+            allReferencesMustBeSourceItems: false,
+            allowedItemKinds: ["decision", "external_confirmation"],
+        });
+        if (!usedBlockers.has(blocker.key))
+            invalidFeasibility("blocker_unreferenced", blocker.key);
+    }
+}
+function validateCellIdentity(cell, targetRef, families, profiles) {
+    if (cell.target_ref !== targetRef)
+        invalidFeasibility("cell_target_mismatch", cell.key);
+    if (!families.has(cell.component_family_ref))
+        invalidFeasibility("cell_component_family_unknown", cell.key);
+    if (!profiles.has(cell.condition_profile_ref))
+        invalidFeasibility("cell_condition_profile_unknown", cell.key);
+}

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

@@ -0,0 +1,4 @@
+import { type DesignResourceImplementationFeasibilityV1 } from "./design-resource-implementation-feasibility-types.js";
+import type { DesignResourceImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
+import type { DesignResourceFeasibilityDecisionSourceIndex } from "./design-resource-implementation-feasibility-source-decision.js";
+export declare function validateFeasibilityDocument(repository: string, document: DesignResourceImplementationFeasibilityV1, model: DesignResourceImplementationFeasibilityTargetModel, decisionSources: DesignResourceFeasibilityDecisionSourceIndex): Promise<void>;

package/dist/lib/design-resource-implementation-feasibility-validation-document.js

@@ -0,0 +1,167 @@
+import { DESIGN_RESOURCE_SUBSTRATE_OBSERVATION_KINDS, } from "./design-resource-implementation-feasibility-types.js";
+import { validateFeasibilityCells } from "./design-resource-implementation-feasibility-validation-cells.js";
+import { assertSameSet, invalidFeasibility, requireKnownRefs, unique, } from "./design-resource-implementation-feasibility-validation-support.js";
+import { createSymbolicDenotationCompilationSession } from "./symbolic-denotation-engine.js";
+import { validateNoExactVisualValueCarriers } from "./design-resource-implementation-feasibility-validation-support.js";
+import { assertProtectedRepositoryDirectory, assertProtectedRepositoryPath, } from "./repository-path-safety.js";
+import path from "node:path";
+const OBSERVATION_SOURCE_ROLES = {
+    platform: "technical_platform",
+    framework_runtime: "framework_runtime",
+    ui_system: "ui_system",
+    token_theming_adapter: "token_theming_adapter",
+    component_owner_roots: "component_owner",
+    route_owner_roots: "route_owner",
+};
+export async function validateFeasibilityDocument(repository, document, model, decisionSources) {
+    if (document.target_ref !== model.target_ref)
+        invalidFeasibility("document_target_mismatch", `${document.target_ref}:${model.target_ref}`);
+    if (document.realization_mode === "reference" &&
+        model.source_profile_kind !== "reference")
+        invalidFeasibility("reference_mode_formal_implementation_forbidden", model.target_ref);
+    if (document.realization_mode !== "reference" &&
+        model.source_profile_kind === "reference")
+        invalidFeasibility("reference_profile_feasibility_mode_invalid", model.target_ref);
+    const sources = new Map(document.source_records.map((item) => [item.key, item]));
+    validateNoExactVisualValueCarriers(document);
+    await validateObservations(repository, document, sources);
+    validateCandidateComponentOwnerRoots(document);
+    const profileRefs = validateConditionModel(document, model);
+    await validateFeasibilityCells(repository, document, model, profileRefs, sources, decisionSources);
+}
+async function validateObservations(repository, document, sources) {
+    unique(document.substrate_observations.map((item) => item.kind), "substrate_observation_kind_duplicate");
+    if (document.realization_mode !== "reference")
+        assertSameSet(document.substrate_observations.map((item) => item.kind), [...DESIGN_RESOURCE_SUBSTRATE_OBSERVATION_KINDS], "substrate_observation_kind_set_mismatch");
+    for (const observation of document.substrate_observations) {
+        unique(observation.source_record_refs, "substrate_observation_source_duplicate", observation.kind);
+        requireKnownRefs(observation.source_record_refs, sources, "substrate_observation_source_unknown", observation.kind);
+        if (observation.disposition === "observed") {
+            validateObservedSubstrate(observation, sources);
+        }
+        else {
+            if (observation.value !== null)
+                invalidFeasibility("unobserved_substrate_value_forbidden", observation.kind);
+            if (observation.reason === null)
+                invalidFeasibility("unobserved_substrate_reason_required", observation.kind);
+        }
+        validateObservationValue(observation, sources);
+        if (observation.value?.kind === "repository_paths")
+            for (const repositoryPath of observation.value.paths)
+                await (observation.kind === "component_owner_roots" ||
+                    observation.kind === "route_owner_roots"
+                    ? assertProtectedRepositoryDirectory
+                    : assertProtectedRepositoryPath)(repository, path.resolve(repository, ...repositoryPath.split("/")), `design_resource_feasibility_repository_path:${observation.kind}`);
+    }
+}
+function validateCandidateComponentOwnerRoots(document) {
+    if (!document.component_family_cells.some((cell) => cell.feasible_realizations.length > 0))
+        return;
+    const roots = document.substrate_observations.find((observation) => observation.kind === "component_owner_roots");
+    if (roots?.disposition !== "observed" ||
+        roots.value?.kind !== "repository_paths" ||
+        roots.value.paths.length === 0)
+        invalidFeasibility("candidate_component_owner_roots_required", document.target_ref);
+}
+function validateObservedSubstrate(observation, sources) {
+    if (!observation.value)
+        invalidFeasibility("observed_substrate_value_required", observation.kind);
+    if (observation.reason !== null)
+        invalidFeasibility("observed_substrate_reason_forbidden", observation.kind);
+    if (!observation.source_record_refs.length)
+        invalidFeasibility("observed_substrate_source_required", observation.kind);
+    const requiredRole = OBSERVATION_SOURCE_ROLES[observation.kind];
+    if (!observation.source_record_refs.some((ref) => sources.get(ref).roles.includes(requiredRole)))
+        invalidFeasibility("observed_substrate_source_role_missing", `${observation.kind}:${requiredRole}`);
+}
+function validateObservationValue(observation, sources) {
+    if (!observation.value)
+        return;
+    if (["platform", "framework_runtime", "ui_system"].includes(observation.kind) &&
+        observation.value.kind !== "identifier")
+        invalidFeasibility("observation_value_kind_invalid", `${observation.kind}:${observation.value.kind}`);
+    if (["component_owner_roots", "route_owner_roots"].includes(observation.kind) &&
+        observation.value.kind !== "repository_paths")
+        invalidFeasibility("observation_value_kind_invalid", `${observation.kind}:${observation.value.kind}`);
+    if (observation.value?.kind === "identifier") {
+        const versionRef = observation.value.version_source_ref;
+        if (versionRef && !sources.has(versionRef))
+            invalidFeasibility("observation_version_source_unknown", versionRef);
+    }
+    else if (observation.value?.kind === "repository_paths" &&
+        !observation.value.paths.length) {
+        invalidFeasibility("observation_repository_paths_required", observation.kind);
+    }
+}
+function validateConditionModel(document, model) {
+    const conditionModel = document.condition_model;
+    if (model.representation === "fact_cells_v1" &&
+        conditionModel.kind !== "explicit_conditions_v1")
+        invalidFeasibility("v1_explicit_condition_model_required", model.target_ref);
+    if (model.representation === "symbolic_rules_v2" &&
+        conditionModel.kind !== "symbolic_regions_v2")
+        invalidFeasibility("v2_symbolic_condition_model_required", model.target_ref);
+    if (!conditionModel.profiles.length &&
+        document.realization_mode !== "reference")
+        invalidFeasibility("condition_profiles_required", model.target_ref);
+    unique(conditionModel.profiles.map((item) => item.key), "condition_profile_key_duplicate");
+    if (model.representation === "fact_cells_v1" &&
+        conditionModel.kind === "explicit_conditions_v1")
+        validateExplicitConditionProfiles(document, model);
+    if (model.representation === "symbolic_rules_v2" &&
+        conditionModel.kind === "symbolic_regions_v2" &&
+        conditionModel.profiles.length)
+        validateSymbolicConditionProfiles(document, model);
+    return new Set(conditionModel.profiles.map((item) => item.key));
+}
+function validateExplicitConditionProfiles(document, model) {
+    if (document.condition_model.kind !== "explicit_conditions_v1")
+        return;
+    const conditionRefs = document.condition_model.profiles.flatMap((profile) => {
+        if (!profile.condition_refs.length)
+            invalidFeasibility("condition_profile_empty", profile.key);
+        unique(profile.condition_refs, "condition_profile_ref_duplicate", profile.key);
+        return profile.condition_refs;
+    });
+    unique(conditionRefs, "condition_profile_overlap");
+    if (document.realization_mode !== "reference")
+        assertSameSet(conditionRefs, model.condition_refs, "condition_profile_set_mismatch");
+}
+function validateSymbolicConditionProfiles(document, model) {
+    if (document.condition_model.kind !== "symbolic_regions_v2")
+        return;
+    const profiles = document.condition_model.profiles;
+    const compilation = createSymbolicDenotationCompilationSession(model.axis_domains, [model.reachable_region, ...profiles.map((item) => item.region)]);
+    const reachable = compilation.compile(model.reachable_region);
+    for (const profile of profiles) {
+        const outside = compilation.compile({
+            op: "all",
+            predicates: [
+                profile.region,
+                { op: "not", predicate: model.reachable_region },
+            ],
+        });
+        if (outside.canonical_dag.root_ref !== "terminal.false")
+            invalidFeasibility("symbolic_condition_profile_unreachable", profile.key);
+    }
+    validateSymbolicProfileDisjointness(profiles, compilation);
+    if (document.realization_mode !== "reference") {
+        const union = compilation.compile({
+            op: "any",
+            predicates: profiles.map((item) => item.region),
+        });
+        if (union.canonical_sha256 !== reachable.canonical_sha256)
+            invalidFeasibility("symbolic_condition_profile_coverage_gap", model.target_ref);
+    }
+}
+function validateSymbolicProfileDisjointness(profiles, compilation) {
+    for (let left = 0; left < profiles.length; left += 1)
+        for (let right = left + 1; right < profiles.length; right += 1) {
+            const overlap = compilation.compile({
+                op: "all",
+                predicates: [profiles[left].region, profiles[right].region],
+            });
+            if (overlap.canonical_dag.root_ref !== "terminal.false")
+                invalidFeasibility("symbolic_condition_profile_overlap", `${profiles[left].key}:${profiles[right].key}`);
+        }
+}

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

@@ -0,0 +1,3 @@
+import type { DesignResourceImplementationFeasibilityCellV1, DesignResourceImplementationFeasibilityV1 } from "./design-resource-implementation-feasibility-types.js";
+import type { DesignResourceImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
+export declare function validateDesignFactRefs(cell: DesignResourceImplementationFeasibilityCellV1, model: DesignResourceImplementationFeasibilityTargetModel, document: DesignResourceImplementationFeasibilityV1): void;

package/dist/lib/design-resource-implementation-feasibility-validation-facts.js

@@ -0,0 +1,76 @@
+import { assertSameSet, invalidFeasibility, } from "./design-resource-implementation-feasibility-validation-support.js";
+import { createSymbolicDenotationCompilationSession } from "./symbolic-denotation-engine.js";
+export function validateDesignFactRefs(cell, model, document) {
+    if (model.representation === "fact_cells_v1") {
+        validateV1FactRefs(cell, model, document);
+        return;
+    }
+    validateV2RuleRefs(cell, model, document);
+}
+function validateV1FactRefs(cell, model, document) {
+    if (document.condition_model.kind !== "explicit_conditions_v1")
+        invalidFeasibility("v1_explicit_condition_model_required", cell.key);
+    const profile = document.condition_model.profiles.find((item) => item.key === cell.condition_profile_ref);
+    for (const ref of cell.design_fact_refs) {
+        const fact = model.facts.get(ref);
+        if (!fact)
+            invalidFeasibility("cell_design_fact_unknown", `${cell.key}:${ref}`);
+        if (fact.target_ref !== cell.target_ref ||
+            !model.component_family_subject_refs
+                .get(cell.component_family_ref)
+                .has(fact.subject_ref) ||
+            !profile.condition_refs.includes(fact.condition_ref))
+            invalidFeasibility("cell_design_fact_scope_mismatch", `${cell.key}:${ref}`);
+    }
+    const expectedRefs = [...model.facts.entries()]
+        .filter(([, fact]) => fact.target_ref === cell.target_ref &&
+        model.component_family_subject_refs
+            .get(cell.component_family_ref)
+            .has(fact.subject_ref) &&
+        profile.condition_refs.includes(fact.condition_ref))
+        .map(([ref]) => ref);
+    assertSameSet(cell.design_fact_refs, expectedRefs, "cell_design_fact_set_mismatch");
+}
+function validateV2RuleRefs(cell, model, document) {
+    if (document.condition_model.kind !== "symbolic_regions_v2")
+        invalidFeasibility("v2_symbolic_condition_model_required", cell.key);
+    const profile = document.condition_model.profiles.find((item) => item.key === cell.condition_profile_ref);
+    const referencedRules = cell.design_fact_refs.map((ref) => {
+        const rule = model.fact_rules.get(ref);
+        if (!rule)
+            invalidFeasibility("cell_design_rule_unknown", `${cell.key}:${ref}`);
+        return rule;
+    });
+    const familyRules = [...model.fact_rules.values()].filter((rule) => rule.target_ref === cell.target_ref &&
+        model.component_family_subject_refs
+            .get(cell.component_family_ref)
+            .has(rule.subject_or_relation_ref));
+    const compilation = createSymbolicDenotationCompilationSession(model.axis_domains, [
+        model.reachable_region,
+        profile.region,
+        ...familyRules.map((rule) => rule.region),
+    ]);
+    for (const rule of referencedRules) {
+        if (rule.target_ref !== cell.target_ref ||
+            !model.component_family_subject_refs
+                .get(cell.component_family_ref)
+                .has(rule.subject_or_relation_ref))
+            invalidFeasibility("cell_design_rule_scope_mismatch", `${cell.key}:${rule.key}`);
+        const intersection = compilation.compile({
+            op: "all",
+            predicates: [profile.region, rule.region],
+        });
+        if (intersection.canonical_dag.root_ref === "terminal.false")
+            invalidFeasibility("cell_design_rule_condition_mismatch", `${cell.key}:${rule.key}`);
+    }
+    const expectedRefs = familyRules
+        .filter((rule) => {
+        const intersection = compilation.compile({
+            op: "all",
+            predicates: [profile.region, rule.region],
+        });
+        return intersection.canonical_dag.root_ref !== "terminal.false";
+    })
+        .map((rule) => rule.key);
+    assertSameSet(cell.design_fact_refs, expectedRefs, "cell_design_rule_set_mismatch");
+}

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

@@ -0,0 +1,8 @@
+import type { DesignResourceFeasibleRealizationV1, DesignResourceImplementationFeasibilityCellV1, DesignResourceTechnicalSourceRecordV1 } from "./design-resource-implementation-feasibility-types.js";
+import { type DesignResourceFeasibilityDecisionSourceIndex } from "./design-resource-implementation-feasibility-source-decision.js";
+export declare function validateFeasibleRealization(repository: string, realization: DesignResourceFeasibleRealizationV1, sources: Map<string, DesignResourceTechnicalSourceRecordV1>, decisionSources: DesignResourceFeasibilityDecisionSourceIndex, componentOwnerRoots: string[], scope: {
+    target_ref: string;
+    component_family_ref: string;
+    condition_scope_sha256: string;
+}): Promise<void>;
+export declare function validateRequiredRealization(cell: DesignResourceImplementationFeasibilityCellV1, sources: Map<string, DesignResourceTechnicalSourceRecordV1>, decisionSources: DesignResourceFeasibilityDecisionSourceIndex, conditionScopeSha256: string): void;

package/dist/lib/design-resource-implementation-feasibility-validation-realizations.js

@@ -0,0 +1,76 @@
+import path from "node:path";
+import { invalidFeasibility, requireAtLeastOneSourceRole, requireKnownRefs, requireSourceRole, unique, } from "./design-resource-implementation-feasibility-validation-support.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA, requireExactFeasibilityDecisionProjection, } from "./design-resource-implementation-feasibility-source-decision.js";
+export async function validateFeasibleRealization(repository, realization, sources, decisionSources, componentOwnerRoots, scope) {
+    if (!realization.strategy_steps.length)
+        invalidFeasibility("realization_strategy_steps_required", realization.key);
+    unique(realization.strategy_steps, "realization_strategy_step_duplicate", realization.key);
+    if (!realization.primitive_refs.length)
+        invalidFeasibility("realization_primitive_refs_required", realization.key);
+    unique(realization.primitive_refs, "realization_primitive_ref_duplicate", realization.key);
+    if (!realization.owner_candidates.length)
+        invalidFeasibility("realization_owner_candidates_required", realization.key);
+    unique(realization.owner_candidates.map((item) => `${item.kind}:${item.locator}`), "realization_owner_candidate_duplicate", realization.key);
+    unique(realization.supported_customization_surfaces, "realization_customization_surface_duplicate", realization.key);
+    validateFeasibilityBasis(realization, sources);
+    unique(realization.observed_costs, "realization_observed_cost_duplicate", realization.key);
+    unique(realization.observed_risks, "realization_observed_risk_duplicate", realization.key);
+    for (const owner of realization.owner_candidates)
+        await validateOwnerCandidate(repository, realization.key, owner, sources, decisionSources, componentOwnerRoots, scope);
+}
+function validateFeasibilityBasis(realization, sources) {
+    if (!realization.feasibility_basis_refs.length)
+        invalidFeasibility("realization_feasibility_basis_required", realization.key);
+    requireKnownRefs(realization.feasibility_basis_refs, sources, "realization_feasibility_basis_unknown", realization.key);
+    unique(realization.feasibility_basis_refs, "realization_feasibility_basis_duplicate", realization.key);
+    requireAtLeastOneSourceRole(realization.feasibility_basis_refs, sources, "feasibility_basis", "realization_feasibility_basis_role_missing", realization.key);
+    requireAtLeastOneSourceRole(realization.feasibility_basis_refs, sources, "capability_basis", "realization_capability_basis_role_missing", realization.key);
+}
+async function validateOwnerCandidate(repository, realizationKey, owner, sources, decisionSources, componentOwnerRoots, scope) {
+    if (owner.kind === "existing_path") {
+        await assertProtectedRepositoryFile(repository, path.resolve(repository, ...owner.locator.split("/")), `design_resource_feasibility_owner:${realizationKey}`);
+        if (componentOwnerRoots.length > 0 &&
+            !componentOwnerRoots.some((root) => owner.locator === root || owner.locator.startsWith(`${root}/`)))
+            invalidFeasibility("existing_owner_outside_component_roots", `${realizationKey}:${owner.locator}`);
+        return;
+    }
+    if (!owner.authorization_source_refs.length)
+        invalidFeasibility("planned_owner_authorization_required", realizationKey);
+    unique(owner.authorization_source_refs, "planned_owner_authorization_duplicate", realizationKey);
+    requireSourceRole(owner.authorization_source_refs, sources, "planned_owner_authorization", "planned_owner_authorization_invalid", realizationKey);
+    requireExactFeasibilityDecisionProjection(owner.authorization_source_refs, decisionSources, {
+        schema_version: DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA,
+        mode: "planned_owner_authorization",
+        ...scope,
+        owner_locator: owner.locator,
+    }, `planned_owner:${realizationKey}:${owner.locator}`, {
+        allReferencesMustBeSourceItems: true,
+        allowedItemKinds: ["technical_obligation"],
+    });
+}
+export function validateRequiredRealization(cell, sources, decisionSources, conditionScopeSha256) {
+    const required = cell.required_realization;
+    unique(required.technical_authority_source_refs, "required_realization_authority_duplicate", cell.key);
+    if (required.realization_ref === null) {
+        if (required.technical_authority_source_refs.length)
+            invalidFeasibility("required_realization_authority_without_selection", cell.key);
+        return;
+    }
+    if (!cell.feasible_realizations.some((realization) => realization.key === required.realization_ref))
+        invalidFeasibility("required_realization_unknown", cell.key);
+    if (!required.technical_authority_source_refs.length)
+        invalidFeasibility("required_realization_authority_required", cell.key);
+    requireSourceRole(required.technical_authority_source_refs, sources, "technical_authority", "required_realization_authority_invalid", cell.key);
+    requireExactFeasibilityDecisionProjection(required.technical_authority_source_refs, decisionSources, {
+        schema_version: DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA,
+        mode: "required_realization",
+        target_ref: cell.target_ref,
+        component_family_ref: cell.component_family_ref,
+        condition_scope_sha256: conditionScopeSha256,
+        realization_ref: required.realization_ref,
+    }, `required_realization:${cell.key}`, {
+        allReferencesMustBeSourceItems: true,
+        allowedItemKinds: ["technical_obligation"],
+    });
+}

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

@@ -0,0 +1,10 @@
+import type { DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalSourceRecordV1 } from "./design-resource-implementation-feasibility-types.js";
+export declare function invalidFeasibility(code: string, detail: string): never;
+export declare function unique(values: string[], code: string, detail?: string): void;
+export declare function requireKnownRefs<T>(refs: string[], values: Map<string, T>, code: string, detail?: string): void;
+export declare function requireSourceRole(refs: string[], sources: Map<string, DesignResourceTechnicalSourceRecordV1>, role: DesignResourceTechnicalSourceRecordV1["roles"][number], code: string, detail: string): void;
+export declare function requireAtLeastOneSourceRole(refs: string[], sources: Map<string, DesignResourceTechnicalSourceRecordV1>, role: DesignResourceTechnicalSourceRecordV1["roles"][number], code: string, detail: string): void;
+export declare function assertSameSet(actual: string[], expected: string[], code: string): void;
+export declare function assertNoExactVisualValues(values: string[], detail: string): void;
+export declare function validateNoExactVisualValueCarriers(document: DesignResourceImplementationFeasibilityV1): void;
+export declare function cellPair(familyRef: string, profileRef: string): string;

package/dist/lib/design-resource-implementation-feasibility-validation-support.js

@@ -0,0 +1,75 @@
+const EXACT_VISUAL_VALUE_PATTERNS = [
+    /#[0-9a-f]{3,8}\b/iu,
+    /\b(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch)\s*\(/iu,
+    /\b\d+(?:\.\d+)?(?:px|rem|em|pt|pc|vh|vw|vmin|vmax|ch|ex|deg)\b/iu,
+    /\b(?:color|background|font(?:-family|-size|-weight)?|line-height|border-radius|radius|padding|margin|gap|width|height|opacity|duration|easing|shadow)\s*[:=]\s*\S+/iu,
+    /--[a-z0-9_-]+\s*:\s*\S+/iu,
+];
+const TIME_VALUE_PATTERN = /\b\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|sec|s)\b/giu;
+const MOTION_TIME_CONTEXT = /\b(?:animation|transition|motion|duration|delay|easing|timeline|keyframes?|fade|spring|stagger|enter|exit|hover|press|ease(?:-in|-out|-in-out)?)\b/iu;
+const TECHNICAL_TIME_CONTEXT = /\b(?:build|compile|bundle|generation|ci|tests?|startup|initialization|latency|timeout|network|benchmark|runtime\s+cost|render\s+cost|benchmark\s+execution)\b/iu;
+const TIME_CONTEXT_RADIUS = 80;
+export function invalidFeasibility(code, detail) {
+    throw new Error(`design_resource_implementation_feasibility_invalid:${code}${detail ? `:${detail}` : ""}`);
+}
+export function unique(values, code, detail = "") {
+    if (new Set(values).size !== values.length)
+        invalidFeasibility(code, detail || values.join(","));
+}
+export function requireKnownRefs(refs, values, code, detail = "") {
+    for (const ref of refs)
+        if (!values.has(ref))
+            invalidFeasibility(code, detail ? `${detail}:${ref}` : ref);
+}
+export function requireSourceRole(refs, sources, role, code, detail) {
+    requireKnownRefs(refs, sources, code, detail);
+    for (const ref of refs)
+        if (!sources.get(ref).roles.includes(role))
+            invalidFeasibility(code, `${detail}:${ref}:${role}`);
+}
+export function requireAtLeastOneSourceRole(refs, sources, role, code, detail) {
+    if (!refs.some((ref) => sources.get(ref)?.roles.includes(role)))
+        invalidFeasibility(code, `${detail}:${role}`);
+}
+export function assertSameSet(actual, expected, code) {
+    const left = [...actual].sort(compareText);
+    const right = [...expected].sort(compareText);
+    if (left.length !== right.length ||
+        left.some((value, index) => value !== right[index]))
+        invalidFeasibility(code, `${left.join(",")}:${right.join(",")}`);
+}
+export function assertNoExactVisualValues(values, detail) {
+    for (const value of values)
+        if (EXACT_VISUAL_VALUE_PATTERNS.some((pattern) => pattern.test(value)) ||
+            hasForbiddenTimeValue(value))
+            invalidFeasibility("exact_visual_value_forbidden", detail);
+}
+function hasForbiddenTimeValue(value) {
+    for (const match of value.matchAll(TIME_VALUE_PATTERN)) {
+        const index = match.index;
+        const context = value.slice(Math.max(0, index - TIME_CONTEXT_RADIUS), Math.min(value.length, index + match[0].length + TIME_CONTEXT_RADIUS));
+        if (MOTION_TIME_CONTEXT.test(context))
+            return true;
+        if (!TECHNICAL_TIME_CONTEXT.test(context))
+            return true;
+    }
+    return false;
+}
+export function validateNoExactVisualValueCarriers(document) {
+    for (const observation of document.substrate_observations)
+        if (observation.reason !== null)
+            assertNoExactVisualValues([observation.reason], `substrate_observation:${observation.kind}:reason`);
+    for (const cell of document.component_family_cells)
+        for (const realization of cell.feasible_realizations) {
+            assertNoExactVisualValues(realization.observed_costs, `realization:${realization.key}:observed_costs`);
+            assertNoExactVisualValues(realization.observed_risks, `realization:${realization.key}:observed_risks`);
+        }
+    for (const blocker of document.blockers)
+        assertNoExactVisualValues([blocker.description], `blocker:${blocker.key}:description`);
+}
+export function cellPair(familyRef, profileRef) {
+    return `${familyRef}\0${profileRef}`;
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

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

@@ -0,0 +1,3 @@
+import type { DesignResourceTechnicalFeasibilityInputV1, LoadedDesignResourceImplementationFeasibilityV1 } from "./design-resource-implementation-feasibility-types.js";
+import type { DesignResourceImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
+export declare function readAndValidateDesignResourceImplementationFeasibility(repository: string, handoffPath: string, inputs: DesignResourceTechnicalFeasibilityInputV1[], targetModels: Map<string, DesignResourceImplementationFeasibilityTargetModel>, canonicalResourcePaths: Set<string>): Promise<LoadedDesignResourceImplementationFeasibilityV1[]>;