project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/profiles.d.ts

@@ -1,13 +0,0 @@
-import type { HarnessConfig, HarnessProfile } from "./types.js";
-export declare const HARNESS_PROFILES: readonly HarnessProfile[];
-export declare function isProfileEnabled(config: HarnessConfig, profile: HarnessProfile): boolean;
-export declare function assertHarnessProfileEnabled(projectRoot: string, profile: HarnessProfile): Promise<void>;
-export declare function enableHarnessProfile(projectRoot: string, profile: string): Promise<{
-    changed: boolean;
-    config: HarnessConfig;
-}>;
-export declare function disableHarnessProfile(projectRoot: string, profile: string): Promise<{
-    changed: boolean;
-    config: HarnessConfig;
-}>;
-export declare function enabledManagedSkillNames(config: HarnessConfig): Set<string>;

package/dist/lib/profiles.js

@@ -1,65 +0,0 @@
-import path from "node:path";
-import { readConfig, writeConfigIfMissing } from "./config.js";
-import { harnessConfigPath } from "./harness-root.js";
-import { readText, writeTextIfChanged } from "./fs.js";
-import { parseYaml, stringifyYaml } from "./yaml.js";
-export const HARNESS_PROFILES = [
-    "core-portable",
-    "workflow-default",
-    "long-task",
-];
-export function isProfileEnabled(config, profile) {
-    return config.profiles.enabled.includes(profile);
-}
-export async function assertHarnessProfileEnabled(projectRoot, profile) {
-    const config = await readConfig(projectRoot);
-    if (!isProfileEnabled(config, profile)) {
-        throw new Error(`profile ${profile} is not enabled; run: ty-context enable ${profile}`);
-    }
-}
-export async function enableHarnessProfile(projectRoot, profile) {
-    if (!HARNESS_PROFILES.includes(profile)) {
-        throw new Error(`unknown profile ${profile}; expected one of ${HARNESS_PROFILES.join(", ")}`);
-    }
-    await writeConfigIfMissing(projectRoot);
-    const relative = await harnessConfigPath(projectRoot);
-    const file = path.join(projectRoot, relative);
-    const raw = parseYaml(await readText(file));
-    const existing = await readConfig(projectRoot);
-    const enabled = [
-        ...new Set([...existing.profiles.enabled, profile]),
-    ];
-    const next = { ...raw, profiles: { enabled } };
-    const changed = await writeTextIfChanged(file, stringifyYaml(next));
-    return { changed, config: await readConfig(projectRoot) };
-}
-export async function disableHarnessProfile(projectRoot, profile) {
-    if (profile !== "long-task") {
-        throw new Error("only long-task can be explicitly disabled");
-    }
-    await writeConfigIfMissing(projectRoot);
-    const relative = await harnessConfigPath(projectRoot);
-    const file = path.join(projectRoot, relative);
-    const raw = parseYaml(await readText(file));
-    const existing = await readConfig(projectRoot);
-    const enabled = existing.profiles.enabled.filter((item) => item !== profile);
-    const next = { ...raw, profiles: { enabled } };
-    const changed = await writeTextIfChanged(file, stringifyYaml(next));
-    return { changed, config: await readConfig(projectRoot) };
-}
-export function enabledManagedSkillNames(config) {
-    const names = new Set([
-        "context_development_engineer",
-        "context_full_project_export",
-        "context_harness_upgrade",
-        "context_product_plan",
-        "context_surface_contract",
-        "context_uiux_design",
-        "design-system-authoring",
-        "design-resource-authoring",
-    ]);
-    if (isProfileEnabled(config, "long-task")) {
-        names.add("long-task-workflow");
-    }
-    return names;
-}

package/dist/lib/semantic-fact-base-types.d.ts

