project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/lib/design-resource-symbolic-fact-types.d.ts

@@ -0,0 +1,213 @@
+import type { DesignResourceDesignSystemSnapshotV1, DesignResourceInspectorV1 } from "./design-resource-fact-manifest-model.js";
+import type { DesignResourceEnvironmentV1, DesignResourceFactLineageV1, DesignResourceLocatedDigestV1, DesignResourceOracleV1, DesignResourcePropertyDefinitionV1 } from "./design-resource-fact-types.js";
+import type { DesignResourceHandoffBlockerV1, DesignResourceHandoffResourceV1, DesignResourceHandoffSubjectV1, DesignResourceSourceProfileKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
+import type { CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationDisposition, SymbolicDenotationPredicate, SymbolicExtensionalPointV1 } from "./symbolic-denotation-types.js";
+import type { DesignResourceSymbolicNoninterferenceCertificateV2 } from "./design-resource-symbolic-noninterference-types.js";
+export type { DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceEquivalenceCaseV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofMethodV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicStaticDependencyNodeV2, DesignResourceSymbolicStaticDependencyRootV2, } from "./design-resource-symbolic-noninterference-types.js";
+export interface DesignResourceSymbolicPopulationV2 {
+    key: string;
+    kind: "static" | "dynamic";
+    member_subject_refs: string[];
+    universe: DesignResourceLocatedDigestV1;
+    enumeration: "complete" | "symbolic_partition";
+    exclusions: Array<{
+        key: string;
+        region: SymbolicDenotationPredicate;
+        basis_refs: string[];
+        rationale: string;
+    }>;
+    quantifier: SymbolicExtensionalPointV1["quantifier"];
+}
+export interface DesignResourceSymbolicFactRuleV2 {
+    key: string;
+    subject_or_relation_ref: string;
+    target_ref: string;
+    property_ref: string;
+    population_ref: string | null;
+    quantifier: SymbolicExtensionalPointV1["quantifier"];
+    region: SymbolicDenotationPredicate;
+    expected: DesignResourceLocatedDigestV1;
+    value_kind: string;
+    provenance_ref: string;
+    observation_scope: "subject" | "full_target";
+    observation_sensitivity: "plain" | "protected";
+    lineage: DesignResourceFactLineageV1;
+    evidence_refs: string[];
+    census_refs: string[];
+    source_item_refs: string[];
+    semantic_obligation_refs: string[];
+}
+export interface DesignResourceSymbolicDispositionRegionV2 {
+    key: string;
+    subject_or_relation_ref: string;
+    target_ref: string;
+    property_ref: string;
+    population_ref: string | null;
+    quantifier: SymbolicExtensionalPointV1["quantifier"];
+    region: SymbolicDenotationPredicate;
+    disposition: Exclude<SymbolicDenotationDisposition, "specified">;
+    census_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}
+export interface DesignResourceSymbolicProofObligationV2 {
+    key: string;
+    fact_rule_ref: string;
+    method: DesignResourceVerificationMethod;
+    region_sha256: string;
+    proof_surface: string;
+    observation_boundary: string;
+    comparison: {
+        comparator: string;
+        mode: "exact" | "tolerance";
+        parameters: DesignResourceLocatedDigestV1;
+        tolerance: DesignResourceLocatedDigestV1 | null;
+        mask: DesignResourceLocatedDigestV1 | null;
+    };
+    oracle_ref: string;
+    environment_ref: string;
+    protected_value_policy: string;
+    completion_effect: string;
+}
+export interface DesignResourceSymbolicDependencyEdgeV2 {
+    key: string;
+    axis_ref: string;
+    fact_rule_ref: string;
+    effects: Array<"disposition" | "expected_semantics" | "proof_denotation">;
+}
+export interface DesignResourceSymbolicSubjectProfileBindingV2 {
+    key: string;
+    subject_refs: string[];
+    profile_refs: string[];
+    census_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}
+export interface DesignResourceSymbolicCustomPropertyClosureV2 {
+    property_ref: string;
+    applicable_subject_refs: string[];
+    census_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}
+export interface DesignResourceSymbolicApplicabilityExceptionV2 {
+    key: string;
+    subject_ref: string;
+    property_ref: string;
+    disposition: "applicable" | "not_applicable";
+    census_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}
+export interface DesignResourceSymbolicStructuralApplicabilityV2 {
+    profile_catalog: "package-subject-property-applicability-v1";
+    subject_profile_bindings: DesignResourceSymbolicSubjectProfileBindingV2[];
+    inspector_custom_property_closure: DesignResourceSymbolicCustomPropertyClosureV2[];
+    instance_exceptions: DesignResourceSymbolicApplicabilityExceptionV2[];
+}
+export interface DesignResourceObservableRuleManifestV2 {
+    schema_version: "design-resource-observable-rule-manifest-v2";
+    scope_key: string;
+    target_key: string;
+    inspector: DesignResourceInspectorV1;
+    design_system: DesignResourceDesignSystemSnapshotV1;
+    axis_domains: SymbolicDenotationAxisDomain[];
+    reachable_region: SymbolicDenotationPredicate;
+    subjects: DesignResourceHandoffSubjectV1[];
+    populations: DesignResourceSymbolicPopulationV2[];
+    properties: DesignResourcePropertyDefinitionV1[];
+    fact_rules: DesignResourceSymbolicFactRuleV2[];
+    disposition_regions: DesignResourceSymbolicDispositionRegionV2[];
+    semantic_proof_obligations: DesignResourceSymbolicProofObligationV2[];
+    dependency_edges: DesignResourceSymbolicDependencyEdgeV2[];
+    noninterference_certificates: DesignResourceSymbolicNoninterferenceCertificateV2[];
+    oracles: DesignResourceOracleV1[];
+    environments: DesignResourceEnvironmentV1[];
+    acceptance_blockers: DesignResourceHandoffBlockerV1[];
+    structural_applicability?: DesignResourceSymbolicStructuralApplicabilityV2;
+}
+export interface DesignResourceSymbolicHandoffTargetV2 {
+    key: string;
+    interpretation: "exact_target" | "constraint";
+    resource_refs: string[];
+    source_profile: {
+        kind: DesignResourceSourceProfileKind;
+        entry_resource_ref: string;
+        dependency_resource_refs: string[];
+        fact_manifest_resource_ref: string;
+        acquisition: "complete";
+    };
+    selection_basis: string;
+}
+export interface DesignResourceSymbolicHandoffCoverageV2 {
+    key: string;
+    target_ref: string;
+    subject_or_relation_refs: string[];
+    property_refs: string[];
+    fact_rule_refs: string[];
+    semantic_obligation_refs: string[];
+    certificate_refs: string[];
+    source_item_refs: string[];
+    rationale: string;
+}
+export interface DesignResourceHandoffV2 {
+    schema_version: "design-resource-handoff-v2";
+    representation: "symbolic_rules_v2";
+    intent: "implementation_handoff";
+    scope: {
+        key: string;
+        style_dependency: "style-bearing" | "non-fidelity" | "mixed";
+        surface_keys: string[];
+        necessary_context: string[];
+        exclusions: string[];
+    };
+    provenance: {
+        provider: string;
+        provider_version: string;
+        project: string;
+        run: string;
+        capability: string;
+        agent: string;
+        model: string;
+        design_system_id: string;
+    };
+    resources: DesignResourceHandoffResourceV1[];
+    targets: DesignResourceSymbolicHandoffTargetV2[];
+    coverage: DesignResourceSymbolicHandoffCoverageV2[];
+    proposal: {
+        reconciliation_status: "applied" | "returned" | "not_applicable";
+        path: string;
+        revision: string;
+    };
+}
+export interface ParsedDesignResourceHandoffV2 {
+    handoff_path: string;
+    handoff: DesignResourceHandoffV2;
+    source_item_keys: string[];
+    source_item_kinds: Record<string, string>;
+}
+export interface DesignResourceSymbolicRuleProjectionV2 {
+    rule: DesignResourceSymbolicFactRuleV2;
+    compiled_region: CompiledSymbolicDenotationV1;
+}
+export interface DesignResourceHandoffPreflightV2 extends ParsedDesignResourceHandoffV2 {
+    preflight_schema_version: "design-resource-handoff-preflight-v2";
+    status: "ready";
+    manifest: DesignResourceObservableRuleManifestV2;
+    resource_hashes: Record<string, string>;
+    rule_projections: DesignResourceSymbolicRuleProjectionV2[];
+    metrics: {
+        semantic_obligations: number;
+        certificate_obligations: number;
+        certificate_covered_omitted_axes: number;
+        certificate_covered_dependency_edges: number;
+        canonical_dag_nodes: number;
+        canonical_partition_edges: number;
+        canonical_bytes: number;
+        theoretical_ground_cardinality: string;
+    };
+}

package/dist/lib/design-resource-symbolic-fact-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/design-resource-symbolic-fact-validation.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceHandoffPreflightV2, ParsedDesignResourceHandoffV2 } from "./design-resource-symbolic-fact-types.js";
+export { designResourceSymbolicCertificateKey, designResourceSymbolicCombinedRuleDigest, designResourceSymbolicDependencyEdge, designResourceSymbolicNoninterferenceProofDigest, designResourceSymbolicObligationKey, designResourceSymbolicRuleKey, } from "./design-resource-symbolic-validation-support.js";
+export declare function preflightParsedDesignResourceSymbolicHandoff(repository: string, parsed: ParsedDesignResourceHandoffV2): Promise<DesignResourceHandoffPreflightV2>;

