project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,218 +0,0 @@
-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";
-import type { DesignResourceImplementationFeasibilityIdentityV1, DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalFeasibilityInputV1 } from "./design-resource-implementation-feasibility-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;
-    };
-    technical_feasibility_inputs: DesignResourceTechnicalFeasibilityInputV1[];
-    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>;
-    technical_feasibility_documents: DesignResourceImplementationFeasibilityV1[];
-    technical_feasibility_identities: DesignResourceImplementationFeasibilityIdentityV1[];
-    limitations: 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-validation.d.ts

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

@@ -1,99 +0,0 @@
-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";
-import { createV2ImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
-import { readAndValidateDesignResourceImplementationFeasibility } from "./design-resource-implementation-feasibility-validation.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);
-    const feasibility = await readAndValidateDesignResourceImplementationFeasibility(repository, parsed.handoff_path, handoff.technical_feasibility_inputs, new Map([
-        [
-            target.key,
-            createV2ImplementationFeasibilityTargetModel(target, manifest),
-        ],
-    ]), new Set(handoff.resources.map((resource) => resource.path)));
-    return {
-        ...parsed,
-        preflight_schema_version: "design-resource-handoff-preflight-v2",
-        status: "ready",
-        manifest,
-        resource_hashes: resourceHashes,
-        technical_feasibility_documents: feasibility.map((item) => item.document),
-        technical_feasibility_identities: feasibility.map((item) => item.identity),
-        limitations: target.source_profile.kind !== "reference" && !feasibility.length
-            ? ["technical feasibility not declared"]
-            : [],
-        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

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

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

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

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

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