project-tiny-context-harness 0.8.13 → 0.8.17

package/dist/commands/design-resource.js

@@ -29,9 +29,15 @@ export async function designResource(args) {
         process.stdout.write(canonicalJson(result));
         return;
     }
-    console.log(`Design resource handoff ready: ${result.handoff_path}`);
+    console.log(`Design resource handoff preflight valid: ${result.handoff_path}`);
+    console.log("Input closure: valid");
     console.log(`Scope: ${result.handoff.scope.key}`);
     console.log(`Targets: ${result.handoff.targets.map((item) => item.key).join(", ")}`);
+    console.log(`Technical feasibility inputs: ${result.technical_feasibility_identities.length}`);
+    console.log(`Technical feasibility cells: ${result.technical_feasibility_identities.reduce((total, item) => total + item.component_family_cells, 0)}`);
+    console.log(`Technical feasibility blockers: ${result.technical_feasibility_identities.reduce((total, item) => total + item.blockers, 0)}`);
+    console.log(`Limitations: ${result.limitations.length ? result.limitations.join("; ") : "none"}`);
+    console.log("Production conformance: not evaluated");
     if ("metrics" in result) {
         console.log(`Coverage: ${result.manifest.subjects.length} subjects x ${result.manifest.properties.length} atomic properties (${result.rule_projections.length} symbolic Rules)`);
         console.log(`Symbolic: ${result.metrics.semantic_obligations} semantic obligations, ${result.metrics.certificate_obligations} certificates, ${result.metrics.canonical_dag_nodes} DAG nodes, ${result.metrics.canonical_bytes} bytes`);
@@ -88,7 +94,8 @@ async function bundle(args) {
         process.stdout.write(canonicalJson(result));
         return;
     }
-    console.log(`Design resource handoff bundle published: ${result.output_directory}`);
+    console.log(`Design resource Source bundle published: ${result.output_directory}`);
+    console.log("Production readiness: not evaluated");
     console.log(`Handoffs: ${result.handoffs.length}`);
     console.log(`Targets: ${result.handoffs.map((item) => item.target_key).join(", ")}`);
 }

package/dist/commands/long-task-revision.js

