project-tiny-context-harness 0.8.16 → 0.11.0

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

@@ -0,0 +1,4 @@
+import { type DesignResourceImplementationFeasibilityV1, type DesignResourceTechnicalFeasibilityInputV1 } from "./design-resource-implementation-feasibility-types.js";
+export declare function parseDesignResourceTechnicalFeasibilityInputs(value: unknown, label?: string): DesignResourceTechnicalFeasibilityInputV1[];
+export declare function parseDesignResourceImplementationFeasibilityJson(content: string): DesignResourceImplementationFeasibilityV1;
+export declare function parseDesignResourceImplementationFeasibilityShape(value: unknown): DesignResourceImplementationFeasibilityV1;

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

@@ -0,0 +1,154 @@
+import { DESIGN_RESOURCE_SUBSTRATE_OBSERVATION_KINDS, DESIGN_RESOURCE_TECHNICAL_SOURCE_ROLES, } from "./design-resource-implementation-feasibility-types.js";
+import { parseBlockers, parseComponentFamilyCells, parseConditionModel, } from "./design-resource-implementation-feasibility-shape-sections.js";
+import { invalidFeasibility } from "./design-resource-implementation-feasibility-validation-support.js";
+import { contractKey, sha256, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { array, literal, nullable, object, repositoryFile, string, } from "./long-task-shape-primitives.js";
+import { parseStrictYaml } from "./strict-codec.js";
+export function parseDesignResourceTechnicalFeasibilityInputs(value, label = "design_resource_handoff.technical_feasibility_inputs") {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "target_ref",
+            "path",
+            "media_type",
+            "sha256",
+        ]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            target_ref: contractKey(row.target_ref, `${itemLabel}.target_ref`),
+            path: repositoryFile(row.path, `${itemLabel}.path`),
+            media_type: literal(row.media_type, ["application/json"], `${itemLabel}.media_type`),
+            sha256: sha256(row.sha256, `${itemLabel}.sha256`),
+        };
+    });
+}
+export function parseDesignResourceImplementationFeasibilityJson(content) {
+    try {
+        JSON.parse(content);
+    }
+    catch (error) {
+        invalidFeasibility("json", error instanceof Error ? error.message : String(error));
+    }
+    try {
+        return parseDesignResourceImplementationFeasibilityShape(parseStrictYaml(content));
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message.startsWith("design_resource_implementation_feasibility_invalid:"))
+            throw error;
+        invalidFeasibility("shape", error instanceof Error ? error.message : String(error));
+    }
+}
+export function parseDesignResourceImplementationFeasibilityShape(value) {
+    const label = "implementation_feasibility";
+    const root = object(value, label, [
+        "schema_version",
+        "key",
+        "target_ref",
+        "realization_mode",
+        "source_records",
+        "substrate_observations",
+        "condition_model",
+        "component_family_cells",
+        "blockers",
+    ]);
+    return {
+        schema_version: literal(root.schema_version, ["design-resource-implementation-feasibility-v1"], `${label}.schema_version`),
+        key: stableKey(root.key, `${label}.key`),
+        target_ref: contractKey(root.target_ref, `${label}.target_ref`),
+        realization_mode: literal(root.realization_mode, ["native_substrate", "mapped_substrate", "reference"], `${label}.realization_mode`),
+        source_records: parseSourceRecords(root.source_records, label),
+        substrate_observations: parseSubstrateObservations(root.substrate_observations, label),
+        condition_model: parseConditionModel(root.condition_model, label),
+        component_family_cells: parseComponentFamilyCells(root.component_family_cells, label),
+        blockers: parseBlockers(root.blockers, label),
+    };
+}
+function parseSourceRecords(value, label) {
+    return array(value, `${label}.source_records`).map((item, index) => {
+        const itemLabel = `${label}.source_records[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "path",
+            "media_type",
+            "sha256",
+            "locator",
+            "roles",
+        ]);
+        const locator = object(row.locator, `${itemLabel}.locator`, ["kind", "value"], ["text_sha256"]);
+        const kind = literal(locator.kind, [
+            "whole_resource",
+            "json_pointer",
+            "markdown_anchor",
+            "source_anchor",
+            "source_item",
+        ], `${itemLabel}.locator.kind`);
+        const locatorValue = string(locator.value, `${itemLabel}.locator.value`);
+        if (kind === "whole_resource" && locatorValue !== ".")
+            invalidFeasibility(`${itemLabel}.locator.value`, "whole_resource_must_be_dot");
+        if (kind === "json_pointer" && !locatorValue.startsWith("/"))
+            invalidFeasibility(`${itemLabel}.locator.value`, "json_pointer_must_start_with_slash");
+        const parsedLocator = kind === "whole_resource"
+            ? { kind, value: "." }
+            : kind === "json_pointer"
+                ? { kind, value: locatorValue }
+                : kind === "source_item"
+                    ? {
+                        kind,
+                        value: stableKey(locatorValue, `${itemLabel}.locator.value`),
+                        text_sha256: sha256(locator.text_sha256, `${itemLabel}.locator.text_sha256`),
+                    }
+                    : { kind, value: locatorValue };
+        if (kind !== "source_item" && locator.text_sha256 !== undefined)
+            invalidFeasibility(`${itemLabel}.locator.text_sha256`, "only_source_item_may_declare_text_sha256");
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            path: repositoryFile(row.path, `${itemLabel}.path`),
+            media_type: string(row.media_type, `${itemLabel}.media_type`),
+            sha256: sha256(row.sha256, `${itemLabel}.sha256`),
+            locator: parsedLocator,
+            roles: array(row.roles, `${itemLabel}.roles`).map((role, roleIndex) => literal(role, DESIGN_RESOURCE_TECHNICAL_SOURCE_ROLES, `${itemLabel}.roles[${roleIndex}]`)),
+        };
+    });
+}
+function parseSubstrateObservations(value, label) {
+    return array(value, `${label}.substrate_observations`).map((item, index) => {
+        const itemLabel = `${label}.substrate_observations[${index}]`;
+        const row = object(item, itemLabel, [
+            "kind",
+            "disposition",
+            "value",
+            "source_record_refs",
+            "reason",
+        ]);
+        return {
+            kind: literal(row.kind, DESIGN_RESOURCE_SUBSTRATE_OBSERVATION_KINDS, `${itemLabel}.kind`),
+            disposition: literal(row.disposition, [
+                "observed",
+                "not_applicable",
+                "decision_required",
+                "unavailable",
+            ], `${itemLabel}.disposition`),
+            value: nullable(row.value, (entry) => parseObservationValue(entry, `${itemLabel}.value`)),
+            source_record_refs: stableKeys(row.source_record_refs, `${itemLabel}.source_record_refs`),
+            reason: nullable(row.reason, (entry) => string(entry, `${itemLabel}.reason`)),
+        };
+    });
+}
+function parseObservationValue(value, label) {
+    const kind = object(value, label, ["kind"], ["name", "version_source_ref", "paths"]).kind;
+    if (kind === "identifier") {
+        const row = object(value, label, ["kind", "name", "version_source_ref"]);
+        return {
+            kind: literal(row.kind, ["identifier"], `${label}.kind`),
+            name: stableKey(row.name, `${label}.name`),
+            version_source_ref: nullable(row.version_source_ref, (entry) => stableKey(entry, `${label}.version_source_ref`)),
+        };
+    }
+    const row = object(value, label, ["kind", "paths"]);
+    return {
+        kind: literal(row.kind, ["repository_paths"], `${label}.kind`),
+        paths: array(row.paths, `${label}.paths`).map((item, index) => repositoryFile(item, `${label}.paths[${index}]`)),
+    };
+}

package/dist/lib/design-resource-implementation-feasibility-source-decision-projection.d.ts

@@ -0,0 +1,24 @@
+import { type DesignResourceSubstrateObservationKind } from "./design-resource-implementation-feasibility-types.js";
+export declare const DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA: "design-resource-feasibility-decision-v1";
+export type DesignResourceFeasibilityDecisionProjection = DesignResourceRequiredRealizationProjection | DesignResourcePlannedOwnerProjection | DesignResourceFeasibilityBlockerProjection;
+interface DesignResourceFeasibilityDecisionProjectionBase {
+    schema_version: typeof DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA;
+    target_ref: string;
+    component_family_ref: string;
+    condition_scope_sha256: string;
+}
+export interface DesignResourceRequiredRealizationProjection extends DesignResourceFeasibilityDecisionProjectionBase {
+    mode: "required_realization";
+    realization_ref: string;
+}
+export interface DesignResourcePlannedOwnerProjection extends DesignResourceFeasibilityDecisionProjectionBase {
+    mode: "planned_owner_authorization";
+    owner_locator: string;
+}
+export interface DesignResourceFeasibilityBlockerProjection extends DesignResourceFeasibilityDecisionProjectionBase {
+    mode: "feasibility_blocker";
+    blocker_ref: string;
+    substrate_observation_refs: DesignResourceSubstrateObservationKind[];
+}
+export declare function parseDesignResourceFeasibilityDecisionProjections(sourcePath: string, sourceItemKey: string, normalizedText: string): DesignResourceFeasibilityDecisionProjection[];
+export {};

package/dist/lib/design-resource-implementation-feasibility-source-decision-projection.js

@@ -0,0 +1,106 @@
+import { digest, literal, object, oneOf, parseStrictJsonObject, stringSet, } from "./design-resource-recovery-codec-primitives.js";
+import { contractKey, stableKey, } from "./design-resource-handoff-shape-primitives.js";
+import { invalidFeasibility } from "./design-resource-implementation-feasibility-validation-support.js";
+import { DESIGN_RESOURCE_SUBSTRATE_OBSERVATION_KINDS, } from "./design-resource-implementation-feasibility-types.js";
+import { canonicalValueJson } from "./strict-codec.js";
+export const DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA = "design-resource-feasibility-decision-v1";
+const DECISION_MARKER = "ty-design-feasibility-decision-v1";
+export function parseDesignResourceFeasibilityDecisionProjections(sourcePath, sourceItemKey, normalizedText) {
+    const projections = [];
+    for (const [index, line] of normalizedText.split("\n").entries()) {
+        if (!line.includes(DECISION_MARKER))
+            continue;
+        const match = /^<!-- ty-design-feasibility-decision-v1 (\{.*\}) -->$/u.exec(line);
+        if (!match)
+            invalidFeasibility("source_decision_marker_invalid", `${sourcePath}:${sourceItemKey}:${index + 1}`);
+        try {
+            projections.push(parseDecisionProjection(match[1], `${sourcePath}:${sourceItemKey}:${index + 1}`));
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith("design_resource_implementation_feasibility_invalid:"))
+                throw error;
+            invalidFeasibility("source_decision_projection_invalid", `${sourcePath}:${sourceItemKey}:${index + 1}:${message(error)}`);
+        }
+    }
+    const identities = projections.map((projection) => canonicalValueJson(projection));
+    if (new Set(identities).size !== identities.length)
+        invalidFeasibility("source_decision_projection_duplicate", `${sourcePath}:${sourceItemKey}`);
+    return projections;
+}
+function parseDecisionProjection(content, label) {
+    const parsed = parseStrictJsonObject(content, `feasibility_decision_projection:${label}`);
+    const header = object(parsed, `feasibility_decision_projection:${label}`, [
+        "schema_version",
+        "mode",
+        "target_ref",
+        "component_family_ref",
+        "condition_scope_sha256",
+    ], [
+        "realization_ref",
+        "owner_locator",
+        "blocker_ref",
+        "substrate_observation_refs",
+    ]);
+    literal(header.schema_version, DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA, `${label}.schema_version`);
+    const mode = oneOf(header.mode, [
+        "required_realization",
+        "planned_owner_authorization",
+        "feasibility_blocker",
+    ], `${label}.mode`);
+    const base = {
+        schema_version: DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA,
+        target_ref: contractKey(header.target_ref, `${label}.target_ref`),
+        component_family_ref: stableKey(header.component_family_ref, `${label}.component_family_ref`),
+        condition_scope_sha256: digest(header.condition_scope_sha256, `${label}.condition_scope_sha256`),
+    };
+    if (mode === "required_realization") {
+        const row = object(parsed, label, [
+            "schema_version",
+            "mode",
+            "target_ref",
+            "component_family_ref",
+            "condition_scope_sha256",
+            "realization_ref",
+        ]);
+        return {
+            ...base,
+            mode,
+            realization_ref: stableKey(row.realization_ref, `${label}.realization_ref`),
+        };
+    }
+    if (mode === "planned_owner_authorization") {
+        const row = object(parsed, label, [
+            "schema_version",
+            "mode",
+            "target_ref",
+            "component_family_ref",
+            "condition_scope_sha256",
+            "owner_locator",
+        ]);
+        return {
+            ...base,
+            mode,
+            owner_locator: stableKey(row.owner_locator, `${label}.owner_locator`),
+        };
+    }
+    const row = object(parsed, label, [
+        "schema_version",
+        "mode",
+        "target_ref",
+        "component_family_ref",
+        "condition_scope_sha256",
+        "blocker_ref",
+        "substrate_observation_refs",
+    ]);
+    const substrateObservationRefs = stringSet(row.substrate_observation_refs, `${label}.substrate_observation_refs`, { allowEmpty: true }).map((observationRef, observationIndex) => oneOf(observationRef, DESIGN_RESOURCE_SUBSTRATE_OBSERVATION_KINDS, `${label}.substrate_observation_refs[${observationIndex}]`));
+    return {
+        ...base,
+        mode,
+        blocker_ref: stableKey(row.blocker_ref, `${label}.blocker_ref`),
+        substrate_observation_refs: substrateObservationRefs,
+    };
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -0,0 +1,21 @@
+import type { SourceItemKind } from "./long-task-source-authority-types.js";
+import type { DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalSourceRecordV1 } from "./design-resource-implementation-feasibility-types.js";
+import type { DesignResourceImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
+import { type DesignResourceFeasibilityDecisionProjection } from "./design-resource-implementation-feasibility-source-decision-projection.js";
+export { DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA, parseDesignResourceFeasibilityDecisionProjections, } from "./design-resource-implementation-feasibility-source-decision-projection.js";
+export type { DesignResourceFeasibilityBlockerProjection, DesignResourceFeasibilityDecisionProjection, DesignResourcePlannedOwnerProjection, DesignResourceRequiredRealizationProjection, } from "./design-resource-implementation-feasibility-source-decision-projection.js";
+export interface LoadedDesignResourceFeasibilityDecisionSource {
+    source_record_ref: string;
+    source_path: string;
+    source_item_key: string;
+    source_item_kind: SourceItemKind;
+    text_sha256: string;
+    projections: DesignResourceFeasibilityDecisionProjection[];
+}
+export type DesignResourceFeasibilityDecisionSourceIndex = Map<string, LoadedDesignResourceFeasibilityDecisionSource>;
+export declare function loadDesignResourceFeasibilityDecisionSource(record: DesignResourceTechnicalSourceRecordV1, content: string): LoadedDesignResourceFeasibilityDecisionSource | null;
+export declare function deriveDesignResourceFeasibilityConditionScopeSha256(document: DesignResourceImplementationFeasibilityV1, model: DesignResourceImplementationFeasibilityTargetModel, profileRef: string): string;
+export declare function requireExactFeasibilityDecisionProjection(sourceRefs: string[], sources: DesignResourceFeasibilityDecisionSourceIndex, expectation: DesignResourceFeasibilityDecisionProjection, label: string, options: {
+    allReferencesMustBeSourceItems: boolean;
+    allowedItemKinds: readonly SourceItemKind[];
+}): LoadedDesignResourceFeasibilityDecisionSource;

package/dist/lib/design-resource-implementation-feasibility-source-decision.js

@@ -0,0 +1,75 @@
+import { parseSourceDocument } from "./long-task-source-item-parser.js";
+import { invalidFeasibility } from "./design-resource-implementation-feasibility-validation-support.js";
+import { parseDesignResourceFeasibilityDecisionProjections, } from "./design-resource-implementation-feasibility-source-decision-projection.js";
+import { createSymbolicDenotationCompilationSession } from "./symbolic-denotation-engine.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export { DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA, parseDesignResourceFeasibilityDecisionProjections, } from "./design-resource-implementation-feasibility-source-decision-projection.js";
+export function loadDesignResourceFeasibilityDecisionSource(record, content) {
+    if (record.locator.kind !== "source_item")
+        return null;
+    let parsed;
+    try {
+        parsed = parseSourceDocument(record.path, content);
+    }
+    catch (error) {
+        invalidFeasibility("source_item_document_invalid", `${record.key}:${message(error)}`);
+    }
+    const item = parsed.items.find((candidate) => candidate.key === record.locator.value);
+    if (!item)
+        invalidFeasibility("source_item_missing", `${record.key}:${record.locator.value}`);
+    if (item.text_sha256 !== record.locator.text_sha256)
+        invalidFeasibility("source_item_text_digest_mismatch", `${record.key}:${record.locator.text_sha256}:${item.text_sha256}`);
+    return {
+        source_record_ref: record.key,
+        source_path: record.path,
+        source_item_key: item.key,
+        source_item_kind: item.kind,
+        text_sha256: item.text_sha256,
+        projections: parseDesignResourceFeasibilityDecisionProjections(record.path, item.key, item.normalized_text),
+    };
+}
+export function deriveDesignResourceFeasibilityConditionScopeSha256(document, model, profileRef) {
+    if (document.condition_model.kind === "explicit_conditions_v1" &&
+        model.representation === "fact_cells_v1") {
+        const profile = document.condition_model.profiles.find((candidate) => candidate.key === profileRef);
+        if (!profile)
+            invalidFeasibility("condition_profile_unknown", profileRef);
+        return sha256Hex(canonicalValueJson([...profile.condition_refs].sort(compareText)));
+    }
+    if (document.condition_model.kind === "symbolic_regions_v2" &&
+        model.representation === "symbolic_rules_v2") {
+        const profile = document.condition_model.profiles.find((candidate) => candidate.key === profileRef);
+        if (!profile)
+            invalidFeasibility("condition_profile_unknown", profileRef);
+        return createSymbolicDenotationCompilationSession(model.axis_domains, [
+            profile.region,
+        ]).compile(profile.region).canonical_sha256;
+    }
+    invalidFeasibility("condition_model_representation_mismatch", profileRef);
+}
+export function requireExactFeasibilityDecisionProjection(sourceRefs, sources, expectation, label, options) {
+    if (options.allReferencesMustBeSourceItems)
+        for (const sourceRef of sourceRefs)
+            if (!sources.has(sourceRef))
+                invalidFeasibility("source_item_authority_required", `${label}:${sourceRef}`);
+    const matches = [];
+    for (const sourceRef of sourceRefs) {
+        const source = sources.get(sourceRef);
+        if (!source)
+            continue;
+        if (source.projections.some((projection) => canonicalValueJson(projection) === canonicalValueJson(expectation)))
+            matches.push(source);
+    }
+    if (matches.length !== 1)
+        invalidFeasibility("source_decision_projection_count", `${label}:${matches.length}`);
+    const match = matches[0];
+    if (!options.allowedItemKinds.includes(match.source_item_kind))
+        invalidFeasibility("source_decision_item_kind_invalid", `${label}:${match.source_item_kind}`);
+    return match;
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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;