@@ -1,14 +0,0 @@
-export type SemanticFactDisposition = "applicable" | "not_applicable" | "decision_required" | "unavailable";
-export type SemanticFactAuthorityKind = "direct" | "logically_derived" | "explicitly_delegated" | "evidence_backed_preservation";
-export type SemanticFactValueKind = "boolean" | "number" | "string" | "enum" | "set" | "ordered_list" | "object" | "schema" | "relation" | "decision_table" | "formula" | "range" | "duration" | "timestamp" | "rate" | "ratio" | "digest" | "trace" | "custom";
-export type SemanticFactLocatorKind = "source_item" | "manifest_pointer" | "json_pointer" | "yaml_pointer" | "whole_resource" | "schema_pointer" | "api_operation" | "code_symbol" | "custom";
-export interface SemanticFactLocatedValueV1 {
-    representation: "inline" | "located" | "digest_only";
-    locator: {
-        material_ref: string;
-        kind: SemanticFactLocatorKind;
-        value: string;
-    };
-    sha256: string;
-    value?: unknown;
-}

package/dist/lib/semantic-fact-base-types.js

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

package/dist/lib/semantic-fact-catalog.d.ts

@@ -1,8 +0,0 @@
-export declare const SEMANTIC_FACT_STANDARD_FAMILIES: readonly ["goal_scope_glossary", "actor_role_tenant_entitlement", "business_rule_calculation", "data_model", "operation_workflow", "state_machine", "temporal_scheduling", "input_validation", "output_error", "api_protocol", "event_message_job", "persistence_cache_search", "transaction_consistency_concurrency_idempotency", "fault_degradation_recovery", "backup_restore_disaster_recovery", "configuration_feature_flag_secret", "compatibility_migration_rollout", "performance_capacity_cost", "reliability_slo", "security", "privacy", "safety_compliance", "observability", "deployment_topology", "external_integration", "notification_file_media", "localization", "commercial_billing", "hardware_sensor", "ai_ml", "architecture_ownership"];
-export declare const SEMANTIC_FACT_STANDARD_CONDITION_AXES: readonly ["actor", "role", "tenant", "organization", "jurisdiction", "residency", "environment", "region", "zone", "platform", "device", "client_version", "api_version", "schema_version", "runtime_version", "feature", "cohort", "configuration", "entitlement", "permission", "consent", "session", "entity_state", "prior_state", "input_class", "boundary_case", "data_volume", "locale", "timezone", "clock", "concurrency", "repetition", "dependency_health", "connectivity", "failure_class", "retry_phase", "consistency", "freshness", "migration_phase", "rollout_phase", "topology", "threat", "operational_mode"];
-export declare const SEMANTIC_FACT_REQUIRED_INSPECTOR_CAPABILITIES: readonly ["source_inventory", "context_inventory", "input_classification", "standard_catalog", "custom_domain_discovery", "subject_inventory", "relation_inventory", "population_inventory", "condition_axis_inventory", "condition_combination_inventory", "property_inventory", "fact_cell_inventory", "proof_obligation_inventory"];
-export declare const SEMANTIC_FACT_PROOF_METHODS: readonly ["exact_value", "schema_contract", "decision_table", "formula_evaluation", "invariant", "transition_trace", "sequence_trace", "durable_roundtrip", "boundary_invocation", "external_side_effect", "population_set_equality", "concurrency_schedule", "idempotency_repetition", "fault_injection", "recovery_drill", "migration", "compatibility", "performance", "capacity", "security", "privacy", "audit", "observability", "deployment", "implementation_structure"];
-export declare const SEMANTIC_FACT_COMPARATORS: readonly ["exact_value", "semantic_equal", "set_equal", "ordered_equal", "schema_compatible", "decision_table_complete", "numeric_tolerance", "range_contains", "trace_equal", "invariant_holds", "population_set_equal", "latency_budget", "capacity_budget", "security_policy", "privacy_policy", "custom"];
-export declare const SEMANTIC_FACT_STANDARD_PROPERTIES: Readonly<Record<(typeof SEMANTIC_FACT_STANDARD_FAMILIES)[number], readonly string[]>>;
-export declare function isCustomSemanticFactName(value: string): boolean;
-export declare function isAtomicSemanticFactAtom(value: string): boolean;

package/dist/lib/semantic-fact-catalog.js

