project-tiny-context-harness 0.8.16 → 0.8.17

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

@@ -0,0 +1,135 @@
+import type { SymbolicDenotationPredicate } from "./symbolic-denotation-types.js";
+export interface DesignResourceTechnicalFeasibilityInputV1 {
+    key: string;
+    target_ref: string;
+    path: string;
+    media_type: "application/json";
+    sha256: string;
+}
+export declare const DESIGN_RESOURCE_SUBSTRATE_OBSERVATION_KINDS: readonly ["platform", "framework_runtime", "ui_system", "token_theming_adapter", "component_owner_roots", "route_owner_roots"];
+export type DesignResourceSubstrateObservationKind = (typeof DESIGN_RESOURCE_SUBSTRATE_OBSERVATION_KINDS)[number];
+export type DesignResourceSubstrateObservationDisposition = "observed" | "not_applicable" | "decision_required" | "unavailable";
+export declare const DESIGN_RESOURCE_TECHNICAL_SOURCE_ROLES: readonly ["technical_platform", "framework_runtime", "ui_system", "token_theming_adapter", "component_owner", "route_owner", "capability_basis", "planned_owner_authorization", "technical_authority", "feasibility_basis"];
+export type DesignResourceTechnicalSourceRole = (typeof DESIGN_RESOURCE_TECHNICAL_SOURCE_ROLES)[number];
+export interface DesignResourceTechnicalSourceRecordV1 {
+    key: string;
+    path: string;
+    media_type: string;
+    sha256: string;
+    locator: {
+        kind: "whole_resource";
+        value: ".";
+    } | {
+        kind: "json_pointer";
+        value: string;
+    } | {
+        kind: "markdown_anchor" | "source_anchor";
+        value: string;
+    } | {
+        kind: "source_item";
+        value: string;
+        text_sha256: string;
+    };
+    roles: DesignResourceTechnicalSourceRole[];
+}
+export type DesignResourceSubstrateObservationValueV1 = {
+    kind: "identifier";
+    name: string;
+    version_source_ref: string | null;
+} | {
+    kind: "repository_paths";
+    paths: string[];
+};
+export interface DesignResourceSubstrateObservationV1 {
+    kind: DesignResourceSubstrateObservationKind;
+    disposition: DesignResourceSubstrateObservationDisposition;
+    value: DesignResourceSubstrateObservationValueV1 | null;
+    source_record_refs: string[];
+    reason: string | null;
+}
+export interface DesignResourceExplicitConditionProfileV1 {
+    key: string;
+    condition_refs: string[];
+}
+export interface DesignResourceSymbolicConditionProfileV1 {
+    key: string;
+    region: SymbolicDenotationPredicate;
+}
+export type DesignResourceImplementationConditionModelV1 = {
+    kind: "explicit_conditions_v1";
+    profiles: DesignResourceExplicitConditionProfileV1[];
+} | {
+    kind: "symbolic_regions_v2";
+    profiles: DesignResourceSymbolicConditionProfileV1[];
+};
+export declare const DESIGN_RESOURCE_IMPLEMENTATION_STRATEGY_STEPS: readonly ["reuse_existing", "compose_existing", "extend_shared_component", "theme_with_tokens", "create_shared_component"];
+export type DesignResourceImplementationStrategyStep = (typeof DESIGN_RESOURCE_IMPLEMENTATION_STRATEGY_STEPS)[number];
+export declare const DESIGN_RESOURCE_CUSTOMIZATION_SURFACES: readonly ["theme_tokens", "component_variant", "primitive_props", "composition", "content_slot", "icon_slot", "behavior_slot", "style_api"];
+export type DesignResourceCustomizationSurface = (typeof DESIGN_RESOURCE_CUSTOMIZATION_SURFACES)[number];
+export type DesignResourceImplementationOwnerCandidateV1 = {
+    kind: "existing_path";
+    locator: string;
+    existence: "existing";
+} | {
+    kind: "planned_logical_owner";
+    locator: string;
+    existence: "planned";
+    authorization_source_refs: string[];
+};
+export interface DesignResourceFeasibleRealizationV1 {
+    key: string;
+    strategy_steps: DesignResourceImplementationStrategyStep[];
+    primitive_refs: string[];
+    owner_candidates: DesignResourceImplementationOwnerCandidateV1[];
+    supported_customization_surfaces: DesignResourceCustomizationSurface[];
+    feasibility_basis_refs: string[];
+    observed_costs: string[];
+    observed_risks: string[];
+}
+export interface DesignResourceImplementationFeasibilityCellV1 {
+    key: string;
+    component_family_ref: string;
+    target_ref: string;
+    condition_profile_ref: string;
+    design_fact_refs: string[];
+    feasible_realizations: DesignResourceFeasibleRealizationV1[];
+    required_realization: {
+        realization_ref: string | null;
+        technical_authority_source_refs: string[];
+    };
+    blocker_refs: string[];
+}
+export interface DesignResourceImplementationFeasibilityBlockerV1 {
+    key: string;
+    component_family_ref: string;
+    target_ref: string;
+    condition_profile_ref: string;
+    source_record_refs: string[];
+    substrate_observation_refs: DesignResourceSubstrateObservationKind[];
+    description: string;
+}
+export interface DesignResourceImplementationFeasibilityV1 {
+    schema_version: "design-resource-implementation-feasibility-v1";
+    key: string;
+    target_ref: string;
+    realization_mode: "native_substrate" | "mapped_substrate" | "reference";
+    source_records: DesignResourceTechnicalSourceRecordV1[];
+    substrate_observations: DesignResourceSubstrateObservationV1[];
+    condition_model: DesignResourceImplementationConditionModelV1;
+    component_family_cells: DesignResourceImplementationFeasibilityCellV1[];
+    blockers: DesignResourceImplementationFeasibilityBlockerV1[];
+}
+export interface DesignResourceImplementationFeasibilityIdentityV1 {
+    key: string;
+    target_ref: string;
+    path: string;
+    sha256: string;
+    realization_mode: DesignResourceImplementationFeasibilityV1["realization_mode"];
+    component_family_cells: number;
+    blockers: number;
+}
+export interface LoadedDesignResourceImplementationFeasibilityV1 {
+    index: DesignResourceTechnicalFeasibilityInputV1;
+    document: DesignResourceImplementationFeasibilityV1;
+    identity: DesignResourceImplementationFeasibilityIdentityV1;
+}

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

