project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,135 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,167 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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"],
-    });
-}