@@ -1,191 +0,0 @@
-export const SEMANTIC_FACT_STANDARD_FAMILIES = [
-    "goal_scope_glossary",
-    "actor_role_tenant_entitlement",
-    "business_rule_calculation",
-    "data_model",
-    "operation_workflow",
-    "state_machine",
-    "temporal_scheduling",
-    "input_validation",
-    "output_error",
-    "api_protocol",
-    "event_message_job",
-    "persistence_cache_search",
-    "transaction_consistency_concurrency_idempotency",
-    "fault_degradation_recovery",
-    "backup_restore_disaster_recovery",
-    "configuration_feature_flag_secret",
-    "compatibility_migration_rollout",
-    "performance_capacity_cost",
-    "reliability_slo",
-    "security",
-    "privacy",
-    "safety_compliance",
-    "observability",
-    "deployment_topology",
-    "external_integration",
-    "notification_file_media",
-    "localization",
-    "commercial_billing",
-    "hardware_sensor",
-    "ai_ml",
-    "architecture_ownership",
-];
-export const SEMANTIC_FACT_STANDARD_CONDITION_AXES = [
-    "actor",
-    "role",
-    "tenant",
-    "organization",
-    "jurisdiction",
-    "residency",
-    "environment",
-    "region",
-    "zone",
-    "platform",
-    "device",
-    "client_version",
-    "api_version",
-    "schema_version",
-    "runtime_version",
-    "feature",
-    "cohort",
-    "configuration",
-    "entitlement",
-    "permission",
-    "consent",
-    "session",
-    "entity_state",
-    "prior_state",
-    "input_class",
-    "boundary_case",
-    "data_volume",
-    "locale",
-    "timezone",
-    "clock",
-    "concurrency",
-    "repetition",
-    "dependency_health",
-    "connectivity",
-    "failure_class",
-    "retry_phase",
-    "consistency",
-    "freshness",
-    "migration_phase",
-    "rollout_phase",
-    "topology",
-    "threat",
-    "operational_mode",
-];
-export const SEMANTIC_FACT_REQUIRED_INSPECTOR_CAPABILITIES = [
-    "source_inventory",
-    "context_inventory",
-    "input_classification",
-    "standard_catalog",
-    "custom_domain_discovery",
-    "subject_inventory",
-    "relation_inventory",
-    "population_inventory",
-    "condition_axis_inventory",
-    "condition_combination_inventory",
-    "property_inventory",
-    "fact_cell_inventory",
-    "proof_obligation_inventory",
-];
-export const SEMANTIC_FACT_PROOF_METHODS = [
-    "exact_value",
-    "schema_contract",
-    "decision_table",
-    "formula_evaluation",
-    "invariant",
-    "transition_trace",
-    "sequence_trace",
-    "durable_roundtrip",
-    "boundary_invocation",
-    "external_side_effect",
-    "population_set_equality",
-    "concurrency_schedule",
-    "idempotency_repetition",
-    "fault_injection",
-    "recovery_drill",
-    "migration",
-    "compatibility",
-    "performance",
-    "capacity",
-    "security",
-    "privacy",
-    "audit",
-    "observability",
-    "deployment",
-    "implementation_structure",
-];
-export const SEMANTIC_FACT_COMPARATORS = [
-    "exact_value",
-    "semantic_equal",
-    "set_equal",
-    "ordered_equal",
-    "schema_compatible",
-    "decision_table_complete",
-    "numeric_tolerance",
-    "range_contains",
-    "trace_equal",
-    "invariant_holds",
-    "population_set_equal",
-    "latency_budget",
-    "capacity_budget",
-    "security_policy",
-    "privacy_policy",
-    "custom",
-];
-export const SEMANTIC_FACT_STANDARD_PROPERTIES = {
-    goal_scope_glossary: "goal observable_outcome scope non_goal term_definition unit_definition invariant assumption priority acceptance_meaning normative_status decision_owner conflict_resolution".split(" "),
-    actor_role_tenant_entitlement: "identity eligibility visibility allowed_operation forbidden_operation delegation impersonation isolation_boundary ownership approval_owner escalation lifecycle".split(" "),
-    business_rule_calculation: "predicate input precedence decision_branch overlap_handling gap_handling output formula formula_version unit precision rounding threshold boundary_inclusivity cap floor exception effective_period audit_rationale".split(" "),
-    data_model: "identity type schema nullability requiredness default absence_semantics enum_domain uniqueness cardinality ownership provenance lineage mutability lifecycle unit precision scale rounding format encoding normalization ordering comparison invariant validation_boundary sensitivity retention serialization".split(" "),
-    operation_workflow: "trigger initiator target precondition input guard ordered_step state_transition synchronous_effect asynchronous_effect output postcondition partial_success cancellation replacement compensation feedback audit_event forbidden_effect".split(" "),
-    state_machine: "state initial_state terminal_state transition trigger guard action emitted_effect illegal_transition compound_state concurrent_state precedence reentry interruption cancellation timeout stale_handling conflict_handling recovery restoration archive_delete".split(" "),
-    temporal_scheduling: "clock_source monotonicity timezone calendar dst_gap dst_fold clock_skew timestamp effective_boundary expiry_boundary interval_inclusivity schedule recurrence grace_period debounce throttle ordering lateness timeout lease retry_timing test_clock".split(" "),
-    input_validation: "source type requiredness default absence_semantics accepted_range grammar unit encoding normalization canonicalization cross_field_rule validation_order validation_location duplicate_handling replay_handling size_limit rate_limit malformed_case adversarial_case error_identity feedback lossless_recovery".split(" "),
-    output_error: "schema ordering format provenance freshness pagination streaming success_variant empty_variant partial_variant stale_variant degraded_variant error_variant error_code retryability feedback correlation_identity redaction reconciliation recovery".split(" "),
-    api_protocol: "operation_identity transport authentication authorization parameter header request_body serialization content_negotiation response_variant error_variant status_code pagination filtering sorting idempotency rate_limit quota timeout retry callback_webhook version_negotiation deprecation compatibility".split(" "),
-    event_message_job: "producer consumer schema version partition_routing_key correlation causation ordering delivery_guarantee acknowledgement deduplication idempotency retry_backoff timeout dead_letter replay retention backpressure poison_message cancellation schedule observable_completion".split(" "),
-    persistence_cache_search: "canonical_owner schema key index query ordering transaction_boundary persistence eviction freshness invalidation replication archive retention deletion tombstone import_export backup_participation tokenization ranking filter pagination rebuild reconciliation".split(" "),
-    transaction_consistency_concurrency_idempotency: "atomicity isolation consistency_model durability read_visibility write_visibility lock_lease optimistic_conflict pessimistic_conflict race_interleaving ordering causality duplicate_handling replay_handling idempotency_scope idempotency_key_lifetime retry_safety lost_update_prevention partial_commit compensation convergence".split(" "),
-    fault_degradation_recovery: "fault_class detection timeout_budget retry_eligibility retry_schedule jitter retry_exhaustion circuit_breaker bulkhead fallback degraded_result cancellation cleanup compensation feedback recovery_trigger restoration_point reconciliation data_loss_prevention duplicate_effect_prevention".split(" "),
-    backup_restore_disaster_recovery: "backup_scope frequency consistency_point encryption retention restore_procedure restore_verification rpo rto regional_disaster dependency_disaster failover failback replay reconciliation ownership drill_evidence".split(" "),
-    configuration_feature_flag_secret: "schema type requiredness safe_default scope environment_precedence tenant_precedence override_rule conflict_rule validation reload_restart rollout cohort_assignment kill_switch expiry cleanup audit protected_representation rotation failure_behavior".split(" "),
-    compatibility_migration_rollout: "supported_version backward_compatibility forward_compatibility mixed_version migration backfill validation dual_read dual_write cutover canary phased_rollout downgrade rollback irreversible_boundary cleanup deprecation data_reconciliation failure_recovery".split(" "),
-    performance_capacity_cost: "journey workload_model dataset_cardinality payload concurrency warm_cold_state latency_percentile deadline throughput queue_limit backpressure_limit resource_budget saturation scaling cost_boundary quota_boundary benchmark_environment measurement_window statistical_method tolerance".split(" "),
-    reliability_slo: "service_indicator measurement_point population exclusion target window availability correctness durability freshness continuity error_budget dependency_assumption degraded_expectation alert_relationship recovery_response".split(" "),
-    security: "asset threat trust_boundary authentication identity_proofing authorization least_privilege tenant_isolation session_lifecycle token_lifecycle mfa account_recovery secret_rotation key_rotation transport_encryption at_rest_encryption integrity input_defense output_defense audit rate_limit abuse_case supply_chain_integrity vulnerability_handling incident_response".split(" "),
-    privacy: "classification purpose lawful_authority consent preference minimization collection sharing lineage processor residency retention access_right correction_right portability_right deletion_right derived_data_effect redaction pseudonymization logging_restriction incident_handling policy_version".split(" "),
-    safety_compliance: "hazard prohibited_outcome jurisdiction policy_version risk_control safe_state human_approval four_eyes irreversibility confirmation cancellation emergency_stop audit accountability expert_authority incident_escalation residual_risk".split(" "),
-    observability: "log metric trace audit_event dimension unit correlation causation sampling aggregation redaction retention ownership health readiness liveness alert_condition alert_threshold alert_window alert_deduplication alert_routing alert_escalation dashboard runbook_diagnosis runbook_mitigation runbook_recovery".split(" "),
-    deployment_topology: "environment region zone topology replica dependency_direction configuration_injection secret_injection artifact_identity artifact_provenance startup readiness liveness shutdown migration_order rollout rollback drain maintenance autoscaling health_probe operational_owner post_deploy_verification".split(" "),
-    external_integration: "provider_protocol_identity capability version authentication region data_boundary quota rate_limit license commercial_constraint request_contract callback_contract timeout retry idempotency outage degradation side_effect_observation reconciliation sandbox_production_difference external_confirmation".split(" "),
-    notification_file_media: "audience channel template localization trigger priority quiet_hours cadence deduplication delivery_receipt retry unsubscribe file_type mime size dimensions duration codec metadata scan_quarantine upload_resume transformation storage signed_access fallback deletion accessibility_alternative".split(" "),
-    localization: "locale fallback language script unicode_normalization encoding collation case_sensitivity accent_sensitivity segmentation plural_rule grammar_rule timezone calendar date_format number_format currency exchange_rate_source measurement_unit conversion decimal_precision rounding locale_invariant_identifier".split(" "),
-    commercial_billing: "product_plan entitlement price effective_version meter_source aggregation currency tax jurisdiction precision rounding proration discount quota invoice payment_state retry refund dispute idempotency reconciliation audit processor_confirmation".split(" "),
-    hardware_sensor: "model firmware capability_discovery permission unit range resolution calibration sampling orientation coordinate_frame latency buffering connectivity power thermal storage_limit disconnect degradation actuator_safety simulation_limit physical_confirmation".split(" "),
-    ai_ml: "model version prompt_contract tool_contract input_schema output_schema context_source grounding_source stochastic_control confidence abstention safety_boundary policy_boundary bias_criterion quality_criterion explainability human_review intervention evaluation_population tolerance reproducibility drift_monitoring fallback privacy latency quota cost".split(" "),
-    architecture_ownership: "owner source_of_truth extension_point dependency_direction interface input_boundary output_boundary state_boundary persistence_boundary lifecycle_boundary failure_boundary recovery compatibility migration selected_design rejected_alternative future_change_challenge technical_debt forbidden_bypass conformance_check".split(" "),
-};
-export function isCustomSemanticFactName(value) {
-    return /^custom\.[a-z0-9][a-z0-9._-]*$/u.test(value);
-}
-export function isAtomicSemanticFactAtom(value) {
-    const normalized = value.trim().toLowerCase();
-    const aggregateLabel = /^(?:all|any|every|multiple|various)[._:-].*(?:catalog|states?|modes?|variants?|cases?|values?|conditions?)$/u.test(normalized) || /^(?:all|any|every|multiple|various)[._:-]\d+[._:-]/u.test(normalized);
-    return (/^[a-z0-9][a-z0-9._:-]*$/u.test(value) &&
-        !aggregateLabel &&
-        ![
-            "all",
-            "any",
-            "every",
-            "default",
-            "various",
-            "multiple",
-            "all-states",
-            "all_states",
-            "*",
-        ].includes(normalized));
-}

