project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,124 +0,0 @@
-import { invalidDesignResourceHandoff, requireKnownDesignResourceRef, requireNonemptyDesignResourceValues, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
-export function validateDesignResourceScope(handoff) {
-    const scopedSurfaceKeys = new Set(handoff.scope.surface_keys);
-    const surfaceSubjects = handoff.subjects.filter((subject) => subject.kind === "surface");
-    const surfaceStableKeys = new Set(surfaceSubjects.flatMap((subject) => subject.stable_keys));
-    for (const surfaceKey of handoff.scope.surface_keys)
-        if (!surfaceStableKeys.has(surfaceKey))
-            invalidDesignResourceHandoff("scope_surface_subject_missing", surfaceKey);
-    for (const subject of surfaceSubjects)
-        if (!subject.stable_keys.some((key) => scopedSurfaceKeys.has(key)))
-            invalidDesignResourceHandoff("scope_surface_subject_outside_scope", subject.key);
-}
-export function validateDesignResourceConditions(handoff) {
-    const viewportProfiles = new Map();
-    const densityProfiles = new Map();
-    const safeAreaProfiles = new Map();
-    const textScaleProfiles = new Map();
-    for (const condition of handoff.conditions) {
-        requireConsistentConditionProfile(viewportProfiles, condition.viewport.key, `${condition.viewport.width}\0${condition.viewport.height}\0${condition.viewport.unit}`, "viewport", condition.key);
-        requireConsistentConditionProfile(densityProfiles, condition.density.key, String(condition.density.pixel_ratio), "density", condition.key);
-        requireConsistentConditionProfile(safeAreaProfiles, condition.safe_area.key, `${condition.safe_area.top}\0${condition.safe_area.right}\0${condition.safe_area.bottom}\0${condition.safe_area.left}\0${condition.safe_area.unit}`, "safe_area", condition.key);
-        requireConsistentConditionProfile(textScaleProfiles, condition.text_scale.key, String(condition.text_scale.multiplier), "text_scale", condition.key);
-        requireUniqueDesignResourceValues(condition.custom_axes.map((item) => item.axis_ref), `condition_custom_axis_duplicate:${condition.key}`);
-        requireUniqueDesignResourceValues(condition.custom_axes.map((item) => `${item.axis_ref}\0${item.value_ref}`), `condition_custom_axis_value_duplicate:${condition.key}`);
-    }
-}
-function requireConsistentConditionProfile(profiles, key, definition, profileKind, conditionKey) {
-    const existing = profiles.get(key);
-    if (existing !== undefined && existing !== definition)
-        invalidDesignResourceHandoff(`condition_${profileKind}_profile_conflict`, `${key}:${conditionKey}`);
-    profiles.set(key, definition);
-}
-export function validateDesignResourceSubjects(handoff, targets) {
-    const stableKeys = new Set();
-    const subjects = new Map(handoff.subjects.map((subject) => [subject.key, subject]));
-    for (const subject of handoff.subjects) {
-        requireNonemptyDesignResourceValues(subject.stable_keys, `subject_stable_keys_required:${subject.key}`);
-        requireUniqueDesignResourceValues(subject.stable_keys, `subject_stable_key_duplicate:${subject.key}`);
-        requireNonemptyDesignResourceValues(subject.target_refs, `subject_target_refs_required:${subject.key}`);
-        requireUniqueDesignResourceValues(subject.target_refs, `subject_target_ref_duplicate:${subject.key}`);
-        for (const ref of subject.target_refs)
-            requireKnownDesignResourceRef(targets, ref, "target");
-        for (const stableKey of subject.stable_keys) {
-            if (stableKeys.has(stableKey))
-                invalidDesignResourceHandoff("subject_stable_key_ambiguous", stableKey);
-            stableKeys.add(stableKey);
-        }
-        for (const ref of [
-            subject.parent_ref,
-            subject.instance_of_ref,
-            subject.override_of_ref,
-            subject.family_ref,
-            subject.portal_host_ref,
-        ])
-            if (ref !== null && !subjects.has(ref))
-                invalidDesignResourceHandoff("subject_hierarchy_ref_unknown", `${subject.key}:${ref}`);
-        requireUniqueDesignResourceValues(subject.census_refs, `subject_census_ref_duplicate:${subject.key}`);
-        requireUniqueDesignResourceValues(subject.relation_endpoints.map((item) => item.role), `subject_relation_endpoint_role_duplicate:${subject.key}`);
-        if (subject.presence === "always" && subject.presence_rule_ref !== null)
-            invalidDesignResourceHandoff("subject_always_presence_rule_forbidden", subject.key);
-        if (subject.presence !== "always" && subject.presence_rule_ref === null)
-            invalidDesignResourceHandoff("subject_dynamic_presence_rule_required", subject.key);
-        if (subject.presence === "virtualized" && subject.population_ref === null)
-            invalidDesignResourceHandoff("subject_virtualized_population_required", subject.key);
-    }
-}
-export function validateDesignResourceTargets(handoff, resources, conditions) {
-    for (const target of handoff.targets) {
-        requireNonemptyDesignResourceValues(target.resource_refs, `target_resource_refs_required:${target.key}`);
-        requireNonemptyDesignResourceValues(target.condition_refs, `target_condition_refs_required:${target.key}`);
-        requireUniqueDesignResourceValues(target.resource_refs, `target_resource_ref_duplicate:${target.key}`);
-        requireUniqueDesignResourceValues(target.condition_refs, `target_condition_ref_duplicate:${target.key}`);
-        for (const ref of target.resource_refs)
-            requireKnownDesignResourceRef(resources, ref, "resource");
-        for (const ref of target.condition_refs)
-            requireKnownDesignResourceRef(conditions, ref, "condition");
-        validateTargetSourceProfile(target, resources);
-        const expectedRole = target.interpretation === "exact_target" ? "exact_target" : "constraint";
-        if (!target.resource_refs.some((ref) => resources.get(ref)?.role === expectedRole))
-            invalidDesignResourceHandoff("target_interpretation_resource_role_missing", `${target.key}:${expectedRole}`);
-    }
-}
-function validateTargetSourceProfile(target, resources) {
-    const profile = target.source_profile;
-    requireKnownDesignResourceRef(resources, profile.entry_resource_ref, "source_profile_entry_resource");
-    requireUniqueDesignResourceValues(profile.dependency_resource_refs, `source_profile_dependency_resource_ref_duplicate:${target.key}`);
-    for (const ref of profile.dependency_resource_refs)
-        requireKnownDesignResourceRef(resources, ref, "source_profile_dependency_resource");
-    requireKnownDesignResourceRef(resources, profile.fact_manifest_resource_ref, "source_profile_fact_manifest_resource");
-    if (!profile.dependency_resource_refs.includes(profile.fact_manifest_resource_ref))
-        invalidDesignResourceHandoff("source_profile_fact_manifest_dependency_missing", target.key);
-    if (profile.dependency_resource_refs.includes(profile.entry_resource_ref))
-        invalidDesignResourceHandoff("source_profile_entry_repeated_as_dependency", target.key);
-    const declared = [
-        profile.entry_resource_ref,
-        ...profile.dependency_resource_refs,
-    ].sort();
-    const targetResources = [...target.resource_refs].sort();
-    if (declared.length !== targetResources.length ||
-        declared.some((ref, index) => ref !== targetResources[index]))
-        invalidDesignResourceHandoff("source_profile_resource_closure_mismatch", target.key);
-    const entry = resources.get(profile.entry_resource_ref);
-    if (profile.kind === "implementation_web" &&
-        !["text/html", "application/xhtml+xml"].includes(entry.media_type))
-        invalidDesignResourceHandoff("implementation_web_entry_media_type_invalid", `${target.key}:${entry.media_type}`);
-    if (profile.kind === "implementation_app" &&
-        !(entry.media_type.startsWith("text/") ||
-            [
-                "application/json",
-                "application/javascript",
-                "application/yaml",
-                "application/x-yaml",
-            ].includes(entry.media_type)))
-        invalidDesignResourceHandoff("implementation_app_entry_media_type_invalid", `${target.key}:${entry.media_type}`);
-}
-export function validateDesignResourceEvidence(handoff, resources, conditions) {
-    for (const item of handoff.evidence) {
-        requireKnownDesignResourceRef(resources, item.resource_ref, "resource");
-        requireNonemptyDesignResourceValues(item.condition_refs, `evidence_condition_refs_required:${item.key}`);
-        requireUniqueDesignResourceValues(item.condition_refs, `evidence_condition_ref_duplicate:${item.key}`);
-        for (const ref of item.condition_refs)
-            requireKnownDesignResourceRef(conditions, ref, "condition");
-    }
-}

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

@@ -1,8 +0,0 @@
-import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
-import type { DesignResourceHandoffPreflightV1, ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
-import type { DesignResourceHandoffPreflightV2 } from "./design-resource-symbolic-fact-types.js";
-import type { ParsedDesignResourceHandoffInput } from "./design-resource-handoff-input-types.js";
-export declare function preflightDesignResourceHandoff(repository: string, handoffPath: string): Promise<DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2>;
-export declare function preflightParsedDesignResourceHandoffAny(repository: string, parsed: ParsedDesignResourceHandoffInput): Promise<DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2>;
-export declare function preflightParsedDesignResourceHandoff(repository: string, parsed: ParsedDesignResourceHandoffInputV1): Promise<DesignResourceHandoffPreflightV1>;
-export declare function validateDesignResourceHandoffSemantics(parsed: ParsedDesignResourceHandoffV1): void;

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

@@ -1,165 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { parseDesignResourceHandoffMarkdown } from "./design-resource-handoff-parser.js";
-import { validateDesignResourceFiles } from "./design-resource-handoff-file-validation.js";
-import { parseDesignResourceFactManifests, validateDesignResourceFactManifests, } from "./design-resource-fact-manifest-validation.js";
-import { hydrateManifestBackedDesignResourceHandoff } from "./design-resource-handoff-manifest-projection.js";
-import { readDesignResourceSnapshot } from "./design-resource-handoff-snapshot.js";
-import { validateDesignResourceFacts } from "./design-resource-handoff-validation-facts.js";
-import { preflightParsedDesignResourceSymbolicHandoff } from "./design-resource-symbolic-fact-validation.js";
-import { validateDesignResourceBlockers, validateDesignResourceCoverage, validateDesignResourceReachability, } from "./design-resource-handoff-validation-coverage.js";
-import { indexDesignResourceItems, invalidDesignResourceHandoff, requireNonemptyDesignResourceValues, requireUniqueDesignResourceObjects, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
-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);
-    const parsed = parseDesignResourceHandoffMarkdown(handoffPath, await readFile(handoffFile, "utf8"));
-    return preflightParsedDesignResourceHandoffAny(repository, parsed);
-}
-export async function preflightParsedDesignResourceHandoffAny(repository, parsed) {
-    if (isParsedSymbolicHandoff(parsed))
-        return preflightParsedDesignResourceSymbolicHandoff(repository, parsed);
-    return preflightParsedDesignResourceHandoff(repository, parsed);
-}
-function isParsedSymbolicHandoff(parsed) {
-    return parsed.handoff.schema_version === "design-resource-handoff-v2";
-}
-export async function preflightParsedDesignResourceHandoff(repository, parsed) {
-    const inputHandoff = parsed.handoff;
-    if (isManifestBacked(inputHandoff) && inputHandoff.targets.length !== 1)
-        invalidDesignResourceHandoff("manifest_backed_one_target_required", String(inputHandoff.targets.length));
-    if (!isManifestBacked(inputHandoff))
-        validateDesignResourceHandoffSemantics({
-            ...parsed,
-            handoff: inputHandoff,
-        });
-    const snapshot = await readDesignResourceSnapshot(repository, parsed);
-    const manifests = parseDesignResourceFactManifests(parsed, snapshot.contents);
-    const handoff = isManifestBacked(inputHandoff)
-        ? hydrateManifestBackedDesignResourceHandoff(inputHandoff, manifests)
-        : inputHandoff;
-    const normalized = { ...parsed, handoff };
-    if (isManifestBacked(inputHandoff))
-        validateDesignResourceHandoffSemantics(normalized);
-    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);
-            const manifest = manifests.get(target.key);
-            return {
-                resource_ref: resourceRef,
-                path: resource.path,
-                sha256: snapshot.hashes[resourceRef],
-                scope_key: manifest.scope_key,
-                target_key: manifest.target_key,
-                collections: manifest.generation.collections.map((collection) => ({
-                    ...collection,
-                })),
-            };
-        }),
-        counts: {
-            resources: handoff.resources.length,
-            manifests: manifests.size,
-            axis_dispositions: handoff.axis_dispositions.length,
-            conditions: handoff.conditions.length,
-            subjects: handoff.subjects.length,
-            variations: handoff.variations.length,
-            properties: handoff.properties.length,
-            lineage_nodes: handoff.lineage_nodes.length,
-            targets: handoff.targets.length,
-            evidence: handoff.evidence.length,
-            fact_cells: handoff.fact_cells.length,
-            facts: handoff.facts.length,
-            proof_obligations: handoff.proof_obligations.length,
-            oracles: handoff.oracles.length,
-            environments: handoff.environments.length,
-            asset_bindings: handoff.asset_bindings.length,
-            resource_fact_closure: handoff.resource_fact_closure.length,
-            coverage: handoff.coverage.length,
-            acceptance_blockers: handoff.acceptance_blockers.length,
-        },
-    };
-}
-function isManifestBacked(handoff) {
-    return "representation" in handoff;
-}
-export function validateDesignResourceHandoffSemantics(parsed) {
-    const { handoff } = parsed;
-    requireNonemptyDesignResourceValues(handoff.scope.surface_keys, "scope_surface_keys_required");
-    requireNonemptyDesignResourceValues(handoff.resources, "resources_required");
-    requireNonemptyDesignResourceValues(handoff.axis_dispositions, "axis_dispositions_required");
-    requireNonemptyDesignResourceValues(handoff.conditions, "conditions_required");
-    requireNonemptyDesignResourceValues(handoff.subjects, "subjects_required");
-    requireNonemptyDesignResourceValues(handoff.variation_axis_dispositions, "variation_axis_dispositions_required");
-    requireNonemptyDesignResourceValues(handoff.variations, "variations_required");
-    requireNonemptyDesignResourceValues(handoff.properties, "properties_required");
-    requireNonemptyDesignResourceValues(handoff.targets, "targets_required");
-    requireNonemptyDesignResourceValues(handoff.evidence, "evidence_required");
-    requireNonemptyDesignResourceValues(handoff.fact_cells, "fact_cells_required");
-    requireNonemptyDesignResourceValues(handoff.facts, "facts_required");
-    requireNonemptyDesignResourceValues(handoff.proof_obligations, "proof_obligations_required");
-    requireNonemptyDesignResourceValues(handoff.oracles, "oracles_required");
-    requireNonemptyDesignResourceValues(handoff.environments, "environments_required");
-    requireNonemptyDesignResourceValues(handoff.resource_fact_closure, "resource_fact_closure_required");
-    requireNonemptyDesignResourceValues(handoff.coverage, "coverage_required");
-    requireUniqueDesignResourceValues(handoff.scope.surface_keys, "scope_surface_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.resources, "resource_key_duplicate");
-    requireUniqueDesignResourceValues(handoff.resources.map((item) => item.path), "resource_path_duplicate");
-    requireUniqueDesignResourceObjects(handoff.axis_dispositions, "axis_disposition_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.condition_exclusions, "condition_exclusion_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.conditions, "condition_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.subjects, "subject_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.variation_axis_dispositions, "variation_axis_disposition_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.variation_exclusions, "variation_exclusion_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.variations, "variation_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.properties, "property_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.lineage_nodes, "lineage_node_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.targets, "target_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.evidence, "evidence_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.facts, "fact_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.fact_cells, "fact_cell_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.proof_obligations, "proof_obligation_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.oracles, "oracle_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.environments, "environment_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.asset_bindings, "asset_binding_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.resource_fact_closure, "resource_fact_closure_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.coverage, "coverage_key_duplicate");
-    requireUniqueDesignResourceObjects(handoff.acceptance_blockers, "acceptance_blocker_key_duplicate");
-    const resources = indexDesignResourceItems(handoff.resources);
-    const conditions = indexDesignResourceItems(handoff.conditions);
-    const subjects = indexDesignResourceItems(handoff.subjects);
-    const targets = indexDesignResourceItems(handoff.targets);
-    const evidence = indexDesignResourceItems(handoff.evidence);
-    const facts = indexDesignResourceItems(handoff.facts);
-    const sourceItems = new Map(Object.entries(parsed.source_item_kinds));
-    validateDesignResourceScope(handoff);
-    validateDesignResourceConditions(handoff);
-    validateDesignResourceSubjects(handoff, targets);
-    validateDesignResourceTargets(handoff, resources, conditions);
-    validateDesignResourceEvidence(handoff, resources, conditions);
-    validateDesignResourceCoverage(handoff, subjects, targets, conditions, evidence, facts, sourceItems);
-    validateDesignResourceFacts(handoff, resources, conditions, subjects, targets, evidence, sourceItems);
-    validateDesignResourceBlockers(handoff, subjects, targets, sourceItems);
-    validateDesignResourceReachability(handoff);
-}

package/dist/lib/design-resource-handoff-web-dependency-validation.d.ts

@@ -1,6 +0,0 @@
-import { type DesignResource } from "./design-resource-handoff-file-primitives.js";
-export declare function validateDesignResourceImplementationDependencyClosure(target: {
-    key: string;
-    resource_refs: string[];
-}, resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;
-export declare const validateDesignResourceWebDependencyClosure: typeof validateDesignResourceImplementationDependencyClosure;

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

@@ -1,130 +0,0 @@
-import path from "node:path";
-import { htmlAttributes, isTextResource, } from "./design-resource-handoff-file-primitives.js";
-import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
-export function validateDesignResourceImplementationDependencyClosure(target, resources, contents) {
-    const declaredPaths = new Set(target.resource_refs.map((ref) => resources.get(ref).path));
-    for (const resourceRef of target.resource_refs) {
-        const resource = resources.get(resourceRef);
-        if (!isTextResource(resource))
-            continue;
-        const content = contents.get(resourceRef).toString("utf8");
-        for (const reference of localDependencyReferences(content, resource.media_type)) {
-            const resolved = resolveResourceReference(resource.path, reference);
-            const declared = resolveDeclaredPath(declaredPaths, resolved);
-            if (declared === null)
-                invalidDesignResourceHandoff("implementation_dependency_undeclared", `${target.key}:${resource.path}:${reference}:${resolved}`);
-        }
-    }
-}
-function localDependencyReferences(content, mediaType) {
-    const values = new Set();
-    const markupMediaTypes = [
-        "text/html",
-        "application/xhtml+xml",
-        "image/svg+xml",
-    ];
-    if (markupMediaTypes.includes(mediaType)) {
-        for (const tag of content.matchAll(/<(script|img|source|video|audio|track|iframe|embed|input|link|object|use|image)\b([^<>]*)>/giu)) {
-            const attributes = htmlAttributes(tag[2]);
-            for (const name of ["src", "href", "xlink:href", "poster"])
-                addLocalReference(values, attributes.get(name));
-            if (tag[1].toLowerCase() === "object")
-                addLocalReference(values, attributes.get("data"));
-            for (const candidate of (attributes.get("srcset") ?? "").split(","))
-                addLocalReference(values, candidate.trim().split(/\s+/u)[0]);
-        }
-    }
-    if (mediaType === "text/css" || markupMediaTypes.includes(mediaType))
-        for (const match of content.matchAll(/(?:url\(\s*["']?([^"')\s]+)|@import\s+(?:url\(\s*)?["']([^"']+))/giu))
-            addLocalReference(values, match[1] ?? match[2]);
-    if ([
-        "text/javascript",
-        "application/javascript",
-        "text/typescript",
-        "application/typescript",
-        "text/ecmascript",
-        "application/ecmascript",
-        "text/html",
-        "application/xhtml+xml",
-        "image/svg+xml",
-    ].includes(mediaType)) {
-        for (const match of content.matchAll(/(?:\b(?:from|import)\s*|\bimport\s*\(|\brequire\s*\()\s*["']([^"']+)["']/gu))
-            addModuleReference(values, match[1]);
-        for (const match of content.matchAll(/(?:\bfetch\s*\(|\bnew\s+(?:Shared)?Worker\s*\(|\bnew\s+URL\s*\()\s*["']([^"']+)["']/gu))
-            addLocalReference(values, match[1]);
-    }
-    return values;
-}
-function addModuleReference(values, raw) {
-    if (!raw)
-        return;
-    const value = raw.trim();
-    if (!value.startsWith(".") && !value.startsWith("/"))
-        return;
-    addLocalReference(values, value);
-}
-function addLocalReference(values, raw) {
-    if (!raw)
-        return;
-    const value = raw.trim();
-    if (!value ||
-        value.startsWith("#") ||
-        /^(?:[a-z][a-z0-9+.-]*:|\/\/)/iu.test(value))
-        return;
-    values.add(value.replace(/[?#].*$/u, ""));
-}
-function resolveResourceReference(from, reference) {
-    if (reference.startsWith("/"))
-        invalidDesignResourceHandoff("implementation_dependency_path_unsafe", `${from}:${reference}`);
-    const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(from), reference));
-    if (resolved === ".." ||
-        resolved.startsWith("../") ||
-        path.posix.isAbsolute(resolved))
-        invalidDesignResourceHandoff("implementation_dependency_path_unsafe", `${from}:${reference}`);
-    return resolved;
-}
-function resolveDeclaredPath(declaredPaths, resolved) {
-    if (declaredPaths.has(resolved))
-        return resolved;
-    const candidates = [
-        ...[
-            ".js",
-            ".jsx",
-            ".mjs",
-            ".cjs",
-            ".ts",
-            ".tsx",
-            ".json",
-            ".css",
-            ".svg",
-            ".png",
-            ".jpg",
-            ".jpeg",
-            ".webp",
-            ".avif",
-            ".gif",
-            ".ico",
-            ".woff",
-            ".woff2",
-            ".ttf",
-            ".otf",
-            ".mp4",
-            ".webm",
-            ".mp3",
-            ".wav",
-            ".lottie",
-        ].map((extension) => `${resolved}${extension}`),
-        ...[
-            "index.js",
-            "index.jsx",
-            "index.mjs",
-            "index.ts",
-            "index.tsx",
-            "index.json",
-        ].map((name) => `${resolved}/${name}`),
-    ].filter((candidate) => declaredPaths.has(candidate));
-    if (candidates.length > 1)
-        invalidDesignResourceHandoff("implementation_dependency_resolution_ambiguous", `${resolved}:${candidates.join(",")}`);
-    return candidates[0] ?? null;
-}
-export const validateDesignResourceWebDependencyClosure = validateDesignResourceImplementationDependencyClosure;

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

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

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

@@ -1,43 +0,0 @@
-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;
-}[];