project-tiny-context-harness 0.8.10 → 0.8.12

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

@@ -0,0 +1,138 @@
+import { parseDesignResourceHandoffResources } from "./design-resource-handoff-shape-structure.js";
+import { contractKey, sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { array, literal, object, repositoryFile, string, strings, } from "./long-task-shape-primitives.js";
+export { parseDesignResourceObservableRuleManifestJson, parseDesignResourceObservableRuleManifestShape, } from "./design-resource-symbolic-manifest-shape.js";
+export function parseDesignResourceSymbolicHandoffShape(value) {
+    const label = "design_resource_handoff_v2";
+    const root = object(value, label, [
+        "schema_version",
+        "representation",
+        "intent",
+        "scope",
+        "provenance",
+        "resources",
+        "targets",
+        "coverage",
+        "proposal",
+    ]);
+    return {
+        schema_version: literal(root.schema_version, ["design-resource-handoff-v2"], `${label}.schema_version`),
+        representation: literal(root.representation, ["symbolic_rules_v2"], `${label}.representation`),
+        intent: literal(root.intent, ["implementation_handoff"], `${label}.intent`),
+        scope: parseScope(root.scope, label),
+        provenance: parseProvenance(root.provenance, label),
+        resources: parseDesignResourceHandoffResources(root.resources),
+        targets: parseTargets(root.targets, label),
+        coverage: parseCoverage(root.coverage, label),
+        proposal: parseProposal(root.proposal, label),
+    };
+}
+function parseScope(value, label) {
+    const row = object(value, `${label}.scope`, [
+        "key",
+        "style_dependency",
+        "surface_keys",
+        "necessary_context",
+        "exclusions",
+    ]);
+    return {
+        key: contractKey(row.key, `${label}.scope.key`),
+        style_dependency: literal(row.style_dependency, ["style-bearing", "non-fidelity", "mixed"], `${label}.scope.style_dependency`),
+        surface_keys: stableKeys(row.surface_keys, `${label}.scope.surface_keys`),
+        necessary_context: strings(row.necessary_context, `${label}.scope.necessary_context`),
+        exclusions: strings(row.exclusions, `${label}.scope.exclusions`),
+    };
+}
+function parseProvenance(value, label) {
+    const row = object(value, `${label}.provenance`, [
+        "provider",
+        "provider_version",
+        "project",
+        "run",
+        "capability",
+        "agent",
+        "model",
+        "design_system_id",
+    ]);
+    return {
+        provider: string(row.provider, `${label}.provenance.provider`),
+        provider_version: string(row.provider_version, `${label}.provenance.provider_version`),
+        project: string(row.project, `${label}.provenance.project`),
+        run: string(row.run, `${label}.provenance.run`),
+        capability: string(row.capability, `${label}.provenance.capability`),
+        agent: string(row.agent, `${label}.provenance.agent`),
+        model: string(row.model, `${label}.provenance.model`),
+        design_system_id: string(row.design_system_id, `${label}.provenance.design_system_id`),
+    };
+}
+function parseTargets(value, label) {
+    return array(value, `${label}.targets`).map((item, index) => {
+        const itemLabel = `${label}.targets[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "interpretation",
+            "resource_refs",
+            "source_profile",
+            "selection_basis",
+        ]);
+        const profile = object(row.source_profile, `${itemLabel}.source_profile`, [
+            "kind",
+            "entry_resource_ref",
+            "dependency_resource_refs",
+            "fact_manifest_resource_ref",
+            "acquisition",
+        ]);
+        return {
+            key: contractKey(row.key, `${itemLabel}.key`),
+            interpretation: literal(row.interpretation, ["exact_target", "constraint"], `${itemLabel}.interpretation`),
+            resource_refs: stableKeys(row.resource_refs, `${itemLabel}.resource_refs`),
+            source_profile: {
+                kind: literal(profile.kind, ["implementation_web", "implementation_app", "reference"], `${itemLabel}.source_profile.kind`),
+                entry_resource_ref: stableKey(profile.entry_resource_ref, `${itemLabel}.source_profile.entry_resource_ref`),
+                dependency_resource_refs: stableKeys(profile.dependency_resource_refs, `${itemLabel}.source_profile.dependency_resource_refs`),
+                fact_manifest_resource_ref: stableKey(profile.fact_manifest_resource_ref, `${itemLabel}.source_profile.fact_manifest_resource_ref`),
+                acquisition: literal(profile.acquisition, ["complete"], `${itemLabel}.source_profile.acquisition`),
+            },
+            selection_basis: string(row.selection_basis, `${itemLabel}.selection_basis`),
+        };
+    });
+}
+function parseCoverage(value, label) {
+    return array(value, `${label}.coverage`).map((item, index) => {
+        const itemLabel = `${label}.coverage[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "target_ref",
+            "subject_or_relation_refs",
+            "property_refs",
+            "fact_rule_refs",
+            "semantic_obligation_refs",
+            "certificate_refs",
+            "source_item_refs",
+            "rationale",
+        ]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            target_ref: contractKey(row.target_ref, `${itemLabel}.target_ref`),
+            subject_or_relation_refs: stableKeys(row.subject_or_relation_refs, `${itemLabel}.subject_or_relation_refs`),
+            property_refs: stableKeys(row.property_refs, `${itemLabel}.property_refs`),
+            fact_rule_refs: stableKeys(row.fact_rule_refs, `${itemLabel}.fact_rule_refs`),
+            semantic_obligation_refs: stableKeys(row.semantic_obligation_refs, `${itemLabel}.semantic_obligation_refs`),
+            certificate_refs: stableKeys(row.certificate_refs, `${itemLabel}.certificate_refs`),
+            source_item_refs: sourceItemKeys(row.source_item_refs, `${itemLabel}.source_item_refs`),
+            rationale: string(row.rationale, `${itemLabel}.rationale`),
+        };
+    });
+}
+function parseProposal(value, label) {
+    const row = object(value, `${label}.proposal`, [
+        "reconciliation_status",
+        "path",
+        "revision",
+    ]);
+    return {
+        reconciliation_status: literal(row.reconciliation_status, ["applied", "returned", "not_applicable"], `${label}.proposal.reconciliation_status`),
+        path: repositoryFile(row.path, `${label}.proposal.path`),
+        revision: string(row.revision, `${label}.proposal.revision`),
+    };
+}

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;