project-tiny-context-harness 0.11.0 → 0.12.1

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

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

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

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

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

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

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

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