package/dist/lib/design-resource-symbolic-fact-validation.js

@@ -0,0 +1,86 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { validateDesignResourceImplementationDependencyClosure } from "./design-resource-handoff-web-dependency-validation.js";
+import { parseDesignResourceObservableRuleManifestJson } from "./design-resource-symbolic-fact-shape.js";
+import { validateDesignResourceSymbolicManifest } from "./design-resource-symbolic-manifest-validation.js";
+import { validateSymbolicCoverage } from "./design-resource-symbolic-region-validation.js";
+import { assertSameSet, invalid, requireExactRefs, unique, } from "./design-resource-symbolic-validation-support.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { sha256Hex } from "./strict-codec.js";
+export { designResourceSymbolicCertificateKey, designResourceSymbolicCombinedRuleDigest, designResourceSymbolicDependencyEdge, designResourceSymbolicNoninterferenceProofDigest, designResourceSymbolicObligationKey, designResourceSymbolicRuleKey, } from "./design-resource-symbolic-validation-support.js";
+const V2_MANIFEST_MAX_BYTES = 8_388_608;
+export async function preflightParsedDesignResourceSymbolicHandoff(repository, parsed) {
+    const { handoff } = parsed;
+    validateHandoffIdentities(handoff);
+    if (handoff.targets.length !== 1)
+        invalid("v2_one_target_required", String(handoff.targets.length));
+    const target = handoff.targets[0];
+    if (!handoff.scope.surface_keys.length)
+        invalid("v2_scope_surface_keys_required", target.key);
+    const resources = new Map(handoff.resources.map((resource) => [resource.key, resource]));
+    requireExactRefs(target.resource_refs, resources, "v2_target_resource");
+    const manifestResource = resources.get(target.source_profile.fact_manifest_resource_ref);
+    if (!manifestResource)
+        invalid("v2_manifest_resource_unknown", target.source_profile.fact_manifest_resource_ref);
+    validateManifestResource(target, manifestResource);
+    assertSameSet(target.resource_refs, [
+        target.source_profile.entry_resource_ref,
+        ...target.source_profile.dependency_resource_refs,
+    ], "v2_source_profile_resource_closure_mismatch", target.key);
+    const { contents, resourceHashes } = await readAndVerifyResources(repository, parsed, manifestResource.key);
+    if (target.source_profile.kind === "implementation_web" ||
+        target.source_profile.kind === "implementation_app")
+        validateDesignResourceImplementationDependencyClosure(target, resources, contents);
+    const manifest = parseDesignResourceObservableRuleManifestJson(contents.get(manifestResource.key).toString("utf8"));
+    if (manifest.scope_key !== handoff.scope.key ||
+        manifest.target_key !== target.key)
+        invalid("v2_manifest_identity_mismatch", `${manifest.scope_key}:${manifest.target_key}`);
+    const validated = validateDesignResourceSymbolicManifest(manifest, parsed, resources, contents);
+    validateSymbolicCoverage(parsed, manifest);
+    return {
+        ...parsed,
+        preflight_schema_version: "design-resource-handoff-preflight-v2",
+        status: "ready",
+        manifest,
+        resource_hashes: resourceHashes,
+        rule_projections: validated.ruleProjections,
+        metrics: validated.metrics,
+    };
+}
+function validateHandoffIdentities(handoff) {
+    unique(handoff.resources.map((item) => item.key), "v2_resource_key_duplicate");
+    unique(handoff.resources.map((item) => item.path), "v2_resource_path_duplicate");
+    unique(handoff.targets.map((item) => item.key), "v2_target_key_duplicate");
+    unique(handoff.coverage.map((item) => item.key), "v2_coverage_key_duplicate");
+}
+function validateManifestResource(target, manifestResource) {
+    if (manifestResource.role !== "supporting" ||
+        manifestResource.media_type !== "application/json")
+        invalid("v2_manifest_resource_invalid", `${manifestResource.key}:${manifestResource.role}:${manifestResource.media_type}`);
+    if (target.source_profile.entry_resource_ref === manifestResource.key ||
+        !target.source_profile.dependency_resource_refs.includes(manifestResource.key))
+        invalid("v2_manifest_dependency_invalid", target.key);
+}
+async function readAndVerifyResources(repository, parsed, manifestResourceRef) {
+    const contents = new Map();
+    const resourceHashes = {};
+    for (const resource of parsed.handoff.resources) {
+        if (resource.path === parsed.handoff_path)
+            invalid("v2_resource_must_not_be_handoff", resource.key);
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...resource.path.split("/")), `design_resource_v2:${resource.key}`);
+        if (resource.key === manifestResourceRef)
+            await enforceManifestByteLimit(file);
+        const bytes = await readFile(file);
+        const digest = sha256Hex(bytes);
+        if (digest !== resource.sha256)
+            invalid("v2_resource_digest_mismatch", `${resource.key}:${resource.sha256}:${digest}`);
+        contents.set(resource.key, bytes);
+        resourceHashes[resource.key] = digest;
+    }
+    return { contents, resourceHashes };
+}
+async function enforceManifestByteLimit(file) {
+    const size = (await stat(file)).size;
+    if (size > V2_MANIFEST_MAX_BYTES)
+        invalid("v2_manifest_byte_limit_exceeded", `bytes=${size}:limit=${V2_MANIFEST_MAX_BYTES}`);
+}