package/dist/lib/semantic-fact-compact-authoring.d.ts

@@ -1,2 +0,0 @@
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function createSemanticFactCompactCarrier(manifestInput: SemanticFactManifestV1): Record<string, unknown>;

package/dist/lib/semantic-fact-compact-authoring.js

@@ -1,160 +0,0 @@
-import { Buffer } from "node:buffer";
-import { indexSemanticFactRevisionInputs, semanticFactRevisionDigest, semanticObligationRevisionDigest, } from "./semantic-fact-compact-carrier.js";
-import { buildSemanticFactInspectorCensus } from "./semantic-fact-policy-census.js";
-import { semanticFactCollectionIdentity } from "./semantic-fact-policy.js";
-import { canonicalValueJson } from "./strict-codec.js";
-import { applyCompactAuthoringSelectors, compactAuthoringTable, compactCapacityBudget, compactDeterministicTemplates, compactWithoutFields as withoutFields, } from "./compact-authoring-support.js";
-import { applyCompactSharedStructures } from "./compact-shared-structure-authoring.js";
-import { semanticCompactSharedStructureTargets } from "./semantic-fact-compact-support.js";
-export function createSemanticFactCompactCarrier(manifestInput) {
-    const manifest = normalizedMaterializedManifest(manifestInput);
-    const inputRevisionsByFact = indexSemanticFactRevisionInputs(manifest.inputs);
-    const factRevisionByKey = new Map(manifest.facts.map((fact) => [
-        fact.key,
-        semanticFactRevisionDigest(fact, inputRevisionsByFact),
-    ]));
-    const proofRecords = manifest.proof_obligations;
-    const proofFamilies = compactDeterministicTemplates(proofRecords, ["key", "fact_ref", "comparison", "counterfactual"], "proof-template");
-    const proofFamilyByKey = new Map(proofFamilies.templates.map((template) => [template.key, template.value]));
-    const base = {
-        schema_version: "semantic-fact-compact-carrier-v1",
-        key: manifest.key,
-        capacity: {},
-        scope: structuredClone(manifest.scope),
-        inspector: {
-            trust: manifest.inspector.trust,
-            identity: manifest.inspector.identity,
-            version: manifest.inspector.version,
-            implementation_sha256: manifest.inspector.implementation_sha256,
-            capabilities: structuredClone(manifest.inspector.capabilities),
-            traversal: manifest.inspector.traversal,
-            dynamic_discovery: manifest.inspector.dynamic_discovery,
-        },
-        selectors: [],
-        shared_structures: [],
-        catalogs: {
-            inputs: compactTable(manifest.inputs),
-            family_dispositions: compactTable(manifest.family_dispositions),
-            subjects: compactTable(manifest.subjects),
-            relations: compactTable(manifest.relations),
-            populations: compactTable(manifest.populations),
-            axis_dispositions: compactTable(manifest.axis_dispositions),
-            condition_rules: compactTable(manifest.condition_rules),
-            conditions: compactTable(manifest.conditions),
-            condition_exclusions: compactTable(manifest.condition_exclusions),
-            property_dispositions: compactTable(manifest.property_dispositions),
-            fact_cells: compactTable(manifest.fact_cells),
-            oracles: compactTable(manifest.oracles),
-            environments: compactTable(manifest.environments),
-            blockers: compactTable(manifest.blockers),
-        },
-        fact_sets: [
-            {
-                key: "fact-set.complete-source",
-                ...compactTable(manifest.facts.map((fact) => ({
-                    fact_revision_digest: semanticFactRevisionDigest(fact, inputRevisionsByFact),
-                    ...fact,
-                })), ["key"]),
-            },
-        ],
-        proof_templates: proofFamilies.templates.map((template) => ({
-            key: template.key,
-            proof: template.value,
-        })),
-        obligations: compactTable(manifest.proof_obligations.map((proof, index) => ({
-            obligation_key: proof.key,
-            obligation_revision_digest: semanticObligationRevisionDigest(proof, requiredFactRevision(factRevisionByKey, proof.fact_ref)),
-            fact_key: proof.fact_ref,
-            template_ref: proofFamilies.template_refs[index],
-            overrides: withoutFields(proof, [
-                "key",
-                "fact_ref",
-                ...Object.keys(proofFamilyByKey.get(proofFamilies.template_refs[index])),
-            ]),
-        }))),
-        exceptions: [],
-    };
-    const { value: compact, selectors } = applyCompactAuthoringSelectors(base);
-    compact.selectors = selectors;
-    const structures = applyCompactSharedStructures(semanticCompactSharedStructureTargets(compact));
-    compact.shared_structures = structures.catalog;
-    const measured = {
-        inputs: manifest.inputs.length,
-        catalog_rows: manifest.inputs.length +
-            manifest.family_dispositions.length +
-            manifest.subjects.length +
-            manifest.relations.length +
-            manifest.populations.length +
-            manifest.axis_dispositions.length +
-            manifest.condition_rules.length +
-            manifest.conditions.length +
-            manifest.condition_exclusions.length +
-            manifest.property_dispositions.length +
-            manifest.fact_cells.length +
-            manifest.oracles.length +
-            manifest.environments.length +
-            manifest.blockers.length,
-        selector_members: selectors.reduce((sum, selector) => sum + selector.members.length, 0),
-        structure_families: structures.statistics.emitted_family_count,
-        structure_references: structures.statistics.reference_count,
-        structure_arguments: structures.statistics.argument_count,
-        facts: manifest.facts.length,
-        obligations: manifest.proof_obligations.length,
-        census: manifest.inspector.census.length,
-        canonical_bytes: Buffer.byteLength(canonicalValueJson(manifest), "utf8"),
-    };
-    compact.capacity = {
-        theoretical_ground_universe: "not_materialized",
-        measured,
-        maximum: Object.fromEntries(Object.entries(measured).map(([name, count]) => [
-            name,
-            compactCapacityBudget(name, count),
-        ])),
-    };
-    return compact;
-}
-function requiredFactRevision(revisions, factRef) {
-    const revision = revisions.get(factRef);
-    if (!revision)
-        throw new Error(`semantic_fact_compact_authoring_fact_revision_missing:${factRef}`);
-    return revision;
-}
-function normalizedMaterializedManifest(input) {
-    const manifest = structuredClone(input);
-    manifest.inspector.census = buildSemanticFactInspectorCensus(manifest);
-    const rows = {
-        inputs: manifest.inputs,
-        inspector_census: manifest.inspector.census,
-        family_dispositions: manifest.family_dispositions,
-        subjects: manifest.subjects,
-        relations: manifest.relations,
-        populations: manifest.populations,
-        axis_dispositions: manifest.axis_dispositions,
-        condition_rules: manifest.condition_rules,
-        conditions: manifest.conditions,
-        condition_exclusions: manifest.condition_exclusions,
-        property_dispositions: manifest.property_dispositions,
-        fact_cells: manifest.fact_cells,
-        facts: manifest.facts,
-        proof_obligations: manifest.proof_obligations,
-        oracles: manifest.oracles,
-        environments: manifest.environments,
-        blockers: manifest.blockers,
-    };
-    manifest.generation = {
-        strategy: "complete_explicit",
-        sampling: "forbidden",
-        truncation: "forbidden",
-        chunk_count: 1,
-        chunk_indexes: [0],
-        collections: Object.entries(rows).map(([name, collection]) => ({
-            name: name,
-            expected_count: collection.length,
-            identity_sha256: semanticFactCollectionIdentity(collection),
-        })),
-    };
-    return manifest;
-}
-function compactTable(input, excludedDefaults = []) {
-    return compactAuthoringTable(input, excludedDefaults);
-}