@@ -90,7 +90,7 @@ function printCompileResult(compiled, previous, preserveProgress, revisionPropos
             ? projectAuthorityRevisionDecision(revisionProposal)
             : null,
         next_action: firstAuthorityLock
-            ? "End this turn now. Do not implement, edit files, build, or test. After the user handles the model change in the host, wait for [continue]. Harness cannot observe or verify the model change."
+            ? "End this turn now. Do not implement, edit files, build, or test. After the user handles the model change in the host, ask them to reply exactly: model checkpoint cleared, continue. This is package-managed prompt guidance; Harness cannot observe the next host message or verify the model change."
             : authorityChanged
                 ? "Run status or resume, then continue rolling implementation or repair under the adopted Authority Revision."
                 : "Continue rolling implementation or repair under the active Authority.",
@@ -158,7 +158,7 @@ function executionModelCheckpoint(firstAuthorityLock) {
         required: true,
         phase: "post_authority_lock_pre_implementation",
         action: "change_model_in_host_then_continue",
-        resume_token: "continue",
+        resume_token: "model checkpoint cleared, continue",
         turn_boundary: "end_current_turn",
         blocked_until_resume: [
             "product_implementation",
@@ -168,8 +168,8 @@ function executionModelCheckpoint(firstAuthorityLock) {
         ],
         model_change_owner: "host_or_user",
         model_change_observable_by_harness: false,
-        generic_continue_satisfies: true,
-        message: "Authority Lock created. End the current turn before product implementation, file edits, builds, or tests. After handling the model change, send [continue]. Harness cannot observe or verify the model change.",
+        generic_continue_satisfies: false,
+        message: "Authority Lock created. End the current turn before product implementation, file edits, builds, or tests. After handling the model change, reply exactly: model checkpoint cleared, continue. This is package-managed prompt guidance; Harness cannot observe the next host message or verify the model change.",
     };
 }
 function message(error) {

package/dist/index.d.ts

@@ -10,4 +10,4 @@ export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
 export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";
 export { closeDeliveryTask, type DeliveryStatusV2, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "./lib/long-task-status-v2.js";
 export { readActiveLongTaskBinding, readCompiledDeliveryContract, readFinalReceipt, } from "./lib/long-task-state.js";
-export type { BoundaryCheckDecisionV2, BoundaryCheckInputV2, CheckExecutionResultV2, CompiledDeliveryContractV2, DesignResourceHandoffBundleOptions, DesignResourceHandoffBundleResult, DesignResourceHandoffPreflightV1, DesignResourceHandoffPreflightV2, DesignResourceHandoffV1, DesignResourceHandoffV2, DesignResourceObservableRuleManifestV2, DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicProofObligationV2, DesignResourceSymbolicSourceIrCertificateScopeV1, DesignResourceSymbolicSourceIrRegionV1, DesignResourceSymbolicSourceIrV1, CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate, SymbolicExtensionalPointV1, SymbolicPointDenotationV1, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, EffectiveRiskLevel, ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, LongTaskRiskFacts, ProofSurface, ProgressRecordV2, RequestedRiskLevel, RunnerType, SourceClaimV2, TargetedVerificationResultV2, HarnessConfig, HarnessProfile, ManagedFile, SourceMapping, } from "./public-types.js";
+export type { BoundaryCheckDecisionV2, BoundaryCheckInputV2, CheckExecutionResultV2, CompiledDeliveryContractV2, DesignResourceHandoffBundleOptions, DesignResourceHandoffBundleResult, DesignResourceHandoffPreflightV1, DesignResourceHandoffPreflightV2, DesignResourceHandoffV1, DesignResourceHandoffV2, DesignResourceImplementationFeasibilityIdentityV1, DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalFeasibilityInputV1, DesignResourceObservableRuleManifestV2, DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicProofObligationV2, DesignResourceSymbolicSourceIrCertificateScopeV1, DesignResourceSymbolicSourceIrRegionV1, DesignResourceSymbolicSourceIrV1, CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate, SymbolicExtensionalPointV1, SymbolicPointDenotationV1, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, EffectiveRiskLevel, ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, LongTaskRiskFacts, ProofSurface, ProgressRecordV2, RequestedRiskLevel, RunnerType, SourceClaimV2, TargetedVerificationResultV2, HarnessConfig, HarnessProfile, ManagedFile, SourceMapping, } from "./public-types.js";

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

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

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

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

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

@@ -11,6 +11,7 @@ export function hydrateManifestBackedDesignResourceHandoff(descriptor, manifests
         intent: descriptor.intent,
         scope: descriptor.scope,
         provenance: descriptor.provenance,
+        technical_feasibility_inputs: descriptor.technical_feasibility_inputs,
         resources: descriptor.resources,
         axis_dispositions: manifest.axis_dispositions,
         condition_exclusions: manifest.condition_exclusions,

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

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

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

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

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

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

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

@@ -12,6 +12,8 @@ import { indexDesignResourceItems, invalidDesignResourceHandoff, requireNonempty
 import { validateDesignResourceConditions, validateDesignResourceEvidence, validateDesignResourceScope, validateDesignResourceSubjects, validateDesignResourceTargets, } from "./design-resource-handoff-validation-structure.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { assertDesignResourceV1HandoffCapacity } from "./design-resource-v1-capacity.js";
+import { createV1ImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
+import { readAndValidateDesignResourceImplementationFeasibility } from "./design-resource-implementation-feasibility-validation.js";
 export async function preflightDesignResourceHandoff(repository, handoffPath) {
     const handoffFile = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...handoffPath.split("/")), "design_resource_handoff");
     await assertDesignResourceV1HandoffCapacity(handoffFile);
@@ -46,11 +48,21 @@ export async function preflightParsedDesignResourceHandoff(repository, parsed) {
     validateDesignResourceFiles(normalized, snapshot.contents);
     validateDesignResourceFactManifests(normalized, snapshot.contents, manifests, !isManifestBacked(inputHandoff));
     const resources = new Map(handoff.resources.map((resource) => [resource.key, resource]));
+    const feasibility = await readAndValidateDesignResourceImplementationFeasibility(repository, parsed.handoff_path, handoff.technical_feasibility_inputs, new Map(handoff.targets.map((target) => [
+        target.key,
+        createV1ImplementationFeasibilityTargetModel(handoff, target),
+    ])), new Set(handoff.resources.map((resource) => resource.path)));
     return {
         schema_version: "design-resource-handoff-preflight-v1",
         status: "ready",
         ...normalized,
         resource_hashes: snapshot.hashes,
+        technical_feasibility_documents: feasibility.map((item) => item.document),
+        technical_feasibility_identities: feasibility.map((item) => item.identity),
+        limitations: handoff.targets.some((target) => target.source_profile.kind !== "reference" &&
+            !feasibility.some((item) => item.index.target_ref === target.key))
+            ? ["technical feasibility not declared"]
+            : [],
         manifest_identities: handoff.targets.map((target) => {
             const resourceRef = target.source_profile.fact_manifest_resource_ref;
             const resource = resources.get(resourceRef);

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

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

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

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

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

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

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

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

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;