package/dist/lib/design-resource-symbolic-indexes.d.ts

@@ -0,0 +1,23 @@
+import type { DesignResourceObservableRuleManifestV2, DesignResourceSymbolicDispositionRegionV2, DesignResourceSymbolicFactRuleV2, ParsedDesignResourceHandoffV2 } from "./design-resource-symbolic-fact-types.js";
+import type { SymbolicExtensionalPointV1 } from "./symbolic-denotation-types.js";
+export declare function buildSymbolicManifestIndexes(manifest: DesignResourceObservableRuleManifestV2, parsed: Pick<ParsedDesignResourceHandoffV2, "source_item_keys">): {
+    sourceItems: Set<string>;
+    census: Map<string, import("./design-resource-fact-manifest-model.js").DesignResourceInspectorCensusEntryV1>;
+    subjects: Map<string, import("./design-resource-handoff-types.js").DesignResourceHandoffSubjectV1>;
+    populations: Map<string, import("./design-resource-symbolic-fact-types.js").DesignResourceSymbolicPopulationV2>;
+    properties: Map<string, import("./design-resource-fact-types.js").DesignResourcePropertyDefinitionV1>;
+    rules: Map<string, DesignResourceSymbolicFactRuleV2>;
+    dispositions: Map<string, DesignResourceSymbolicDispositionRegionV2>;
+    obligations: Map<string, import("./design-resource-symbolic-fact-types.js").DesignResourceSymbolicProofObligationV2>;
+    oracles: Map<string, import("./design-resource-fact-types.js").DesignResourceOracleV1>;
+    environments: Map<string, import("./design-resource-fact-types.js").DesignResourceEnvironmentV1>;
+    inspectorCapabilities: Set<"accessibility" | "assets" | "audio" | "component_anatomy" | "css_cascade" | "custom_properties" | "design_tokens" | "dynamic_population" | "geometry_measurement" | "haptics" | "html_dom" | "input_rules" | "javascript_static" | "json" | "localization" | "markdown" | "motion" | "prototype_transitions" | "relations" | "render_capture" | "responsive_rules" | "svg" | "system_ui">;
+    rulesBySubjectProperty: Map<string, DesignResourceSymbolicFactRuleV2[]>;
+    dispositionsBySubjectProperty: Map<string, DesignResourceSymbolicDispositionRegionV2[]>;
+    rulesBySemanticTuple: Map<string, DesignResourceSymbolicFactRuleV2[]>;
+    dispositionsBySemanticTuple: Map<string, DesignResourceSymbolicDispositionRegionV2[]>;
+    rulesByCensus: Map<string, DesignResourceSymbolicFactRuleV2[]>;
+};
+export type SymbolicManifestIndexes = ReturnType<typeof buildSymbolicManifestIndexes>;
+export declare function symbolicSubjectPropertyKey(subjectRef: string, propertyRef: string): string;
+export declare function symbolicSemanticTupleKey(row: DesignResourceSymbolicFactRuleV2 | DesignResourceSymbolicDispositionRegionV2 | SymbolicExtensionalPointV1): string;

