project-tiny-context-harness 0.8.11 → 0.8.13

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

@@ -0,0 +1,76 @@
+import { sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { array, literal, object, string, } from "./long-task-shape-primitives.js";
+export function parseSymbolicStructuralApplicability(value, label) {
+    const root = object(value, label, [
+        "profile_catalog",
+        "subject_profile_bindings",
+        "inspector_custom_property_closure",
+        "instance_exceptions",
+    ]);
+    return {
+        profile_catalog: literal(root.profile_catalog, ["package-subject-property-applicability-v1"], `${label}.profile_catalog`),
+        subject_profile_bindings: array(root.subject_profile_bindings, `${label}.subject_profile_bindings`).map((item, index) => parseProfileBinding(item, `${label}.subject_profile_bindings[${index}]`)),
+        inspector_custom_property_closure: array(root.inspector_custom_property_closure, `${label}.inspector_custom_property_closure`).map((item, index) => parseCustomPropertyClosure(item, `${label}.inspector_custom_property_closure[${index}]`)),
+        instance_exceptions: array(root.instance_exceptions, `${label}.instance_exceptions`).map((item, index) => parseInstanceException(item, `${label}.instance_exceptions[${index}]`)),
+    };
+}
+function parseProfileBinding(value, label) {
+    const row = object(value, label, [
+        "key",
+        "subject_refs",
+        "profile_refs",
+        "census_refs",
+        "source_item_refs",
+        "basis_refs",
+        "rationale",
+    ]);
+    return {
+        key: stableKey(row.key, `${label}.key`),
+        subject_refs: stableKeys(row.subject_refs, `${label}.subject_refs`),
+        profile_refs: stableKeys(row.profile_refs, `${label}.profile_refs`),
+        census_refs: stableKeys(row.census_refs, `${label}.census_refs`),
+        source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
+        basis_refs: stableKeys(row.basis_refs, `${label}.basis_refs`),
+        rationale: string(row.rationale, `${label}.rationale`),
+    };
+}
+function parseCustomPropertyClosure(value, label) {
+    const row = object(value, label, [
+        "property_ref",
+        "applicable_subject_refs",
+        "census_refs",
+        "source_item_refs",
+        "basis_refs",
+        "rationale",
+    ]);
+    return {
+        property_ref: stableKey(row.property_ref, `${label}.property_ref`),
+        applicable_subject_refs: stableKeys(row.applicable_subject_refs, `${label}.applicable_subject_refs`),
+        census_refs: stableKeys(row.census_refs, `${label}.census_refs`),
+        source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
+        basis_refs: stableKeys(row.basis_refs, `${label}.basis_refs`),
+        rationale: string(row.rationale, `${label}.rationale`),
+    };
+}
+function parseInstanceException(value, label) {
+    const row = object(value, label, [
+        "key",
+        "subject_ref",
+        "property_ref",
+        "disposition",
+        "census_refs",
+        "source_item_refs",
+        "basis_refs",
+        "rationale",
+    ]);
+    return {
+        key: stableKey(row.key, `${label}.key`),
+        subject_ref: stableKey(row.subject_ref, `${label}.subject_ref`),
+        property_ref: stableKey(row.property_ref, `${label}.property_ref`),
+        disposition: literal(row.disposition, ["applicable", "not_applicable"], `${label}.disposition`),
+        census_refs: stableKeys(row.census_refs, `${label}.census_refs`),
+        source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
+        basis_refs: stableKeys(row.basis_refs, `${label}.basis_refs`),
+        rationale: string(row.rationale, `${label}.rationale`),
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { DesignResourceObservableRuleManifestV2 } from "./design-resource-symbolic-fact-types.js";
+import type { SymbolicManifestIndexes } from "./design-resource-symbolic-indexes.js";
+export interface SymbolicApplicabilityIndex {
+    mode: "legacy_physical_partitions" | "package_profiles";
+    isApplicable(subjectRef: string, propertyRef: string): boolean;
+}
+export declare function buildSymbolicApplicabilityIndex(manifest: DesignResourceObservableRuleManifestV2, indexes: SymbolicManifestIndexes): SymbolicApplicabilityIndex;

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

@@ -0,0 +1,128 @@
+import { DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILE_CATALOG, resolveSymbolicApplicabilityProfiles, } from "./design-resource-symbolic-applicability-profiles.js";
+import { deriveRequiredSymbolicStandardApplicability } from "./design-resource-symbolic-applicability-policy.js";
+import { validateSymbolicApplicabilityAuthorityRefs as validateAuthorityRefs } from "./design-resource-symbolic-applicability-authority.js";
+import { assertSameSet, invalid, requireKnownRefs, unique, } from "./design-resource-symbolic-validation-support.js";
+export function buildSymbolicApplicabilityIndex(manifest, indexes) {
+    const compact = manifest.structural_applicability;
+    if (!compact)
+        return {
+            mode: "legacy_physical_partitions",
+            isApplicable: () => true,
+        };
+    if (compact.profile_catalog !==
+        DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILE_CATALOG)
+        invalid("v2_applicability_profile_catalog_unknown", compact.profile_catalog);
+    const artifactRefs = new Set(manifest.noninterference_certificates.flatMap((certificate) => [
+        certificate.source_noninterference_proof,
+        certificate.production_noninterference_proof,
+    ]
+        .filter((proof) => proof != null)
+        .map((proof) => proof.artifact_resource_ref)));
+    const { effective, expected } = validateProfileBindings(manifest, indexes, artifactRefs);
+    validateCustomPropertyClosure(manifest, indexes, effective, expected, artifactRefs);
+    validateInstanceExceptions(manifest, indexes, effective, expected, artifactRefs);
+    for (const subjectRef of indexes.subjects.keys())
+        assertSameSet([...(effective.get(subjectRef) ?? [])], [...(expected.get(subjectRef) ?? [])], "v2_applicability_package_derived_set_mismatch", subjectRef);
+    return {
+        mode: "package_profiles",
+        isApplicable(subjectRef, propertyRef) {
+            const properties = effective.get(subjectRef);
+            if (!properties)
+                invalid("v2_applicability_subject_unknown", subjectRef);
+            if (!indexes.properties.has(propertyRef))
+                invalid("v2_applicability_property_unknown", propertyRef);
+            return properties.has(propertyRef);
+        },
+    };
+}
+function validateProfileBindings(manifest, indexes, artifactRefs) {
+    const bindings = manifest.structural_applicability.subject_profile_bindings;
+    unique(bindings.map((binding) => binding.key), "v2_applicability_profile_binding_key_duplicate");
+    const boundSubjects = bindings.flatMap((binding) => binding.subject_refs);
+    unique(boundSubjects, "v2_applicability_subject_profile_ambiguous");
+    assertSameSet(boundSubjects, [...indexes.subjects.keys()], "v2_applicability_subject_profile_set_mismatch", manifest.target_key);
+    const effective = new Map();
+    const expected = new Map();
+    for (const binding of bindings) {
+        if (!binding.subject_refs.length || !binding.profile_refs.length)
+            invalid("v2_applicability_profile_binding_empty", binding.key);
+        validateAuthorityRefs(binding, indexes, artifactRefs, binding.key);
+        unique(binding.profile_refs, `v2_applicability_profile_ref_duplicate:${binding.key}`);
+        const properties = resolveSymbolicApplicabilityProfiles(binding.profile_refs, binding.key);
+        const subjectCensusRefs = binding.subject_refs.flatMap((subjectRef) => {
+            const subject = indexes.subjects.get(subjectRef);
+            if (!subject)
+                invalid("v2_applicability_profile_subject_unknown", subjectRef);
+            return subject.census_refs;
+        });
+        assertSameSet(binding.census_refs, subjectCensusRefs, "v2_applicability_subject_census_set_mismatch", binding.key);
+        for (const subjectRef of binding.subject_refs) {
+            const subject = indexes.subjects.get(subjectRef);
+            if (!subject)
+                invalid("v2_applicability_profile_subject_unknown", subjectRef);
+            const derived = deriveRequiredSymbolicStandardApplicability(subject, indexes.census);
+            for (const basisRef of derived.policy_basis_refs)
+                if (!binding.basis_refs.includes(basisRef))
+                    invalid("v2_applicability_package_policy_basis_missing", `${binding.key}:${subjectRef}:${basisRef}`);
+            effective.set(subjectRef, new Set(properties));
+            expected.set(subjectRef, new Set(derived.property_refs));
+        }
+    }
+    return { effective, expected };
+}
+function validateCustomPropertyClosure(manifest, indexes, effective, expected, artifactRefs) {
+    const rows = manifest.structural_applicability.inspector_custom_property_closure;
+    unique(rows.map((row) => row.property_ref), "v2_custom_property_closure_duplicate");
+    const customProperties = manifest.properties.filter((property) => !property.standard);
+    assertSameSet(rows.map((row) => row.property_ref), customProperties.map((property) => property.key), "v2_custom_property_closure_set_mismatch", manifest.target_key);
+    for (const row of rows) {
+        const property = indexes.properties.get(row.property_ref);
+        if (!property || property.standard)
+            invalid("v2_custom_property_closure_property_unknown", row.property_ref);
+        validateAuthorityRefs(row, indexes, artifactRefs, row.property_ref);
+        requireKnownRefs(row.applicable_subject_refs, indexes.subjects, "v2_custom_property_subject_unknown");
+        unique(row.applicable_subject_refs, `v2_custom_property_subject_duplicate:${row.property_ref}`);
+        assertSameSet(row.census_refs, property.census_refs, "v2_custom_property_census_set_mismatch", row.property_ref);
+        for (const censusRef of row.census_refs) {
+            const census = indexes.census.get(censusRef);
+            if (census?.kind !== "custom_property" ||
+                census.disposition !== "covered")
+                invalid("v2_custom_property_census_authority_invalid", `${row.property_ref}:${censusRef}`);
+        }
+        for (const subjectRef of row.applicable_subject_refs)
+            for (const index of [effective, expected])
+                index.get(subjectRef).add(row.property_ref);
+    }
+    assertSameSet(rows.flatMap((row) => row.census_refs), manifest.inspector.census
+        .filter((row) => row.kind === "custom_property")
+        .map((row) => row.key), "v2_custom_property_census_closure_mismatch", manifest.target_key);
+}
+function validateInstanceExceptions(manifest, indexes, effective, expected, artifactRefs) {
+    const exceptions = manifest.structural_applicability.instance_exceptions;
+    unique(exceptions.map((item) => item.key), "v2_applicability_exception_key_duplicate");
+    const tupleKeys = exceptions.map((item) => `${item.subject_ref}\u0000${item.property_ref}`);
+    unique(tupleKeys, "v2_applicability_exception_tuple_duplicate");
+    for (const exception of exceptions) {
+        const subject = indexes.subjects.get(exception.subject_ref);
+        if (!subject)
+            invalid("v2_applicability_exception_subject_unknown", exception.key);
+        const property = indexes.properties.get(exception.property_ref);
+        if (!property)
+            invalid("v2_applicability_exception_property_unknown", exception.key);
+        validateAuthorityRefs(exception, indexes, artifactRefs, exception.key);
+        assertSameSet(exception.census_refs, [...subject.census_refs, ...property.census_refs], "v2_applicability_exception_census_set_mismatch", exception.key);
+        const properties = effective.get(exception.subject_ref);
+        const requestedApplicability = exception.disposition === "applicable";
+        if (properties.has(exception.property_ref) === requestedApplicability)
+            invalid("v2_applicability_exception_noop", exception.key);
+        if (exception.disposition === "applicable")
+            properties.add(exception.property_ref);
+        else
+            properties.delete(exception.property_ref);
+        const expectedProperties = expected.get(exception.subject_ref);
+        if (exception.disposition === "applicable")
+            expectedProperties.add(exception.property_ref);
+        else
+            expectedProperties.delete(exception.property_ref);
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { DesignResourceObservableRuleManifestV2 } from "./design-resource-symbolic-fact-types.js";
+export declare function createDesignResourceSymbolicCompilationSession(manifest: DesignResourceObservableRuleManifestV2): import("./symbolic-denotation-engine.js").SymbolicDenotationCompilationSession;
+export type DesignResourceSymbolicCompilationSession = ReturnType<typeof createDesignResourceSymbolicCompilationSession>;

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

@@ -0,0 +1,13 @@
+import { createSymbolicDenotationCompilationSession } from "./symbolic-denotation-engine.js";
+export function createDesignResourceSymbolicCompilationSession(manifest) {
+    return createSymbolicDenotationCompilationSession(manifest.axis_domains, [
+        manifest.reachable_region,
+        ...manifest.fact_rules.map((rule) => rule.region),
+        ...manifest.disposition_regions.map((row) => row.region),
+        ...manifest.populations.flatMap((population) => population.exclusions.map((exclusion) => exclusion.region)),
+        ...manifest.noninterference_certificates.flatMap((certificate) => [certificate.production_noninterference_proof].flatMap((proof) => proof?.equivalence_cases.flatMap((item) => [
+            item.side_predicate,
+            item.axis_erased_predicate,
+        ]) ?? [])),
+    ]);
+}

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

@@ -0,0 +1,3 @@
+import type { DesignResourceHandoffPreflightV2 } from "./design-resource-symbolic-fact-types.js";
+import type { SymbolicExtensionalPointV1, SymbolicPointDenotationV1 } from "./symbolic-denotation-types.js";
+export declare function denoteDesignResourceSymbolicPoint(preflight: DesignResourceHandoffPreflightV2, point: SymbolicExtensionalPointV1): SymbolicPointDenotationV1;

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

@@ -0,0 +1,167 @@
+import { buildSymbolicApplicabilityIndex } from "./design-resource-symbolic-applicability-validation.js";
+import { createDesignResourceSymbolicCompilationSession } from "./design-resource-symbolic-compilation.js";
+import { buildSymbolicManifestIndexes, symbolicSemanticTupleKey, } from "./design-resource-symbolic-indexes.js";
+import { evaluateCanonicalSymbolicDenotation } from "./symbolic-denotation-engine.js";
+const queryIndexCache = new WeakMap();
+export function denoteDesignResourceSymbolicPoint(preflight, point) {
+    const manifest = preflight.manifest;
+    const assignment = {
+        ...point.condition_assignment,
+        ...point.variation_assignment,
+    };
+    validateCompleteAssignment(manifest.axis_domains, assignment);
+    const query = queryIndex(preflight);
+    validatePointTupleAuthority(preflight, query.indexes, point);
+    const reachable = query.reachable;
+    if (!evaluateCanonicalSymbolicDenotation(reachable.canonical_dag, assignment))
+        invalid("extensional_point_unreachable", pointIdentity(point));
+    if (!query.applicability.isApplicable(point.subject_or_relation_ref, point.property_ref))
+        return {
+            disposition: "not_applicable",
+            expected_semantics: null,
+            proof_obligations: [],
+        };
+    const tupleKey = symbolicSemanticTupleKey(point);
+    const rules = (query.rulesByTuple.get(tupleKey) ?? []).filter((projection) => evaluateCanonicalSymbolicDenotation(projection.compiled_region.canonical_dag, assignment));
+    const dispositions = (query.dispositionsByTuple.get(tupleKey) ?? []).filter((projection) => evaluateCanonicalSymbolicDenotation(projection.compiled.canonical_dag, assignment));
+    if (rules.length + dispositions.length !== 1)
+        invalid("extensional_point_effective_region_invalid", `${pointIdentity(point)}:rules=${rules.length}:dispositions=${dispositions.length}`);
+    if (dispositions.length)
+        return {
+            disposition: dispositions[0].row.disposition,
+            expected_semantics: null,
+            proof_obligations: [],
+        };
+    const rule = rules[0].rule;
+    const obligations = rule.semantic_obligation_refs
+        .map((ref) => query.indexes.obligations.get(ref))
+        .map((obligation) => {
+        if (!obligation)
+            invalid("semantic_obligation_unknown", rule.key);
+        const oracle = query.indexes.oracles.get(obligation.oracle_ref);
+        const environment = query.indexes.environments.get(obligation.environment_ref);
+        if (!oracle || !environment)
+            invalid("semantic_obligation_authority_unknown", obligation.key);
+        return {
+            method: obligation.method,
+            proof_surface: obligation.proof_surface,
+            observation_boundary: obligation.observation_boundary,
+            comparison: structuredClone(obligation.comparison),
+            oracle: structuredClone(oracle),
+            environment: structuredClone(environment),
+            protected_value_policy: obligation.protected_value_policy,
+            completion_effect: obligation.completion_effect,
+        };
+    })
+        .sort((left, right) => compareText(left.method, right.method));
+    return {
+        disposition: "specified",
+        expected_semantics: {
+            value_type: rule.value_kind,
+            expected: structuredClone(rule.expected),
+            provenance_ref: rule.provenance_ref,
+            sensitivity: rule.observation_sensitivity,
+            population_ref: rule.population_ref,
+            quantifier: structuredClone(rule.quantifier),
+            lineage: structuredClone(rule.lineage),
+        },
+        proof_obligations: obligations,
+    };
+}
+function validatePointTupleAuthority(preflight, indexes, point) {
+    const manifest = preflight.manifest;
+    const subject = indexes.subjects.get(point.subject_or_relation_ref);
+    if (!subject || point.target_ref !== manifest.target_key)
+        invalid("extensional_point_subject_target_unknown", pointIdentity(point));
+    if (!indexes.properties.has(point.property_ref))
+        invalid("extensional_point_property_unknown", point.property_ref);
+    const expectedQuantifier = subject.population_ref
+        ? indexes.populations.get(subject.population_ref)?.quantifier
+        : { kind: "one", minimum: 1, maximum: 1 };
+    if (point.population_ref !== subject.population_ref ||
+        canonicalJson(point.quantifier) !== canonicalJson(expectedQuantifier))
+        invalid("extensional_point_population_quantifier_mismatch", pointIdentity(point));
+}
+function queryIndex(preflight) {
+    const cached = queryIndexCache.get(preflight);
+    if (cached)
+        return cached;
+    const built = buildQueryIndex(preflight);
+    queryIndexCache.set(preflight, built);
+    return built;
+}
+function buildQueryIndex(preflight) {
+    const indexes = buildSymbolicManifestIndexes(preflight.manifest, preflight);
+    const applicability = buildSymbolicApplicabilityIndex(preflight.manifest, indexes);
+    const compilation = createDesignResourceSymbolicCompilationSession(preflight.manifest);
+    const rulesByTuple = new Map();
+    for (const projection of preflight.rule_projections) {
+        const key = symbolicSemanticTupleKey(projection.rule);
+        const values = rulesByTuple.get(key);
+        if (values)
+            values.push(projection);
+        else
+            rulesByTuple.set(key, [projection]);
+    }
+    const dispositionsByTuple = new Map();
+    for (const row of preflight.manifest.disposition_regions) {
+        const key = symbolicSemanticTupleKey(row);
+        const projection = { row, compiled: compilation.compile(row.region) };
+        const values = dispositionsByTuple.get(key);
+        if (values)
+            values.push(projection);
+        else
+            dispositionsByTuple.set(key, [projection]);
+    }
+    return {
+        indexes,
+        applicability,
+        rulesByTuple,
+        dispositionsByTuple,
+        reachable: compilation.compile(preflight.manifest.reachable_region),
+    };
+}
+function validateCompleteAssignment(domains, assignment) {
+    const actual = Object.keys(assignment).sort(compareText);
+    const expected = domains.map((domain) => domain.key).sort(compareText);
+    if (actual.length !== expected.length ||
+        actual.some((key, index) => key !== expected[index]))
+        invalid("extensional_assignment_axis_set_mismatch", `${actual.join(",")}:${expected.join(",")}`);
+    for (const domain of domains) {
+        const value = assignment[domain.key];
+        if (domain.kind === "enum"
+            ? typeof value !== "string" || !domain.values.includes(value)
+            : typeof value !== "number" ||
+                !Number.isSafeInteger(value) ||
+                value < domain.minimum ||
+                value > domain.maximum)
+            invalid("extensional_assignment_value_outside_domain", `${domain.key}:${String(value)}`);
+    }
+}
+function pointIdentity(point) {
+    return [
+        point.subject_or_relation_ref,
+        point.target_ref,
+        point.property_ref,
+        point.population_ref ?? "none",
+        canonicalJson(point.quantifier),
+        canonicalJson(point.condition_assignment),
+        canonicalJson(point.variation_assignment),
+    ].join(":");
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => compareText(left, right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function invalid(code, detail) {
+    throw new Error(`design_resource_symbolic_denotation_invalid:${code}:${detail}`);
+}

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

@@ -0,0 +1,4 @@
+import type { DesignResourceObservableRuleManifestV2 } from "./design-resource-symbolic-fact-types.js";
+import type { DesignResourceSymbolicCompilationSession } from "./design-resource-symbolic-compilation.js";
+import type { SymbolicManifestIndexes } from "./design-resource-symbolic-indexes.js";
+export declare function validateSymbolicDispositions(manifest: DesignResourceObservableRuleManifestV2, targetKey: string, indexes: SymbolicManifestIndexes, compilation: DesignResourceSymbolicCompilationSession): void;

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

@@ -0,0 +1,28 @@
+import { assertNoUnprovedOmittedAxes } from "./design-resource-symbolic-safety-validation.js";
+import { validateSymbolicPopulationAndQuantifier, validateSymbolicRegionWithinReachable, } from "./design-resource-symbolic-region-validation.js";
+import { invalid, requireKnownRefs, unique, } from "./design-resource-symbolic-validation-support.js";
+export function validateSymbolicDispositions(manifest, targetKey, indexes, compilation) {
+    for (const disposition of manifest.disposition_regions) {
+        const subject = indexes.subjects.get(disposition.subject_or_relation_ref);
+        if (!subject)
+            invalid("v2_disposition_subject_unknown", disposition.key);
+        if (!indexes.properties.has(disposition.property_ref))
+            invalid("v2_disposition_property_unknown", disposition.key);
+        if (disposition.target_ref !== targetKey)
+            invalid("v2_disposition_target_mismatch", disposition.key);
+        validateSymbolicPopulationAndQuantifier(disposition, subject.population_ref, indexes.populations);
+        if (!disposition.basis_refs.length || !disposition.source_item_refs.length)
+            invalid("v2_disposition_basis_source_required", disposition.key);
+        unique(disposition.census_refs, `v2_disposition_census_duplicate:${disposition.key}`);
+        unique(disposition.source_item_refs, `v2_disposition_source_item_duplicate:${disposition.key}`);
+        unique(disposition.basis_refs, `v2_disposition_basis_duplicate:${disposition.key}`);
+        requireKnownRefs(disposition.census_refs, indexes.census, "v2_disposition_census_unknown");
+        requireKnownRefs(disposition.source_item_refs, indexes.sourceItems, "v2_disposition_source_item_unknown");
+        validateSymbolicRegionWithinReachable(disposition.region, manifest.reachable_region, disposition.key, compilation);
+        assertNoUnprovedOmittedAxes(compilation.compile(disposition.region), disposition.key);
+        if (disposition.disposition === "decision_required" ||
+            disposition.disposition === "unavailable" ||
+            disposition.disposition === "blocking")
+            invalid("v2_unresolved_disposition", `${disposition.key}:${disposition.disposition}`);
+    }
+}

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

@@ -0,0 +1,12 @@
+export declare const DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY: {
+    readonly symbolic_denotation_efficiency_delivery: true;
+    readonly control_relations_unchanged: true;
+    readonly forbidden_symbolic_shortcuts_absent: true;
+    readonly symbolic_inventory_is_not_completion: true;
+    readonly v1_capacity: {
+        readonly embedded_handoff_max_bytes: 8388608;
+        readonly canonical_manifest_max_bytes: 33554432;
+        readonly expected_fact_cells_max: 16384;
+        readonly capacity_header_prefix_max_bytes: 65536;
+    };
+};

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

@@ -0,0 +1,12 @@
+export const DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY = {
+    symbolic_denotation_efficiency_delivery: true,
+    control_relations_unchanged: true,
+    forbidden_symbolic_shortcuts_absent: true,
+    symbolic_inventory_is_not_completion: true,
+    v1_capacity: {
+        embedded_handoff_max_bytes: 8_388_608,
+        canonical_manifest_max_bytes: 33_554_432,
+        expected_fact_cells_max: 16_384,
+        capacity_header_prefix_max_bytes: 65_536,
+    },
+};

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

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

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`),
+    };
+}