project-tiny-context-harness 0.8.17 → 0.12.0

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,140 +0,0 @@
-import { parseDesignResourceHandoffResources } from "./design-resource-handoff-shape-structure.js";
-import { contractKey, sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
-import { parseDesignResourceTechnicalFeasibilityInputs } from "./design-resource-implementation-feasibility-shape.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",
-    ], ["technical_feasibility_inputs"]);
-    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),
-        technical_feasibility_inputs: parseDesignResourceTechnicalFeasibilityInputs(root.technical_feasibility_inputs ?? [], `${label}.technical_feasibility_inputs`),
-        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`),
-    };
-}