package/dist/lib/design-resource-symbolic-indexes.js

@@ -0,0 +1,54 @@
+import { stableJson } from "./design-resource-symbolic-validation-support.js";
+export function buildSymbolicManifestIndexes(manifest, parsed) {
+    const rulesBySubjectProperty = groupRows(manifest.fact_rules, (rule) => symbolicSubjectPropertyKey(rule.subject_or_relation_ref, rule.property_ref));
+    const dispositionsBySubjectProperty = groupRows(manifest.disposition_regions, (row) => symbolicSubjectPropertyKey(row.subject_or_relation_ref, row.property_ref));
+    const rulesBySemanticTuple = groupRows(manifest.fact_rules, symbolicSemanticTupleKey);
+    const dispositionsBySemanticTuple = groupRows(manifest.disposition_regions, symbolicSemanticTupleKey);
+    const rulesByCensus = new Map();
+    for (const rule of manifest.fact_rules)
+        for (const censusRef of rule.census_refs)
+            append(rulesByCensus, censusRef, rule);
+    return {
+        sourceItems: new Set(parsed.source_item_keys),
+        census: new Map(manifest.inspector.census.map((item) => [item.key, item])),
+        subjects: new Map(manifest.subjects.map((item) => [item.key, item])),
+        populations: new Map(manifest.populations.map((item) => [item.key, item])),
+        properties: new Map(manifest.properties.map((item) => [item.key, item])),
+        rules: new Map(manifest.fact_rules.map((item) => [item.key, item])),
+        dispositions: new Map(manifest.disposition_regions.map((item) => [item.key, item])),
+        obligations: new Map(manifest.semantic_proof_obligations.map((item) => [item.key, item])),
+        oracles: new Map(manifest.oracles.map((item) => [item.key, item])),
+        environments: new Map(manifest.environments.map((item) => [item.key, item])),
+        inspectorCapabilities: new Set(manifest.inspector.capability_refs),
+        rulesBySubjectProperty,
+        dispositionsBySubjectProperty,
+        rulesBySemanticTuple,
+        dispositionsBySemanticTuple,
+        rulesByCensus,
+    };
+}
+export function symbolicSubjectPropertyKey(subjectRef, propertyRef) {
+    return `${subjectRef}\u0000${propertyRef}`;
+}
+export function symbolicSemanticTupleKey(row) {
+    return [
+        row.subject_or_relation_ref,
+        row.target_ref,
+        row.property_ref,
+        row.population_ref ?? "none",
+        stableJson(row.quantifier),
+    ].join("\u0000");
+}
+function groupRows(rows, keyOf) {
+    const groups = new Map();
+    for (const row of rows)
+        append(groups, keyOf(row), row);
+    return groups;
+}
+function append(groups, key, row) {
+    const values = groups.get(key);
+    if (values)
+        values.push(row);
+    else
+        groups.set(key, [row]);
+}

