project-tiny-context-harness 0.8.16 → 0.8.17

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;

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