@@ -0,0 +1,37 @@
+export const DESIGN_RESOURCE_SUBSTRATE_OBSERVATION_KINDS = [
+    "platform",
+    "framework_runtime",
+    "ui_system",
+    "token_theming_adapter",
+    "component_owner_roots",
+    "route_owner_roots",
+];
+export const DESIGN_RESOURCE_TECHNICAL_SOURCE_ROLES = [
+    "technical_platform",
+    "framework_runtime",
+    "ui_system",
+    "token_theming_adapter",
+    "component_owner",
+    "route_owner",
+    "capability_basis",
+    "planned_owner_authorization",
+    "technical_authority",
+    "feasibility_basis",
+];
+export const DESIGN_RESOURCE_IMPLEMENTATION_STRATEGY_STEPS = [
+    "reuse_existing",
+    "compose_existing",
+    "extend_shared_component",
+    "theme_with_tokens",
+    "create_shared_component",
+];
+export const DESIGN_RESOURCE_CUSTOMIZATION_SURFACES = [
+    "theme_tokens",
+    "component_variant",
+    "primitive_props",
+    "composition",
+    "content_slot",
+    "icon_slot",
+    "behavior_slot",
+    "style_api",
+];

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

@@ -0,0 +1,5 @@
+import type { DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalSourceRecordV1 } 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 validateFeasibilityCells(repository: string, document: DesignResourceImplementationFeasibilityV1, model: DesignResourceImplementationFeasibilityTargetModel, profileRefs: Set<string>, sources: Map<string, DesignResourceTechnicalSourceRecordV1>, decisionSources: DesignResourceFeasibilityDecisionSourceIndex): Promise<void>;
+export declare function validateSubstrateObservationBlockerCoverage(document: Pick<DesignResourceImplementationFeasibilityV1, "substrate_observations" | "component_family_cells" | "blockers">, model: Pick<DesignResourceImplementationFeasibilityTargetModel, "component_family_refs">): void;

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"],
+    });
+}