package/dist/lib/design-resource-symbolic-manifest-shape.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceObservableRuleManifestV2 } from "./design-resource-symbolic-fact-types.js";
+export declare function parseDesignResourceObservableRuleManifestJson(content: string): DesignResourceObservableRuleManifestV2;
+export declare function parseDesignResourceObservableRuleManifestShape(value: unknown): DesignResourceObservableRuleManifestV2;

package/dist/lib/design-resource-symbolic-manifest-shape.js

@@ -0,0 +1,155 @@
+import { parseDesignResourceEnvironments, parseDesignResourceOracles, } from "./design-resource-fact-manifest-shape-evidence.js";
+import { parseDesignResourceProperties } from "./design-resource-fact-manifest-shape-facts.js";
+import { parseDesignResourceFactManifestInspector, parseDesignResourceManifestDesignSystem, } from "./design-resource-fact-manifest-shape-inspector.js";
+import { parseDesignResourceHandoffBlockers } from "./design-resource-handoff-shape-evidence.js";
+import { contractKey, sha256, sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { parseDesignResourceHandoffSubjects } from "./design-resource-handoff-shape-structure.js";
+import { parseSymbolicStructuralApplicability } from "./design-resource-symbolic-applicability-shape.js";
+import { parseSymbolicNoninterferenceProof } from "./design-resource-symbolic-noninterference-shape.js";
+import { parseSymbolicAxisDomains, parseSymbolicPredicate, } from "./design-resource-symbolic-predicate-shape.js";
+import { parseSymbolicFactRules, parseSymbolicObligation, parseSymbolicPopulations, parseSymbolicQuantifier, } from "./design-resource-symbolic-rule-shape.js";
+import { array, literal, nullable, object, string, } from "./long-task-shape-primitives.js";
+export function parseDesignResourceObservableRuleManifestJson(content) {
+    let value;
+    try {
+        value = JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`design_resource_symbolic_manifest_invalid:json:${message}`);
+    }
+    return parseDesignResourceObservableRuleManifestShape(value);
+}
+export function parseDesignResourceObservableRuleManifestShape(value) {
+    const label = "design_resource_symbolic_manifest";
+    const root = object(value, label, [
+        "schema_version",
+        "scope_key",
+        "target_key",
+        "inspector",
+        "design_system",
+        "axis_domains",
+        "reachable_region",
+        "subjects",
+        "populations",
+        "properties",
+        "fact_rules",
+        "disposition_regions",
+        "semantic_proof_obligations",
+        "dependency_edges",
+        "noninterference_certificates",
+        "oracles",
+        "environments",
+        "acceptance_blockers",
+    ], ["structural_applicability"]);
+    return {
+        schema_version: literal(root.schema_version, ["design-resource-observable-rule-manifest-v2"], `${label}.schema_version`),
+        scope_key: contractKey(root.scope_key, `${label}.scope_key`),
+        target_key: contractKey(root.target_key, `${label}.target_key`),
+        inspector: parseDesignResourceFactManifestInspector(root.inspector, `${label}.inspector`),
+        design_system: parseDesignResourceManifestDesignSystem(root.design_system, `${label}.design_system`),
+        axis_domains: parseSymbolicAxisDomains(root.axis_domains, `${label}.axis_domains`),
+        reachable_region: parseSymbolicPredicate(root.reachable_region, `${label}.reachable_region`),
+        subjects: parseDesignResourceHandoffSubjects(root.subjects),
+        populations: parseSymbolicPopulations(root.populations, `${label}.populations`),
+        properties: parseDesignResourceProperties(root.properties, `${label}.properties`),
+        fact_rules: parseSymbolicFactRules(root.fact_rules, `${label}.fact_rules`),
+        disposition_regions: parseDispositionRegions(root.disposition_regions, label),
+        semantic_proof_obligations: array(root.semantic_proof_obligations, `${label}.semantic_proof_obligations`).map((item, index) => parseSymbolicObligation(item, `${label}.semantic_proof_obligations[${index}]`)),
+        dependency_edges: parseDependencyEdges(root.dependency_edges, label),
+        noninterference_certificates: parseNoninterferenceCertificates(root.noninterference_certificates, label),
+        oracles: parseDesignResourceOracles(root.oracles, `${label}.oracles`),
+        environments: parseDesignResourceEnvironments(root.environments, `${label}.environments`),
+        acceptance_blockers: parseDesignResourceHandoffBlockers(root.acceptance_blockers),
+        ...(root.structural_applicability === undefined
+            ? {}
+            : {
+                structural_applicability: parseSymbolicStructuralApplicability(root.structural_applicability, `${label}.structural_applicability`),
+            }),
+    };
+}
+function parseDispositionRegions(value, label) {
+    return array(value, `${label}.disposition_regions`).map((item, index) => {
+        const itemLabel = `${label}.disposition_regions[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "subject_or_relation_ref",
+            "target_ref",
+            "property_ref",
+            "population_ref",
+            "quantifier",
+            "region",
+            "disposition",
+            "census_refs",
+            "source_item_refs",
+            "basis_refs",
+            "rationale",
+        ]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            subject_or_relation_ref: stableKey(row.subject_or_relation_ref, `${itemLabel}.subject_or_relation_ref`),
+            target_ref: contractKey(row.target_ref, `${itemLabel}.target_ref`),
+            property_ref: stableKey(row.property_ref, `${itemLabel}.property_ref`),
+            population_ref: nullable(row.population_ref, (entry) => stableKey(entry, `${itemLabel}.population_ref`)),
+            quantifier: parseSymbolicQuantifier(row.quantifier, `${itemLabel}.quantifier`),
+            region: parseSymbolicPredicate(row.region, `${itemLabel}.region`),
+            disposition: literal(row.disposition, [
+                "not_applicable",
+                "excluded",
+                "decision_required",
+                "unavailable",
+                "blocking",
+            ], `${itemLabel}.disposition`),
+            census_refs: stableKeys(row.census_refs, `${itemLabel}.census_refs`),
+            source_item_refs: sourceItemKeys(row.source_item_refs, `${itemLabel}.source_item_refs`),
+            basis_refs: stableKeys(row.basis_refs, `${itemLabel}.basis_refs`),
+            rationale: string(row.rationale, `${itemLabel}.rationale`),
+        };
+    });
+}
+function parseDependencyEdges(value, label) {
+    return array(value, `${label}.dependency_edges`).map((item, index) => {
+        const itemLabel = `${label}.dependency_edges[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "axis_ref",
+            "fact_rule_ref",
+            "effects",
+        ]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            axis_ref: stableKey(row.axis_ref, `${itemLabel}.axis_ref`),
+            fact_rule_ref: stableKey(row.fact_rule_ref, `${itemLabel}.fact_rule_ref`),
+            effects: array(row.effects, `${itemLabel}.effects`).map((effect, effectIndex) => literal(effect, ["disposition", "expected_semantics", "proof_denotation"], `${itemLabel}.effects[${effectIndex}]`)),
+        };
+    });
+}
+function parseNoninterferenceCertificates(value, label) {
+    return array(value, `${label}.noninterference_certificates`).map((item, index) => {
+        const itemLabel = `${label}.noninterference_certificates[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "fact_rule_refs",
+            "omitted_axis_refs",
+            "dependency_edge_refs",
+            "canonical_rule_dag_sha256",
+        ], ["source_noninterference_proof", "production_noninterference_proof"]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            fact_rule_refs: stableKeys(row.fact_rule_refs, `${itemLabel}.fact_rule_refs`),
+            omitted_axis_refs: stableKeys(row.omitted_axis_refs, `${itemLabel}.omitted_axis_refs`),
+            dependency_edge_refs: stableKeys(row.dependency_edge_refs, `${itemLabel}.dependency_edge_refs`),
+            canonical_rule_dag_sha256: sha256(row.canonical_rule_dag_sha256, `${itemLabel}.canonical_rule_dag_sha256`),
+            ...(row.source_noninterference_proof === undefined
+                ? {}
+                : {
+                    source_noninterference_proof: nullable(row.source_noninterference_proof, (entry) => parseSymbolicNoninterferenceProof(entry, `${itemLabel}.source_noninterference_proof`)),
+                }),
+            ...(row.production_noninterference_proof === undefined
+                ? {}
+                : {
+                    production_noninterference_proof: nullable(row.production_noninterference_proof, (entry) => parseSymbolicNoninterferenceProof(entry, `${itemLabel}.production_noninterference_proof`)),
+                }),
+        };
+    });
+}

package/dist/lib/design-resource-symbolic-manifest-validation.d.ts

@@ -0,0 +1,6 @@
+import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
+import type { DesignResourceHandoffPreflightV2, DesignResourceObservableRuleManifestV2, ParsedDesignResourceHandoffV2 } from "./design-resource-symbolic-fact-types.js";
+export declare function validateDesignResourceSymbolicManifest(manifest: DesignResourceObservableRuleManifestV2, parsed: ParsedDesignResourceHandoffV2, resources: Map<string, DesignResource>, contents: Map<string, Buffer>): {
+    ruleProjections: DesignResourceHandoffPreflightV2["rule_projections"];
+    metrics: DesignResourceHandoffPreflightV2["metrics"];
+};