package/dist/lib/semantic-fact-compact-capacity.d.ts

@@ -1,9 +0,0 @@
-export declare const SEMANTIC_COMPACT_CAPACITY_FIELDS: readonly ["inputs", "catalog_rows", "selector_members", "structure_families", "structure_references", "structure_arguments", "facts", "obligations", "census", "canonical_bytes"];
-type CapacityField = (typeof SEMANTIC_COMPACT_CAPACITY_FIELDS)[number];
-export type SemanticCompactCapacityCounts = Record<CapacityField, number>;
-export declare function validateSemanticCompactCapacity(capacity: {
-    measured: SemanticCompactCapacityCounts;
-    maximum: SemanticCompactCapacityCounts;
-}, measured: SemanticCompactCapacityCounts, label: string): void;
-export declare function validateSemanticCompactDeclaredMaximum(maximum: SemanticCompactCapacityCounts, label: string): void;
-export {};

package/dist/lib/semantic-fact-compact-capacity.js

@@ -1,40 +0,0 @@
-import { semanticFail } from "./semantic-fact-shape-primitives.js";
-export const SEMANTIC_COMPACT_CAPACITY_FIELDS = [
-    "inputs",
-    "catalog_rows",
-    "selector_members",
-    "structure_families",
-    "structure_references",
-    "structure_arguments",
-    "facts",
-    "obligations",
-    "census",
-    "canonical_bytes",
-];
-const PACKAGE_MAXIMUM = {
-    inputs: 100_000,
-    catalog_rows: 2_000_000,
-    selector_members: 5_000_000,
-    structure_families: 1_000_000,
-    structure_references: 10_000_000,
-    structure_arguments: 50_000_000,
-    facts: 1_000_000,
-    obligations: 2_000_000,
-    census: 10_000_000,
-    canonical_bytes: 256 * 1024 * 1024,
-};
-export function validateSemanticCompactCapacity(capacity, measured, label) {
-    for (const field of SEMANTIC_COMPACT_CAPACITY_FIELDS) {
-        if (capacity.maximum[field] > PACKAGE_MAXIMUM[field])
-            semanticFail(`${label}.capacity.maximum.${field}`, `exceeds package maximum ${PACKAGE_MAXIMUM[field]}`);
-        if (capacity.measured[field] !== measured[field])
-            semanticFail(`${label}.capacity.measured.${field}`, `measured mismatch: ${capacity.measured[field]}:${measured[field]}`);
-        if (measured[field] > capacity.maximum[field])
-            semanticFail(`${label}.capacity.maximum.${field}`, `capacity exceeded: ${measured[field]}:${capacity.maximum[field]}`);
-    }
-}
-export function validateSemanticCompactDeclaredMaximum(maximum, label) {
-    for (const field of SEMANTIC_COMPACT_CAPACITY_FIELDS)
-        if (maximum[field] > PACKAGE_MAXIMUM[field])
-            semanticFail(`${label}.capacity.maximum.${field}`, `exceeds package maximum ${PACKAGE_MAXIMUM[field]}`);
-}

package/dist/lib/semantic-fact-compact-carrier.d.ts

@@ -1,16 +0,0 @@
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-import { type SemanticCompactCapacityCounts } from "./semantic-fact-compact-support.js";
-export { indexSemanticFactRevisionInputs, semanticFactRevisionDigest, semanticObligationRevisionDigest, } from "./semantic-fact-compact-support.js";
-export declare const SEMANTIC_FACT_COMPACT_CARRIER_VERSION: "semantic-fact-compact-carrier-v1";
-export interface SemanticFactRevisionIdentityV1 {
-    key: string;
-    revision_digest: string;
-}
-export interface MaterializedSemanticFactCompactCarrierV1 {
-    manifest: SemanticFactManifestV1;
-    fact_revisions: SemanticFactRevisionIdentityV1[];
-    obligation_revisions: SemanticFactRevisionIdentityV1[];
-    measured: SemanticCompactCapacityCounts;
-}
-export declare function parseSemanticFactCompactCarrierShape(value: unknown): MaterializedSemanticFactCompactCarrierV1;
-export declare function parseSemanticFactCompactCarrierForMigration(value: unknown): MaterializedSemanticFactCompactCarrierV1;