@unified-product-graph/core 0.28.0 → 0.30.0

package/dist/index.d.ts

@@ -11,7 +11,7 @@
  * @see registry/entity-meta.ts for type IDs and maturity
  * @see grammar/hierarchy.ts for parent-child rules
  */
-type UPGEntityType = 'specification' | 'primitive' | 'operating_lifecycle' | 'operating_stage' | 'product' | 'outcome' | 'objective' | 'key_result' | 'metric' | 'metric_quality_assessment' | 'vision' | 'mission' | 'strategic_theme' | 'initiative' | 'capability' | 'value_stream' | 'strategic_pillar' | 'assumption' | 'decision' | 'constraint' | 'strategic_question' | 'persona' | 'job' | 'need' | 'desired_outcome' | 'job_step' | 'switching_cost' | 'opportunity' | 'solution' | 'feasibility_study' | 'design_sprint' | 'hypothesis' | 'hypothesis_evidence' | 'experiment' | 'experiment_plan' | 'experiment_run' | 'learning' | 'test_plan' | 'evidence' | 'research_plan' | 'competitor' | 'competitor_feature' | 'competitor_signal' | 'market_trend' | 'market_segment' | 'competitive_analysis' | 'classification_axis' | 'classification_value' | 'research_study' | 'insight' | 'participant' | 'observation' | 'quote' | 'affinity_cluster' | 'research_question' | 'interview_guide' | 'survey_response' | 'user_journey' | 'journey_step' | 'journey_phase' | 'journey_action' | 'design_question' | 'design_concept' | 'prototype' | 'wireframe' | 'user_flow' | 'screen' | 'screen_state' | 'surface' | 'annotation' | 'interaction_spec' | 'design_component' | 'design_token' | 'design_system' | 'design_pattern' | 'design_guideline' | 'brand_identity' | 'brand_colour' | 'brand_typography' | 'brand_voice' | 'brand_logo' | 'brand_imagery' | 'feature_area' | 'feature' | 'epic' | 'user_story' | 'story_statement' | 'story_task' | 'acceptance_criterion' | 'release' | 'task' | 'bug' | 'roadmap' | 'roadmap_item' | 'theme' | 'roadmap_theme' | 'changelog' | 'planning_cycle' | 'bounded_context' | 'service' | 'domain_event' | 'api_contract' | 'technical_debt_item' | 'feature_flag' | 'deployment' | 'aggregate' | 'domain_entity' | 'value_object' | 'command' | 'read_model' | 'api_endpoint' | 'database_schema' | 'queue_topic' | 'build_artifact' | 'code_repository' | 'library_dependency' | 'integration_pattern' | 'external_api' | 'data_flow' | 'investigation' | 'root_cause' | 'symptom' | 'fix' | 'funnel' | 'funnel_step' | 'acquisition_channel' | 'growth_campaign' | 'cohort' | 'behavioral_segment' | 'growth_loop' | 'variant' | 'attribution_model' | 'business_model' | 'value_proposition' | 'revenue_stream' | 'pricing_tier' | 'cost_structure' | 'unit_economics' | 'partnership' | 'key_resource' | 'key_activity' | 'customer_relationship' | 'distribution_channel' | 'gtm_strategy' | 'ideal_customer_profile' | 'positioning' | 'messaging' | 'launch' | 'content_strategy' | 'sales_motion' | 'competitive_battle_card' | 'demand_gen_program' | 'territory' | 'objection' | 'rebuttal' | 'proof_point' | 'team' | 'role' | 'stakeholder' | 'person' | 'team_okr' | 'retrospective' | 'dependency' | 'department' | 'skill' | 'ceremony' | 'capacity_plan' | 'data_source' | 'event_schema' | 'dashboard' | 'data_model' | 'data_quality_rule' | 'data_product' | 'data_pipeline' | 'data_lineage' | 'glossary_term' | 'data_domain' | 'report' | 'content_piece' | 'knowledge_base_article' | 'brand_asset' | 'prompt_template' | 'content_calendar' | 'content_theme' | 'documentation_template' | 'document' | 'legal_entity' | 'ip_asset' | 'contract' | 'contract_clause' | 'privacy_policy' | 'compliance_requirement' | 'risk' | 'data_contract' | 'audit_log_policy' | 'compliance_framework' | 'security_audit' | 'service_level_indicator' | 'service_level_objective' | 'error_budget' | 'incident' | 'postmortem' | 'runbook' | 'monitor' | 'alert_rule' | 'ci_pipeline' | 'release_strategy' | 'on_call_rotation' | 'infrastructure_component' | 'threat_model' | 'threat' | 'vulnerability' | 'security_control' | 'security_policy' | 'penetration_test' | 'security_review' | 'data_classification' | 'access_policy' | 'a11y_standard' | 'a11y_guideline' | 'a11y_audit' | 'a11y_issue' | 'a11y_annotation' | 'test_suite' | 'test_case' | 'qa_session' | 'regression_test' | 'test_coverage_report' | 'test_environment' | 'test_result' | 'feedback_program' | 'feature_request' | 'feedback_vote' | 'nps_campaign' | 'user_advisory_board' | 'beta_program' | 'feedback_theme' | 'pricing_strategy' | 'discount_strategy' | 'trial_config' | 'paywall' | 'ai_model' | 'prompt_version' | 'eval_benchmark' | 'eval_run' | 'ai_cost_tracker' | 'hallucination_report' | 'ai_guardrail' | 'model_comparison' | 'ai_experiment' | 'ai_dataset' | 'ai_trace' | 'workflow_template' | 'workflow_run' | 'agent_definition' | 'agent_session' | 'review_gate' | 'approval_record' | 'agent_skill' | 'agent_hook' | 'workflow_artifact' | 'agent_task' | 'organization' | 'portfolio' | 'product_area' | 'workspace' | 'framework_exercise' | 'account' | 'contact' | 'lead' | 'deal' | 'pipeline_sales' | 'pipeline_stage' | 'quote_document' | 'subscription' | 'invoice' | 'forecast' | 'program' | 'project' | 'milestone' | 'risk_register' | 'change_request' | 'deliverable' | 'resource_allocation' | 'status_report' | 'marketing_strategy' | 'marketing_channel' | 'marketing_campaign_plan' | 'email_sequence' | 'social_post' | 'seo_keyword' | 'ad_creative' | 'press_release' | 'event' | 'community_initiative' | 'support_ticket' | 'customer_feedback' | 'churn_reason' | 'customer_health_score' | 'playbook' | 'service_level_agreement' | 'customer_journey_stage' | 'touchpoint' | 'success_milestone' | 'service_blueprint' | 'locale' | 'translation_key' | 'translation_bundle' | 'locale_config' | 'cultural_adaptation' | 'regional_pricing' | 'education_program' | 'tutorial' | 'walkthrough' | 'webinar' | 'certification' | 'help_video' | 'learning_path' | 'partner_program' | 'partner_tier' | 'api_ecosystem' | 'marketplace_listing' | 'developer_portal' | 'integration_partner' | 'partner_revenue_share';
+type UPGEntityType = 'specification' | 'primitive' | 'operating_lifecycle' | 'operating_stage' | 'product' | 'outcome' | 'objective' | 'key_result' | 'metric' | 'metric_quality_assessment' | 'vision' | 'mission' | 'strategic_theme' | 'initiative' | 'capability' | 'value_stream' | 'strategic_pillar' | 'assumption' | 'decision' | 'constraint' | 'strategic_question' | 'persona' | 'job' | 'need' | 'desired_outcome' | 'job_step' | 'switching_cost' | 'opportunity' | 'solution' | 'feasibility_study' | 'design_sprint' | 'hypothesis' | 'hypothesis_evidence' | 'experiment' | 'experiment_plan' | 'experiment_run' | 'learning' | 'test_plan' | 'evidence' | 'research_plan' | 'competitor' | 'competitor_feature' | 'competitor_signal' | 'market_trend' | 'market_segment' | 'competitive_analysis' | 'classification_axis' | 'classification_value' | 'research_study' | 'insight' | 'participant' | 'observation' | 'quote' | 'affinity_cluster' | 'research_question' | 'interview_guide' | 'survey_response' | 'user_journey' | 'journey_step' | 'journey_phase' | 'journey_action' | 'design_question' | 'design_concept' | 'prototype' | 'wireframe' | 'user_flow' | 'screen' | 'screen_state' | 'surface' | 'annotation' | 'interaction_spec' | 'design_component' | 'design_token' | 'design_system' | 'design_pattern' | 'design_guideline' | 'brand_identity' | 'brand_colour' | 'brand_typography' | 'brand_voice' | 'brand_logo' | 'brand_imagery' | 'feature_area' | 'feature' | 'epic' | 'user_story' | 'story_statement' | 'story_task' | 'acceptance_criterion' | 'release' | 'task' | 'bug' | 'roadmap' | 'roadmap_item' | 'theme' | 'roadmap_theme' | 'changelog' | 'planning_cycle' | 'configuration_axis' | 'bounded_context' | 'service' | 'domain_event' | 'api_contract' | 'technical_debt_item' | 'feature_flag' | 'deployment' | 'aggregate' | 'domain_entity' | 'value_object' | 'command' | 'read_model' | 'api_endpoint' | 'database_schema' | 'queue_topic' | 'build_artifact' | 'code_repository' | 'library_dependency' | 'integration_pattern' | 'external_api' | 'data_flow' | 'investigation' | 'root_cause' | 'symptom' | 'fix' | 'funnel' | 'funnel_step' | 'acquisition_channel' | 'growth_campaign' | 'cohort' | 'behavioral_segment' | 'growth_loop' | 'variant' | 'attribution_model' | 'business_model' | 'value_proposition' | 'revenue_stream' | 'pricing_tier' | 'cost_structure' | 'unit_economics' | 'partnership' | 'key_resource' | 'key_activity' | 'customer_relationship' | 'distribution_channel' | 'gtm_strategy' | 'ideal_customer_profile' | 'positioning' | 'messaging' | 'launch' | 'content_strategy' | 'sales_motion' | 'competitive_battle_card' | 'demand_gen_program' | 'territory' | 'objection' | 'rebuttal' | 'proof_point' | 'team' | 'role' | 'stakeholder' | 'person' | 'team_okr' | 'retrospective' | 'dependency' | 'department' | 'skill' | 'ceremony' | 'capacity_plan' | 'data_source' | 'event_schema' | 'dashboard' | 'data_model' | 'data_quality_rule' | 'data_product' | 'data_pipeline' | 'data_lineage' | 'glossary_term' | 'data_domain' | 'report' | 'content_piece' | 'knowledge_base_article' | 'brand_asset' | 'prompt_template' | 'content_calendar' | 'content_theme' | 'documentation_template' | 'document' | 'legal_entity' | 'ip_asset' | 'contract' | 'contract_clause' | 'privacy_policy' | 'compliance_requirement' | 'risk' | 'data_contract' | 'audit_log_policy' | 'compliance_framework' | 'security_audit' | 'service_level_indicator' | 'service_level_objective' | 'error_budget' | 'incident' | 'postmortem' | 'runbook' | 'monitor' | 'alert_rule' | 'ci_pipeline' | 'release_strategy' | 'on_call_rotation' | 'infrastructure_component' | 'threat_model' | 'threat' | 'vulnerability' | 'security_control' | 'security_policy' | 'penetration_test' | 'security_review' | 'data_classification' | 'access_policy' | 'a11y_standard' | 'a11y_guideline' | 'a11y_audit' | 'a11y_issue' | 'a11y_annotation' | 'test_suite' | 'test_case' | 'qa_session' | 'regression_test' | 'test_coverage_report' | 'test_environment' | 'test_result' | 'feedback_program' | 'feature_request' | 'feedback_vote' | 'nps_campaign' | 'user_advisory_board' | 'beta_program' | 'feedback_theme' | 'pricing_strategy' | 'discount_strategy' | 'trial_config' | 'paywall' | 'ai_model' | 'prompt_version' | 'eval_benchmark' | 'eval_run' | 'ai_cost_tracker' | 'hallucination_report' | 'ai_guardrail' | 'model_comparison' | 'ai_experiment' | 'ai_dataset' | 'ai_trace' | 'workflow_template' | 'workflow_run' | 'agent_definition' | 'agent_session' | 'review_gate' | 'approval_record' | 'agent_skill' | 'agent_hook' | 'workflow_artifact' | 'agent_task' | 'organization' | 'portfolio' | 'product_area' | 'workspace' | 'framework_exercise' | 'account' | 'contact' | 'lead' | 'deal' | 'pipeline_sales' | 'pipeline_stage' | 'quote_document' | 'subscription' | 'invoice' | 'forecast' | 'program' | 'project' | 'milestone' | 'risk_register' | 'change_request' | 'deliverable' | 'resource_allocation' | 'status_report' | 'marketing_strategy' | 'marketing_channel' | 'marketing_campaign_plan' | 'email_sequence' | 'social_post' | 'seo_keyword' | 'ad_creative' | 'press_release' | 'event' | 'community_initiative' | 'support_ticket' | 'customer_feedback' | 'churn_reason' | 'customer_health_score' | 'playbook' | 'service_level_agreement' | 'customer_journey_stage' | 'touchpoint' | 'success_milestone' | 'service_blueprint' | 'locale' | 'translation_key' | 'translation_bundle' | 'locale_config' | 'cultural_adaptation' | 'regional_pricing' | 'education_program' | 'tutorial' | 'walkthrough' | 'webinar' | 'certification' | 'help_video' | 'learning_path' | 'partner_program' | 'partner_tier' | 'api_ecosystem' | 'marketplace_listing' | 'developer_portal' | 'integration_partner' | 'partner_revenue_share';
 /**
  * No entity types are currently deprecated; this union is `never`. The
  * deprecated-name bridge, which previously widened this union to early
@@ -138,7 +138,7 @@ interface UPGBaseNode {
  * wall-clock timestamp: generation is deterministic). This file is a GATED
  * artifact — check:generated re-runs the generator and fails on any drift, so
  * edit the sources above, never this file.
- * Entity types with properties: 324
+ * Entity types with properties: 325
  */
 interface PropertyDefinition {
     type: 'string' | 'number' | 'boolean' | 'string[]' | 'object' | 'object[]' | 'assessment';
@@ -283,6 +283,42 @@ declare const CLASSIFICATION_EDGE_PROPERTY_SCHEMA: PropertySchema;
  * a stated period); the writers reject any other key.
  */
 declare const DEFER_EDGE_PROPERTY_SCHEMA: PropertySchema;
+/**
+ * Property schema carried by `surface_varies_by_configuration_axis` (0.30.0).
+ *
+ * CONDITIONAL EXISTENCE, expressed as an edge. The surface exists in the stored
+ * graph regardless; this edge says which members of the configuration family it
+ * appears in. No edge at all means invariant, which is why every graph written
+ * before this existed keeps meaning exactly what it meant.
+ */
+declare const CONFIGURATION_VARIANCE_EDGE_PROPERTY_SCHEMA: PropertySchema;
+/**
+ * Property schema carried by the two surface-composition edges
+ * (`surface_contains_surface` and `feature_occupies_surface`), 0.30.0.
+ *
+ * A single `active_when` key qualifies the relationship by a configuration
+ * axis: the edge holds only under the named values, and is absent from every
+ * other projection.
+ *
+ * SCOPE IS THE POINT, NOT AN OVERSIGHT. These two edges are the whole legal
+ * surface for the qualifier, and `validate_graph` rejects `active_when` on any
+ * other edge type. UPG is not adding a general modality system on one field
+ * report; it is answering the composition question that report actually asked.
+ * Any further edge earns the qualifier on field evidence, one at a time.
+ *
+ * A QUALIFIER CANNOT EXPRESS NON-EXISTENCE. If the surface itself is absent
+ * under a value, say so on the node with `surface_varies_by_configuration_axis`;
+ * the projection then drops this edge as dangling and the qualifier is
+ * redundant. Reach for `active_when` only when BOTH endpoints exist and the
+ * RELATIONSHIP is what changes: the occupant that moves to a different row, the
+ * feature that occupies a different place under the flag.
+ *
+ * ONE AXIS PER QUALIFIER. An edge conditional on two axes at once is a stated
+ * non-goal; where it is genuinely needed, the honest model is one axis whose
+ * values are the combinations that actually occur, which is the same discipline
+ * as "one axis per semantic lever".
+ */
+declare const CONFIGURATION_QUALIFIER_EDGE_PROPERTY_SCHEMA: PropertySchema;
 declare const UPG_EDGE_CATALOG: {
     product_targets_persona: {
         forward_verb: string;
@@ -1769,6 +1805,8 @@ declare const UPG_EDGE_CATALOG: {
         classification: "hierarchy";
         source_type: string;
         target_type: string;
+        carries_properties: true;
+        property_schema: PropertySchema;
     };
     surface_serves_job: {
         forward_verb: string;
@@ -1815,12 +1853,44 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    product_defines_configuration_axis: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "hierarchy";
+        source_type: string;
+        target_type: string;
+    };
+    feature_flag_drives_configuration_axis: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "cross-domain";
+        source_type: string;
+        target_type: string;
+    };
+    surface_varies_by_configuration_axis: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "cross-domain";
+        source_type: string;
+        target_type: string;
+        carries_properties: true;
+        property_schema: PropertySchema;
+    };
+    surface_alternates_with_surface: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "semantic";
+        source_type: string;
+        target_type: string;
+    };
     feature_occupies_surface: {
         forward_verb: string;
         reverse_verb: string;
         classification: "cross-domain";
         source_type: string;
         target_type: string;
+        carries_properties: true;
+        property_schema: PropertySchema;
     };
     screen_renders_surface: {
         forward_verb: string;
@@ -8715,7 +8785,7 @@ declare const UPG_DOMAINS: readonly [{
     readonly id: "product_spec";
     readonly label: "Product Specification";
     readonly description: "What you are building and shipping. Feature areas group related capabilities. Features, epics, and user stories break work down. Acceptance criteria define done. Tasks and bugs track execution. Releases and changelogs mark what shipped. Roadmaps and roadmap items plan what comes next. Roadmap themes group roadmap work around the customer problem it solves, one level down from the strategic themes in Strategy. Planning cycles are the cadence axis: the named, dated, self-nesting intervals (sprint, iteration, quarter, program increment, cooldown) that work is scheduled through. Translates Strategy into Engineering and tracks delivery through Program Management.";
-    readonly types: readonly ["feature", "feature_area", "epic", "user_story", "acceptance_criterion", "release", "task", "bug", "roadmap", "roadmap_item", "roadmap_theme", "changelog", "planning_cycle"];
+    readonly types: readonly ["feature", "feature_area", "epic", "user_story", "acceptance_criterion", "release", "task", "bug", "roadmap", "roadmap_item", "roadmap_theme", "changelog", "planning_cycle", "configuration_axis"];
 }, {
     readonly id: "engineering";
     readonly label: "Engineering";
@@ -9011,6 +9081,203 @@ declare const UPG_CONTAINMENT_FREE_TYPES: ReadonlySet<string>;
  */
 declare function isContainmentFreeType(entityType: string): boolean;
 
+/**
+ * UPG Configuration Projection (0.30.0).
+ *
+ * The stored graph is the UNION of a configuration family. A single
+ * configuration is a PROJECTION of it, and this is the operator that takes one.
+ *
+ * π(G, C) drops what a named configuration does not contain and leaves
+ * everything else exactly as it was. Facts that carry no configuration
+ * qualification are invariant: they belong to every member of the family, which
+ * is why a graph written before this existed projects to itself under every C
+ * and needs no migration.
+ *
+ * PURE, AND DELIBERATELY STORE-FREE. It takes node and edge arrays and returns
+ * node and edge arrays, so the local file store, the cloud SQL store and a
+ * synthetic store built for validation preview all reuse one definition of what
+ * a projection IS. A projection implemented twice is two projections.
+ *
+ * READ-ONLY. Nothing writes a projected graph back. The union is the file.
+ *
+ * https://unifiedproductgraph.org/spec | MIT
+ */
+/** The minimum a node must expose to be projected. */
+interface ProjectableNode {
+    id: string;
+    type?: string;
+    properties?: Record<string, unknown> | undefined;
+}
+/** The minimum an edge must expose to be projected. */
+interface ProjectableEdge {
+    id?: string;
+    source: string;
+    target: string;
+    type?: string;
+    properties?: Record<string, unknown> | undefined;
+}
+/**
+ * A configuration: axis node id to the single value that holds on it.
+ *
+ * PARTIAL BY DESIGN. An axis absent from the map is not applied, so every fact
+ * qualified on it is retained. Projecting on nothing returns the union, which
+ * makes a configuration a strictly narrowing filter an agent can apply
+ * incrementally rather than an all-or-nothing mode.
+ */
+type Configuration = Readonly<Record<string, string>>;
+/** The edge that declares conditional existence. */
+declare const VARIES_BY_EDGE = "surface_varies_by_configuration_axis";
+/** The property carried by that edge. */
+declare const PRESENT_UNDER_PROPERTY = "present_under";
+/** The qualifier property carried by the two composition edges. */
+declare const ACTIVE_WHEN_PROPERTY = "active_when";
+/**
+ * The only edge types on which `active_when` is legal (D3).
+ *
+ * Scope is enforced, not merely documented: `validate_graph`'s
+ * `configuration_drift` scope reports the qualifier on any other edge type as
+ * an error. The projection operator itself is deliberately permissive here (it
+ * honours a qualifier wherever it finds one) so that a graph carrying an
+ * illegal qualifier still projects predictably while the validator names the
+ * problem. Silently ignoring it would make the drift invisible in the one view
+ * where its effect shows.
+ */
+declare const QUALIFIABLE_EDGE_TYPES: readonly string[];
+/** Result of a projection: the surviving nodes and edges, plus what it dropped. */
+interface ProjectionResult<N extends ProjectableNode = ProjectableNode, E extends ProjectableEdge = ProjectableEdge> {
+    nodes: N[];
+    edges: E[];
+    /** Node ids dropped because the configuration excluded them. */
+    excluded_node_ids: string[];
+    /** Count of edges dropped because their own qualifier excluded them. */
+    deactivated_edge_count: number;
+    /** Count of edges dropped because an endpoint was excluded. */
+    dangling_edge_count: number;
+}
+/**
+ * Read a string array property defensively; anything else reads as absent.
+ *
+ * Exported so the drift checker and the read-tool view share one reading of
+ * what a list-valued configuration property is. Three copies of this drifting
+ * apart is how a value the validator accepts becomes a value the projection
+ * ignores.
+ */
+declare function readStringArray(properties: Record<string, unknown> | undefined, key: string): string[] | undefined;
+/**
+ * Read an `active_when` qualifier, or undefined when the edge carries none or
+ * carries something malformed.
+ *
+ * A malformed qualifier reads as ABSENT rather than as "excludes everything".
+ * Absence means the relationship is invariant, so a broken qualifier leaves the
+ * edge in every projection: the graph shows too much rather than too little,
+ * and `configuration_drift` reports the malformation by name. The alternative
+ * would let one bad property silently delete structure from every view.
+ */
+declare function readActiveWhen(edge: ProjectableEdge): {
+    axis: string;
+    values: string[];
+} | undefined;
+/**
+ * Project a graph onto one configuration.
+ *
+ * Applied in order, ONCE. The operator is a filter, not a solver:
+ *
+ *  1. NODE EXCLUSION. A node is dropped when it declares variance on an axis
+ *     named in `configuration` and the chosen value is not in its
+ *     `present_under`. A node that says nothing about a named axis is retained,
+ *     because silence means invariant.
+ *  2. EDGE DEACTIVATION. An edge is dropped when its own `active_when` names an
+ *     axis in `configuration` and the chosen value is not among its values.
+ *  3. DANGLING REMOVAL. Any surviving edge with an endpoint dropped in step 1
+ *     goes too.
+ *
+ * NO CASCADE, AND THIS IS THE SUBTLE PART. A child surface is NOT dropped
+ * because its parent was. The motivating field case is precisely a surface
+ * whose PARENT changes under the flag (a navigation row splits in two and an
+ * occupant moves into the new row), so cascading would delete a surface that is
+ * genuinely present. A surface that survives with no containment parent in that
+ * projection is a modelling gap for the validator to report, not a deletion for
+ * the operator to guess at.
+ *
+ * COMMUTATIVE ACROSS AXES. Each axis's predicate reads only that axis, so
+ * projecting on two axes in either order, or both at once, gives the same
+ * result. Multi-axis projection therefore needs no ordering rule.
+ *
+ * @example
+ * // A graph where the inspector exists only under the split-nav flag.
+ * projectGraph(nodes, edges, { axis_nav: 'legacy_nav' }).nodes
+ * // → every node except the split-nav-only surfaces
+ */
+declare function projectGraph<N extends ProjectableNode = ProjectableNode, E extends ProjectableEdge = ProjectableEdge>(nodes: N[], edges: E[], configuration: Configuration): ProjectionResult<N, E>;
+/**
+ * Every configuration this graph can be projected onto, one axis at a time.
+ *
+ * PER-AXIS, NOT CARTESIAN. The list is the union (an empty configuration) plus
+ * one entry per declared value of each axis: `1 + Σ|values|`, linear in the
+ * declarations. The cartesian product across axes is combinatorial and buys
+ * nothing here, because every v1 qualifier reads a single axis and every check
+ * that consumes a projection is surface-local. Cross-axis interaction is a
+ * stated non-goal; when a detector needs it, this is the function that grows.
+ */
+declare function enumerateProjections(nodes: ProjectableNode[]): Array<{
+    axis?: string;
+    value?: string;
+    configuration: Configuration;
+}>;
+
+/**
+ * UPG Configuration Drift (0.30.0).
+ *
+ * Structural checking of the configuration declarations themselves: that an
+ * axis is well formed, that every value named anywhere is a value the axis
+ * actually declares, that the qualifier appears only where it is legal, and
+ * that a declared alternation is consistent with what the declarations imply.
+ *
+ * DRIFT, NOT AN ANTI-PATTERN. These are contradictions inside the model, the
+ * same family as an unknown entity type or a status outside its lifecycle: a
+ * graph carrying one is saying something it cannot mean. Anti-patterns are the
+ * other thing, judgements about a graph that is internally consistent, and
+ * 0.30.0 deliberately mints none of those (a detector with no field evidence
+ * behind it is how a check family gets noisy).
+ *
+ * Runs on the UNION. The declarations are facts about the whole family, so they
+ * are checked once, not once per projection. The single exception is
+ * `orphaned_under_projection`, which by definition can only be seen by taking
+ * one.
+ *
+ * https://unifiedproductgraph.org/spec | MIT
+ */
+
+/** The kinds of configuration drift the validator reports. */
+type ConfigurationDriftKind = 'axis_values_empty' | 'axis_default_not_a_value' | 'present_under_empty' | 'present_under_unknown_value' | 'qualifier_axis_unresolved' | 'qualifier_values_empty' | 'qualifier_unknown_value' | 'qualifier_on_illegal_edge' | 'alternation_axis_mismatch' | 'alternation_overlap' | 'orphaned_under_projection';
+/** One configuration-drift finding. */
+interface ConfigurationDriftFinding {
+    kind: ConfigurationDriftKind;
+    /**
+     * `error` means the graph contradicts itself and a projection of it cannot be
+     * trusted. `warning` means the graph is coherent but a projection of it has a
+     * gap worth looking at.
+     */
+    severity: 'error' | 'warning';
+    /** The node this finding is about, when it is about a node. */
+    node_id?: string;
+    /** The edge this finding is about, when it is about an edge. */
+    edge_id?: string;
+    /** The axis involved, where one is identifiable. */
+    axis_id?: string;
+    /** Human-readable statement of what is wrong. */
+    message: string;
+}
+/**
+ * Check every configuration declaration in a graph.
+ *
+ * @param nodes All nodes in the union.
+ * @param edges All edges in the union.
+ * @returns Findings, in a stable order: axis checks, then variance, then
+ *   qualifiers, then alternation, then the per-projection orphan warning.
+ */
+declare function checkConfigurationDrift(nodes: ProjectableNode[], edges: ProjectableEdge[]): ConfigurationDriftFinding[];
+
 /**
  * UPG Lifecycles. Phase-and-state journeys for entity types with meaningful status.
  *
@@ -10803,6 +11070,23 @@ interface ProductProperties {
     logo_url?: string;
     /** When the product became generally available (ISO 8601) */
     launched_at?: ISODateTime;
+    /**
+     * The product configuration this graph describes, named in plain language.
+     *
+     * A product's composition often differs by feature flag, plan tier,
+     * permission level or beta programme: surfaces appear, disappear, or are
+     * replaced by different surfaces with different occupants. A graph that
+     * models one of those without saying which is qualified by a condition
+     * nobody wrote down, and every fact in it inherits that silence.
+     *
+     * NAMING, NOT CONFIGURING. This is a label for readers. Nothing reads it to
+     * gate, filter, or alter how a tool interprets the graph, and it makes no
+     * claim about which configuration most customers are on.
+     *
+     * @example "Enterprise plan, split-navigation flag on"
+     * @example "Default: free tier, all flags off"
+     */
+    described_configuration?: string;
 }
 /** Vision entity.
  *
@@ -12917,6 +13201,21 @@ interface SurfaceProperties {
      * absence carries the "no cap" reading, rather than a magic sentinel value
      * that every consumer would have to special-case. `0` is a real cap meaning
      * "nothing may occupy this surface" (a reserved place), not "unbounded".
+     *
+     * THREE STATES, AND THEY ARE ALL DIFFERENT. Absent = unbounded, no cap
+     * stated. `0` = a reserved place nothing may occupy. `null` = neither of
+     * those, and nothing this field defines; it is what you get by writing an
+     * explicit null rather than removing the key, and no consumer reads it as a
+     * cap. To return this property to ABSENT, remove the key with
+     * `update_node`'s or `batch_update_nodes`' `unset_properties`, since a
+     * property merge preserves anything you omit.
+     *
+     * UNBOUNDED IS NOT AN EXEMPTION FROM SCRUTINY. The contention detector reads
+     * an absent capacity as a threshold of 1, on the reasoning that a surface
+     * which states no limit has stated no answer either, so several occupants is
+     * exactly the unrecorded decision worth naming. Declaring a real capacity is
+     * therefore the way to quiet the check honestly, and the only way that also
+     * records something true.
      */
     capacity?: number;
     /**
@@ -13790,6 +14089,92 @@ interface PlanningCycleProperties {
     /** Shape Up appetite: the fixed time budget a cycle is willing to spend on a bet (e.g. "6 weeks", "2 weeks"). */
     appetite?: string;
 }
+/** What kind of lever this axis is. Names the mechanism family so a reader
+ * knows what changing the value would mean operationally.
+ *
+ * - `feature_flag` — a runtime toggle owned by the product team.
+ * - `plan_tier` — what the customer bought.
+ * - `permission_level` — what this user is allowed to see.
+ * - `beta_program` — enrolment in an early-access cohort.
+ * - `other` — a lever that is none of these and is described in the node's
+ *   description rather than forced into a category that fits badly.
+ */
+type ConfigurationAxisKind = 'feature_flag' | 'plan_tier' | 'permission_level' | 'beta_program' | 'other';
+/** A named dimension along which the product's composition differs.
+ *
+ * The stored graph is the UNION of a configuration family; an axis names one
+ * dimension of that family, and a projection picks one value on it. A graph
+ * that declares no axis describes a product with one configuration, which is
+ * what every graph written before this entity existed already meant. That is
+ * the zero-migration guarantee: silence still means "true everywhere".
+ *
+ * ONE AXIS PER SEMANTIC LEVER, NOT PER CODE FLAG. The unit is the decision a
+ * reader makes ("are we on the new navigation or the old one?"), not the
+ * boolean a deploy system stores. Two flags that cannot be set independently
+ * — one forcing the other on — are ONE axis with two values, and modelling
+ * them as two axes would assert a four-configuration family, three members of
+ * which do not exist. Link each driving flag with
+ * `feature_flag_drives_configuration_axis`: the mechanism lives in
+ * engineering, the lever lives here.
+ *
+ * VALUES ARE CLOSED. Every `present_under` and every `active_when.values`
+ * entry must name a member of this list, and `validate_graph`'s
+ * `configuration_drift` scope says so. An axis whose values are open cannot
+ * support a projection, because nothing bounds the family being projected
+ * from.
+ *
+ * NOT `classification_axis`. That instrument sorts SUBJECTS into cells: a
+ * subject may sit in several at once, each placement carries evidence and
+ * confidence, and the axis describes a landscape. This one selects WHICH
+ * GRAPH YOU ARE READING: exactly one value holds at a time, placements carry
+ * no evidence, and changing the value changes what exists. The shapes rhyme;
+ * the questions do not.
+ *
+ * Per UPG principle P14, structural relationships are edges:
+ *   the product that defines it: `product_defines_configuration_axis` (inbound)
+ *   the driving mechanism: `feature_flag_drives_configuration_axis` (inbound)
+ *   what varies along it: `surface_varies_by_configuration_axis` (inbound)
+ *
+ * @example
+ * const properties: ConfigurationAxisProperties = {
+ *   values: ['legacy_nav', 'split_nav'],
+ *   default_value: 'legacy_nav',
+ *   kind: 'feature_flag',
+ * }
+ */
+interface ConfigurationAxisProperties {
+    /**
+     * The closed set of values this axis can take. Required: an axis with no
+     * values selects nothing and cannot be projected along.
+     *
+     * Two values is the common case and three is not unusual (a plan ladder).
+     * Order is not significant; the axis is categorical, not ordinal. Where the
+     * ordering does matter (an entitlement ladder in which each tier includes
+     * the one below), that is a classification question, and
+     * `classification_axis` with `axis_kind: 'ordinal'` is the instrument for it.
+     */
+    values: string[];
+    /**
+     * The value this axis is understood to sit at when nobody says otherwise.
+     * Must be a member of `values`.
+     *
+     * NOTHING APPLIES IT AUTOMATICALLY. Omitting `configuration` on a read
+     * returns the UNION, not this projection, because the union is the honest
+     * answer to an unqualified question: it is every configuration at once, and
+     * silently substituting one of them would hide the others from a reader who
+     * did not know to ask. What the field does carry is the declaration
+     * convention for `surface_alternates_with_surface` (declare the edge from the
+     * surface present under the default) and a documented anchor for tools that
+     * later want to offer a starting configuration.
+     *
+     * It is a claim about the model, not about deployment: it says which value
+     * most of the graph was written against, not which configuration most
+     * customers are on.
+     */
+    default_value?: string;
+    /** What kind of lever this is. Names the mechanism family. */
+    kind?: ConfigurationAxisKind;
+}
 
 /**
  * UPG Property Schemas: Metrics. Unified measurement across the product.
@@ -19686,6 +20071,7 @@ interface UPGPropertyMap {
     changelog: ChangelogProperties;
     /** A named, dated, self-nesting planning interval (sprint / iteration / quarter / PI / cooldown) work is scheduled through: the cadence axis */
     planning_cycle: PlanningCycleProperties;
+    configuration_axis: ConfigurationAxisProperties;
     /** A governed specification (query language, protocol, format) products implement, expose, or conform to */
     specification: SpecificationProperties;
     /** A foundational compositional unit a specification defines (a block, a reference, a query value) */
@@ -20576,9 +20962,17 @@ declare function getBusinessAreasForRegion(regionId: string): string[];
 /**
  * UPG Intelligence Conditions: structured, machine-evaluable graph predicates.
  *
- * Three check types: `EntityCheck` (count by criteria), `RelationshipCheck`
- * (edge existence/count), `BenchmarkCheck` (compare against stage benchmark).
+ * Check types: `EntityCheck` (count by criteria), `RelationshipCheck`
+ * (edge existence/count), `BenchmarkCheck` (compare against stage benchmark),
+ * `EdgeCountVsPropertyCheck` (per-node: edge count against the node's own
+ * numeric property), plus the graph-shape counts (total / domain / orphan).
  * Composable via `and` / `or` operators.
+ *
+ * All but `EdgeCountVsPropertyCheck` are AGGREGATE checks — whole-graph tallies
+ * compared against constants. That is why most detectors here are whole-graph
+ * approximations of per-node rules, and why they can say a graph has a problem
+ * without saying where. `EdgeCountVsPropertyCheck` (0.29.0) is the exception,
+ * and it is what lets a violation name the nodes it is about.
  */
 
 /** Count entities matching criteria */
@@ -20597,6 +20991,18 @@ interface EntityCheck {
      *    field nobody filled in, e.g. a `surface` with no `arbitration_rule`.
      *    A value-keyed filter cannot express absence, because the collector only
      *    indexes values that exist.
+     *
+     *    NON-EMPTY VALUE HERE MEANS NON-EMPTY *STRING*. The aggregate indexes
+     *    backing this form record string values only, so a numeric `0` or a
+     *    boolean `false` counts as ABSENT to this filter. That is a known wart,
+     *    documented rather than fixed in 0.29.0: broadening it would change which
+     *    graphs existing detectors fire on, which is not a change to make in a
+     *    release already carrying correctness fixes. It costs nothing today (no
+     *    catalog filter uses this form since the contention branch moved to
+     *    `EdgeCountVsPropertyCheck`), and the broadening question is banked as
+     *    a tracked follow-up. A detector that needs to see a declared
+     *    zero should use `EdgeCountVsPropertyCheck.node_filter`, whose presence
+     *    test is deliberately broader.
      * 2. `{ property, value }` (0.17.0) — count entities whose `property` equals
      *    `value`, e.g. `metric` where `designation === 'north_star'`.
      * 3. `{ status }` — count entities in a given lifecycle status.
@@ -20693,6 +21099,111 @@ interface OrphanCheck {
     /** Threshold value (not needed for 'zero' / 'nonzero') */
     threshold?: number;
 }
+/**
+ * Count entities whose EDGE COUNT stands in a stated relation to one of their
+ * own NUMERIC PROPERTIES (0.29.0).
+ *
+ * The first genuinely per-node check form. Every other check in this file is an
+ * aggregate: it compares a whole-graph tally against a constant. This one
+ * compares two values that both live on the same node, so it cannot be
+ * expressed by any composition of the others — a graph-wide edge count says
+ * nothing about which node holds which capacity, and the presence filters key
+ * on whether a property EXISTS, never on what it says relative to anything else.
+ *
+ * The motivating case (feedback `af9ae4c2`, measured on a 43-surface field
+ * graph): `contended-surface-without-arbitration` counted
+ * `feature_occupies_surface` edges and never read `capacity`, so a header row
+ * declaring room for four occupants and holding exactly four was flagged as
+ * contended alongside a capacity-1 panel holding three. Ten surfaces flagged,
+ * three of them wrongly, and all three wrong for this one reason.
+ *
+ * DELIBERATELY GENERAL. The shape is "edge count versus numeric property", not
+ * "occupancy versus capacity". A surface's guest list against its capacity is
+ * the first instance, but the form fits any place the graph states a numeric
+ * intent and the edges record what actually arrived.
+ *
+ * COLLECTORS ARE DRIVEN BY DECLARED SPECS, never by speculative indexing.
+ * `UPG_EDGE_COUNT_SPECS` is derived from the conditions in this catalog, so a
+ * collector computes exactly the per-node tallies some detector asked for, and
+ * seeds every declared spec before walking so that "nothing matched" and "this
+ * collector is stale" stay distinguishable. The evaluator treats the second as
+ * a worst case and over-reports, which is the safe failure for a detector whose
+ * job is noticing omissions.
+ */
+interface EdgeCountVsPropertyCheck {
+    /** Discriminator, always `'edge_count_vs_property'` for this check type */
+    type: 'edge_count_vs_property';
+    /** The entity type whose nodes are evaluated one at a time. */
+    entity_type: UPGEntityType;
+    /** The edge type counted against each node of `entity_type`. */
+    edge_type: UPGEdgeType;
+    /**
+     * Which end of `edge_type` the evaluated node sits on. `inbound` (the
+     * default) counts edges that POINT AT the node, which is the occupancy
+     * reading: `feature_occupies_surface` runs feature → surface, so a surface's
+     * guest list is its inbound count.
+     */
+    direction?: 'inbound' | 'outbound';
+    /** The node's own numeric property the count is compared against. */
+    property: string;
+    /**
+     * What to compare against when the node does not carry `property` at all.
+     *
+     * ABSENCE IS A READING, NOT A HOLE. On `surface.capacity` absence means
+     * unbounded, and an unbounded surface is not thereby exempt: it has stated no
+     * limit, so it has stated no answer, and more than one occupant is exactly
+     * the situation worth naming. Setting this to `1` encodes that — an
+     * unqualified place holding two things has an unrecorded decision in it.
+     */
+    property_absent_default: number;
+    /**
+     * How a node's edge count must relate to the property value for that node to
+     * be counted. `gt` reads "more arrived than the design said would fit".
+     */
+    node_comparison: 'gt' | 'gte' | 'lt' | 'lte' | 'eq';
+    /**
+     * Optional additional per-node requirement: the node must carry
+     * (`present: true`) or must not carry (`present: false`) a value for
+     * `property`.
+     *
+     * PRESENT MEANS ANY VALUE, NOT ANY NON-EMPTY STRING. Only `undefined`,
+     * `null` and the empty string read as absent here. `capacity: 0` is a real
+     * cap (a reserved place nothing may occupy) and `mutates_content: false` is a
+     * real answer, so treating either as an omission would be wrong: this check
+     * form exists to read NUMERIC intents, and a form that could not see a
+     * declared zero would misread the surfaces it was built for.
+     *
+     * THIS DELIBERATELY DIFFERS FROM `EntityCheck.filter`'s presence form, which
+     * is string-only because the aggregate indexes behind it only hold strings.
+     * The asymmetry is a real difference in what the two can see, not a style
+     * choice, so this field does not borrow that vocabulary. Collectors express
+     * the split as two named predicates (`isPropertyPresent` here,
+     * `isStringPropertyPresent` there) rather than one helper with a comment.
+     *
+     * THIS IS ALSO WHY THE FORM IS PER-NODE RATHER THAN TWO ANDED AGGREGATES.
+     * "Some surface is over capacity" AND "some surface has no arbitration rule"
+     * are both true of a graph where those are DIFFERENT surfaces, so composing
+     * two aggregate checks would keep firing on exactly the graphs this release
+     * exists to stop firing on. Both halves have to be asked of the same node.
+     */
+    node_filter?: {
+        property: string;
+        present: boolean;
+    };
+    /**
+     * Optional exemption, mirroring the 0.28.0 `except_property` /
+     * `except_value` form on `EntityCheck`. A node declaring the exemption is
+     * removed from the evaluated population entirely — it is not counted, and it
+     * is not attributed.
+     */
+    except_property?: string;
+    /** Value of `except_property` that triggers the exemption. */
+    except_value?: string;
+    /** Aggregate comparison applied to the number of nodes that matched. */
+    comparison: 'eq' | 'gt' | 'lt' | 'gte' | 'lte' | 'zero' | 'nonzero';
+    /** Threshold value (not needed for 'zero' / 'nonzero') */
+    threshold?: number;
+}
 /**
  * A structured, machine-evaluable condition for intelligence prompts.
  *
@@ -20708,7 +21219,7 @@ interface OrphanCheck {
  * ] }
  */
 type IntelligenceCondition = {
-    check: EntityCheck | RelationshipCheck | BenchmarkCheck | TotalEntityCountCheck | DomainCountCheck | DomainPopulationCheck | OrphanCheck;
+    check: EntityCheck | RelationshipCheck | BenchmarkCheck | TotalEntityCountCheck | DomainCountCheck | DomainPopulationCheck | OrphanCheck | EdgeCountVsPropertyCheck;
 } | {
     operator: 'and' | 'or';
     checks: IntelligenceCondition[];
@@ -21782,14 +22293,21 @@ interface UPGPresenceExceptSpec {
  * indexes, because those record marginals and the question is an intersection.
  *
  * So the catalog declares what it needs and collectors compute exactly that
- * and no more. Today the list holds one entry (`surface.arbitration_rule`
- * except `composition_mode: 'chained'`); it stays correct without maintenance
- * because it is derived from the conditions themselves.
+ * and no more. It stays correct without maintenance because it is derived from
+ * the conditions themselves.
+ *
+ * EMPTY SINCE 0.29.0, AND THAT IS NOT A REGRESSION. Its one declarer was the
+ * arbitration branch of `contended-surface-without-arbitration`, which moved to
+ * the per-node `edge_count_vs_property` form because the aggregate could not
+ * ask "over capacity" and "no rule" of the SAME surface. The mechanism stays
+ * supported and tested: an except-qualified presence count is still the right
+ * instrument for a detector that needs an intersection of two marginals and no
+ * per-node arithmetic, and a future pattern declaring one gets it for free.
  *
  * @example
- * UPG_PRESENCE_EXCEPT_SPECS[0]
- * // → { entity_type: 'surface', property: 'arbitration_rule',
- * //     except_property: 'composition_mode', except_value: 'chained' }
+ * // The shape, as the 0.28.0 contention branch declared it:
+ * // { entity_type: 'surface', property: 'arbitration_rule',
+ * //   except_property: 'composition_mode', except_value: 'chained' }
  */
 declare const UPG_PRESENCE_EXCEPT_SPECS: readonly UPGPresenceExceptSpec[];
 /**
@@ -21802,6 +22320,148 @@ declare const UPG_PRESENCE_EXCEPT_SPECS: readonly UPGPresenceExceptSpec[];
  * // → "arbitration_rule!composition_mode=chained"
  */
 declare function presenceExceptKey(property: string, exceptProperty: string, exceptValue: string): string;
+/**
+ * One `edge_count_vs_property` check declared somewhere in
+ * `UPG_ANTI_PATTERNS`, flattened for collectors (0.29.0).
+ *
+ * @see UPG_EDGE_COUNT_SPECS
+ */
+interface UPGEdgeCountSpec {
+    /** Entity type whose nodes are evaluated one at a time. */
+    entity_type: string;
+    /** Edge type counted against each node. */
+    edge_type: string;
+    /** Which end of the edge the evaluated node sits on. */
+    direction: 'inbound' | 'outbound';
+    /** The node's own numeric property the count is compared against. */
+    property: string;
+    /** Value used when the node does not carry `property` at all. */
+    property_absent_default: number;
+    /** How the count must relate to the property for the node to match. */
+    node_comparison: 'gt' | 'gte' | 'lt' | 'lte' | 'eq';
+    /** Optional extra per-node presence requirement. */
+    node_filter?: {
+        property: string;
+        present: boolean;
+    };
+    /** Property that removes a node from the evaluated population. */
+    except_property?: string;
+    /** Value of `except_property` that triggers the exclusion. */
+    except_value?: string;
+}
+/**
+ * Canonical key for one edge-count spec, shared by the collectors that build
+ * `nodesByEdgeCountSpec` and the evaluator that reads it. Both sides must
+ * agree, so neither spells it inline.
+ *
+ * Every discriminating field is in the key. Two detectors asking about the same
+ * edge and property but with different thresholds, filters or exemptions are
+ * different questions and must not collide on one tally.
+ *
+ * @example
+ * edgeCountSpecKey({ entity_type: 'surface', edge_type: 'feature_occupies_surface',
+ *   direction: 'inbound', property: 'capacity', property_absent_default: 1,
+ *   node_comparison: 'gt', node_filter: { property: 'arbitration_rule', present: false },
+ *   except_property: 'composition_mode', except_value: 'chained' })
+ * // → "surface|feature_occupies_surface|inbound|capacity|1|gt|arbitration_rule=absent|composition_mode=chained"
+ */
+declare function edgeCountSpecKey(spec: UPGEdgeCountSpec): string;
+/**
+ * Canonical key for one `entity_count` filter, shared by the collectors that
+ * build `nodesByEntityFilter` and the evaluator that reads it (0.29.0).
+ *
+ * Covers all four filter forms in `EntityCheck.filter`. The key encodes the
+ * filter as the detector wrote it, so a `present: false` filter and a
+ * `present: true` filter over the same property are different keys holding
+ * different node sets, and neither has to be derived from the other by
+ * subtraction.
+ *
+ * @example
+ * entityFilterKey('surface', { property: 'arbitration_state', value: 'none' })
+ * // → "surface|arbitration_state=none"
+ * entityFilterKey('hypothesis', { status: 'drafted' })
+ * // → "hypothesis|status=drafted"
+ */
+declare function entityFilterKey(entityType: string, filter: Record<string, unknown>): string;
+/**
+ * Which of the recognised `EntityCheck.filter` shapes this is.
+ *
+ * The presence form deliberately does NOT branch on `except_property` /
+ * `except_value`. Those belong to the aggregate
+ * `countsByTypeAndPropertyPresenceExcept` mechanism, which is still supported
+ * for counting; ATTRIBUTION for that shape has no declarer, no collector path
+ * and no test, and shipping an unexercised parallel path is how the next drift
+ * starts. When a detector declares one, its attribution lands with it and with
+ * a test. Until then such a filter classifies as `presence` and is attributed
+ * on the presence predicate alone, which is a superset and therefore never
+ * names a node the detector did not implicate.
+ */
+declare function classifyEntityFilter(filter: Record<string, unknown>): 'presence' | 'value' | 'status' | 'unrecognized';
+/**
+ * One `entity_count` filter declared somewhere in `UPG_ANTI_PATTERNS`,
+ * flattened for collectors (0.29.0). Attribution only: the counts these
+ * filters drive are unchanged and still read the aggregate tallies.
+ *
+ * @see UPG_ENTITY_FILTER_SPECS
+ */
+interface UPGEntityFilterSpec {
+    /** Entity type the filter is applied to. */
+    entity_type: string;
+    /** The filter exactly as the detector declared it. */
+    filter: Record<string, unknown>;
+    /**
+     * Which recognised shape this filter is, resolved once at derivation.
+     *
+     * Carrying it means a collector switches exhaustively on a closed set rather
+     * than re-sniffing the shape and quietly skipping anything it was not taught.
+     * A silent skip there produces a forever-empty match list: attribution dies
+     * with no error and no failing test, which is the worst possible failure for
+     * a feature whose whole job is to name things.
+     */
+    kind: 'presence' | 'value' | 'status';
+}
+/**
+ * Every `entity_count` filter the catalog declares (0.29.0), so collectors can
+ * record which nodes matched each one without indexing the whole graph.
+ *
+ * The catalog declares FOUR filters in total (one status form, three value
+ * forms), which is what makes per-node attribution affordable here: a handful
+ * of predicate evaluations per node, rather than an id list for every (type,
+ * property, value) triple that happens to exist in the data.
+ *
+ * Note there is no `present` form among them since 0.29.0, when the contention
+ * branch moved to `EdgeCountVsPropertyCheck`. The only `present: false` left in
+ * the catalog is that check's `node_filter`, which this walk correctly does not
+ * collect: it is a per-node clause on a different check type, tallied through
+ * `UPG_EDGE_COUNT_SPECS` instead. The count is asserted in the tests rather
+ * than trusted to this comment.
+ */
+declare const UPG_ENTITY_FILTER_SPECS: readonly UPGEntityFilterSpec[];
+/**
+ * Normalise one `edge_count_vs_property` check into its spec.
+ *
+ * THE ONLY PLACE THIS SHAPE IS CONSTRUCTED. The spec has nine fields and every
+ * one of them is keyed into `edgeCountSpecKey`, so a second construction site
+ * that forgot to apply the `direction` default (or added a field) would produce
+ * a key that silently misses the collector's entry, and the check would read as
+ * "no node matched" rather than failing. Collector, evaluator and attribution
+ * all route through here.
+ */
+declare function checkToEdgeCountSpec(check: EdgeCountVsPropertyCheck): UPGEdgeCountSpec;
+/**
+ * Every per-node edge-count check the catalog declares (0.29.0).
+ *
+ * Same contract as `UPG_PRESENCE_EXCEPT_SPECS`: the catalog states what it
+ * needs, collectors compute exactly that and nothing more. Indexing every
+ * (type, edge type, property) triple speculatively would tax every
+ * `validate_graph` call to serve one detector, and unlike the aggregate counts
+ * these tallies cannot be derived from each other.
+ *
+ * Today the list holds one entry (surface occupancy against `capacity`), and it
+ * stays correct without maintenance because it is derived from the conditions
+ * themselves.
+ */
+declare const UPG_EDGE_COUNT_SPECS: readonly UPGEdgeCountSpec[];
 /**
  * Look up a curated anti-pattern by its slug id.
  *
@@ -21924,7 +22584,7 @@ declare function isThinCoverageAdvisory(antiPatternId: string, totalEntityCount:
  * Walks `UPG_ANTI_PATTERNS`, evaluates each `structured_condition` against
  * `AntiPatternInputs`, returns the violations.
  *
- * Synchronous. Collectors live per server (`packages/upg-mcp-server/src/lib/anti-pattern-inputs.ts`).
+ * Synchronous. Collectors live outside this package (`packages/upg-sdk/src/lib/anti-pattern-inputs.ts`).
  * Covers every leaf check type in `IntelligenceCondition`; composes recursively.
  *
  * https://unifiedproductgraph.org | MIT
@@ -21990,6 +22650,37 @@ interface AntiPatternInputs {
      * direction for a check whose job is to notice omissions.
      */
     countsByTypeAndPropertyPresenceExcept?: Record<string, Record<string, number>>;
+    /**
+     * Node ids matching each declared per-node edge-count check (0.29.0). Shape:
+     * `edgeCountSpecKey(spec)` → the ids of the nodes that matched.
+     *
+     * The COUNT is the array length, so this input carries both halves of the
+     * check: what fired, and which nodes it fired about. Collectors build it by
+     * walking `UPG_EDGE_COUNT_SPECS`, never speculatively.
+     *
+     * A SEEDED-BUT-EMPTY entry and a MISSING entry mean different things, and
+     * collectors must keep them distinct. Empty means "nothing matched" and the
+     * check clears. Missing means "this collector predates the spec", and the
+     * evaluator falls back to assuming every node of the type matched, preserving
+     * the 0.28.0 property that a stale collector over-reports rather than
+     * silently retiring the detector. Attribution stays empty on that path: a
+     * fabricated node id is worse than an unattributed violation.
+     */
+    nodesByEdgeCountSpec?: Record<string, string[]>;
+    /**
+     * Node ids matching each declared `entity_count` filter (0.29.0), for
+     * ATTRIBUTION ONLY. Shape: `entityFilterKey(entity_type, filter)` → ids.
+     *
+     * Counts are unaffected: every `entity_count` comparison still reads the
+     * aggregate tallies above, exactly as it did before this input existed. This
+     * runs alongside purely so a fired violation can name nodes, which means a
+     * collector that omits it loses attribution and changes no verdict.
+     *
+     * Bounded by declaration, like every other spec-driven input here: the whole
+     * catalog declares four filters, so this is a handful of predicate
+     * evaluations per node rather than an index over every property.
+     */
+    nodesByEntityFilter?: Record<string, string[]>;
     /**
      * Boolean presence per `(source_type, edge_type, target_type)` tuple.
      * Key format: `${source_type}|${edge_type}|${target_type}`.
@@ -22036,6 +22727,32 @@ interface AntiPatternViolation {
     concern: UPGAntiPatternConcern;
     /** Entity-type strings the catalog references. Phase 1: types, not ids. */
     target_entities: string[];
+    /**
+     * The specific nodes this violation is about (0.29.0), where the fired
+     * condition could name them. Sorted, deduplicated, and drawn only from the
+     * branches that actually contributed to the fire.
+     *
+     * ABSENT MEANS "THIS DETECTOR CANNOT NAME NODES", NOT "NO NODES". Most
+     * patterns here are whole-graph approximations of per-node rules: they
+     * compare aggregate tallies against constants, so they can say a graph has a
+     * problem without knowing where it lives. Only checks that evaluate nodes one
+     * at a time attribute, plus the declared `entity_count` filters.
+     *
+     * ATTRIBUTION IS PARTIAL, AND PARTIAL PER TYPE. A violation may name nodes of
+     * one type while saying nothing about another type in `target_entities`: the
+     * contention detector names surfaces and never the features occupying them,
+     * though both types appear there. So a consumer must NOT read a non-empty
+     * list as "these are the only implicated entities".
+     *
+     * The contract for a reverse lookup is: this list is authoritative for the
+     * types it actually covers, and silent about every other type, which must
+     * keep resolving through `target_entities`. Reading it as globally
+     * authoritative makes entities of the uncovered types unreachable, which is
+     * a reachability regression dressed up as precision.
+     *
+     * Optional so every existing consumer keeps compiling and behaving as before.
+     */
+    target_node_ids?: string[];
     description: string;
     why_it_matters: string;
     remediation: string;
@@ -22062,6 +22779,16 @@ interface EvaluateAntiPatternsOptions {
  *   })
  */
 declare function evaluateAntiPatterns(inputs: AntiPatternInputs, options?: EvaluateAntiPatternsOptions): AntiPatternViolation[];
+/**
+ * Walk the condition and return the unique entity-type strings it references.
+ *
+ * This is what fills `target_entities`, so it is the type half of every
+ * consumer's reachability. A check form missing from the walk produces a
+ * violation nothing can find by type, which is why the walk is exported: it is
+ * testable in isolation, against conditions built to defeat the masking that
+ * hides an omission inside a real multi-check pattern.
+ */
+declare function collectTargetEntities(cond: IntelligenceCondition | undefined): string[];
 
 /**
  * `UPGProductStage` validation and soft-coercion.
@@ -23264,7 +23991,7 @@ declare function checkHeaderSealText(text: string): UPGHeaderSealReport;
  * it stamps the `upg_version` field of every `.upg` file written by the SDK.
  * The `check:version-lockstep` gate enforces this at release time.
  */
-declare const UPG_VERSION: "0.28.0";
+declare const UPG_VERSION: "0.30.0";
 /**
  * The `.upg` JSON document format version. Written to the `upg_version` field.
  * Evolves independently from `UPG_VERSION` (the catalogue version).
@@ -23389,4 +24116,4 @@ declare const UPG_EDGE_COUNT: number;
  */
 declare const UPG_META_COUNT: number;
 
-export { type A11yAnnotationProperties, type A11yAuditProperties, type A11yGuidelineProperties, type A11yIssueProperties, type A11yStandardProperties, ANALYTICS_DATA_PLAYBOOK, type AcceptanceCriterionProperties, type AccessPolicyProperties, type AccountProperties, type AcquisitionChannelProperties, type AdCreativeProperties, type AffinityClusterProperties, type AgentDefinitionProperties, type AgentHookProperties, type AgentSessionProperties, type AgentSkillProperties, type AgentTaskProperties, type AggregateProperties, type AiCostTrackerProperties, type AiDatasetProperties, type AiExperimentProperties, type AiGuardrailProperties, type AiModelProperties, type AiTraceProperties, type AlertRuleProperties, type AnnotationProperties, type AntiPatternInputs, type AntiPatternViolation, type AnyUPGEntityType, type ApiContractProperties, type ApiEcosystemProperties, type ApiEndpointProperties, type ApproachBinding, type ApproachFilter, type ApproachRun, type ApproachRuntime, type ApprovalRecordProperties, type AssumptionProperties, type AttributionModelProperties, type AuditLogPolicyProperties, BUSINESS_GROWTH_METRIC_DRIVEN_PLAYBOOK, BUSINESS_GTM_GROWTH_PLAYBOOK, BUSINESS_MARKETING_AUDIENCE_FIRST_PLAYBOOK, type BehavioralSegmentProperties, type BenchmarkCheck, type BetaProgramProperties, type BoundedContextProperties, type BrandAssetProperties, type BrandColourProperties, type BrandIdentityProperties, type BrandImageryProperties, type BrandLogoProperties, type BrandTypographyProperties, type BrandVoiceProperties, type BugProperties, type BuildArtifactProperties, type BusinessModelProperties, CLASSIFICATION_EDGE_PROPERTY_SCHEMA, CONTENT_DEPTH_WARNING_RULES, COVERAGE_ANTI_PATTERNS, type Cadence, type CapabilityProperties, type CapacityPlanProperties, type CauseConfidence, type CeremonyProperties, type CertificationProperties, type ChangeRequestProperties, type ChangelogProperties, type ChurnReasonProperties, type CiPipelineProperties, type ClassificationAxisProperties, type ClassificationCapability, type ClassificationCapabilitySurface, type ClassificationCommitment, type ClassificationValueProperties, type CodeRepositoryProperties, type CohortProperties, type ComfortLevel, type CommandProperties, type CommunityInitiativeProperties, type CompetitiveAnalysisProperties, type CompetitiveBattleCardProperties, type CompetitorFeatureProperties, type CompetitorProperties, type CompetitorSignalProperties, type ComplianceFrameworkProperties, type ComplianceRequirementProperties, type Confidence, type ConformanceLevel, type ConstraintKind, type ConstraintOrigin, type ConstraintProperties, type ConstraintStatus, type ContactProperties, type ContentCalendarProperties, type ContentPieceProperties, type ContentStrategyProperties, type ContentThemeProperties, type ContractClauseProperties, type ContractProperties, type CostStructureProperties, type CountBenchmark, type Cron, type CrossProductEligibleEdgeType, type CrossProductScope, type CulturalAdaptationProperties, type CustomerFeedbackProperties, type CustomerHealthScoreProperties, type CustomerJourneyStageProperties, type CustomerRelationshipProperties, DEFAULT_ENTITY_EMOJI, DEFERRED_PROPOSED_BY_CONTRACT, DEFER_EDGE_PROPERTY_SCHEMA, DISCOVERY_RESEARCH_VALIDATION_PLAYBOOK, type DashboardProperties, type DataClassificationProperties, type DataContractProperties, type DataDomainProperties, type DataFlowProperties, type DataLineageProperties, type DataModelProperties, type DataPipelineProperties, type DataProductProperties, type DataQualityRuleProperties, type DataSensitivity, type DataSourceProperties, type DatabaseSchemaProperties, type DealProperties, type DecisionProperties, type DeliberateOnlyEdgeType, type DeliverableProperties, type DemandGenProgramProperties, type DepartmentProperties, type DependencyProperties, type DeploymentProperties, type DeprecatedUPGEntityType, type DesignComponentProperties, type DesignConceptProperties, type DesignGuidelineProperties, type DesignPatternProperties, type DesignQuestionProperties, type DesignSprintProperties, type DesignSystemProperties, type DesignTokenProperties, type DesiredOutcomeProperties, type DeveloperPortalProperties, type DifficultyLevel, type DiscountStrategyProperties, type DistributionChannelProperties, type DocumentProperties, type DocumentationTemplateProperties, type DomainActivation, type DomainCountCheck, type DomainEntityProperties, type DomainEventProperties, type DomainGuideStep, type DomainPopulationCheck, type Duration, ENGINEERING_PLATFORM_PLAYBOOK, ENTITY_EMOJI, EXPERIENCE_DESIGN_BRAND_PLAYBOOK, type EducationProgramProperties, type EmailSequenceProperties, type EmptyCell, type EmptyCellRationaleKind, type EntityCheck, type EntitySequenceStep, type EntityTypeMeta, type EntityTypeResolution, type EntryMode, type EpicProperties, type ErrorBudgetProperties, type EvalBenchmarkProperties, type EvalRunProperties, type EvaluateAntiPatternsOptions, type EventProperties, type EventSchemaProperties, type EvidenceDirection, type EvidenceProperties, type ExperimentPlanProperties, type ExperimentProperties, type ExperimentRunProperties, type ExternalApiProperties, FOUNDATIONS_PLAYBOOK, type FeasibilityStudyProperties, type FeatureAreaProperties, type FeatureFlagProperties, type FeatureProperties, type FeatureRequestProperties, type FeedbackProgramProperties, type FeedbackThemeProperties, type FeedbackVoteProperties, type FixProperties, type ForecastProperties, type FrameworkCategory, type FrameworkComputedProperty, type FrameworkConstant, type FrameworkDataSpec, type FrameworkEducation, type FrameworkEntityTypeSpec, type FrameworkExerciseProperties, type FrameworkInvocationStep, type FrameworkLayout, type FrameworkLevel, type FrameworkOrigin, type FrameworkPresentationSpec, type FrameworkPropertyRequirement, type FrameworkScoringMethod, type FrameworkSlot, type FrameworkStep, type FrameworkStructureSpec, type FrameworkValidationResult, type FrequencyRating, type FunnelProperties, type FunnelStage, type FunnelStepProperties, type GlossaryTermProperties, type GrowthCampaignProperties, type GrowthLoopProperties, type GtmStrategyProperties, type GuardrailStatus, type HallucinationReportProperties, type HealthStatus, type HelpVideoProperties, type HypothesisEvidenceProperties, type HypothesisProperties, type ISO4217, type ISODate, type ISODateTime, type IdealCustomerProfileProperties, type IncidentProperties, type IncidentSeverity, type InfrastructureComponentProperties, type InitiativeProperties, type InsightProperties, type IntegrationPartnerProperties, type IntegrationPatternProperties, type IntelligenceCondition, type InteractionSpecProperties, type InternalDocProperties, type InterviewGuideProperties, type InvestigationProperties, type InvoiceProperties, type IpAssetProperties, type JobProperties, type JobStepProperties, type JourneyActionProperties, type JourneyPhaseProperties, type JourneyStepProperties, type JourneyType, type KeyActivityProperties, type KeyResourceProperties, type KeyResultProperties, type KnowledgeBaseArticleProperties, LEGACY_PRODUCT_STAGES, type LaunchProperties, type LeadProperties, type LearningPathProperties, type LearningProperties, type LegalEntityProperties, type LibraryDependencyProperties, type LifecyclePhase, type LifecycleRenderShape, type LifecycleRenderState, type LifecycleRenderTransition, type LifecycleState, type LocaleConfigProperties, type LocaleProperties, type LogLevel, type LowMedHigh, MARKDOWN_FORMAT_VERSION, MARKET_COMPETITIVE_PLAYBOOK, type MarketSegmentProperties, type MarketTrendProperties, type MarketingCampaignPlanProperties, type MarketingChannelProperties, type MarketingPlatform, type MarketingStrategyProperties, type MarketplaceListingProperties, type MatrixSlot, type MaturityLevel, type MessagingProperties, type MetricCategory, type MetricDataPoint, type MetricDesignation, type MetricHealth, type MetricImpactLevel, type MetricIndicatorDirection, type MetricProperties, type MetricQualityAssessmentProperties, type MetricSegmentType, type MetricStatisticalFunction, type MilestoneProperties, type MissionProperties, type ModelComparisonProperties, type ModifiedProperty, type MonitorProperties, type NamedGroup, type NeedMaturity, type NeedProperties, type NeedValence, type NpsCampaignProperties, OPERATIONS_QUALITY_PLAYBOOK, type ObjectionProperties, type ObjectiveProperties, type ObservationProperties, type OnCallRotationProperties, type OperatingLifecycleProperties, type OperatingStageProperties, type OpportunityProperties, type OrganizationProperties, type OrphanCheck, type OutcomeProperties, PRODUCT_DELIVERY_PLAYBOOK, PROPERTY_MODIFIERS, PROPERTY_MODIFIER_SEMANTICS, PROPERTY_SCALE_MAP, type ParticipantProperties, type PartnerProgramProperties, type PartnerRevenueShareProperties, type PartnerTierProperties, type PartnershipProperties, type PaywallProperties, type PenetrationTestProperties, type PersonProperties, type PersonaProperties, type PipelineSalesProperties, type PipelineStageProperties, type PlanningCycleProperties, type PlaybookBinding, type PlaybookFilter, type PlaybookProperties, type PlaybookRun, type PlaybookRuntime, type PortfolioProperties, type PositioningProperties, type PostmortemProperties, type PressReleaseProperties, type PricingStrategyProperties, type PricingTierProperties, type PrimitiveProperties, type Priority, type PrivacyPolicyProperties, type ProductAreaProperties, type ProductProperties, type ProductStageCoercion, type ProgramProperties, type ProjectProperties, type PromptTemplateProperties, type PromptVersionProperties, type ProofPointProperties, type PropertyDefinition, type PropertyModifier, type PropertySchema, type Protocol, type PrototypeProperties, type ProxyConfidence, type ProxyReason, type QaSessionProperties, type QueueTopicProperties, type QuoteDocumentProperties, type QuoteProperties, RECORD_ENTITY_TYPES, REFLECT_MODES, REGISTRY_PRODUCT_ID, type RatioBenchmark, type ReadModelProperties, type RebuttalProperties, type ReflectMode, type RegionalPricingProperties, type RegressionTestProperties, type RelationshipBenchmark, type RelationshipCheck, type ReleaseProperties, type ReleaseStrategyProperties, type ReportProperties, type ResearchPlanProperties, type ResearchQuestionProperties, type ResearchStudyProperties, type ResourceAllocationProperties, type RetrospectiveProperties, type RevenueStreamProperties, type ReviewGateProperties, type RiskProperties, type RiskRegisterProperties, type RoadmapItemProperties, type RoadmapProperties, type RoadmapThemeProperties, type RoleProperties, type RootCauseProperties, type RuleStrength, type RunContext, type RunbookProperties, STRATEGY_OUTCOMES_PLAYBOOK, type SalesMotionProperties, type ScreenProperties, type ScreenStateProperties, type SecurityAuditProperties, type SecurityControlProperties, type SecurityPolicyProperties, type SecurityReviewProperties, type Semver, type SeoKeywordProperties, type SerializeOptions, type ServiceBlueprintProperties, type ServiceLevelAgreementProperties, type ServiceLevelIndicatorProperties, type ServiceLevelObjectiveProperties, type ServiceProperties, type SignalChannel, type SignalSentiment, type SignalUrgency, type SkillProperties, type SocialPostProperties, type SolutionProperties, type SpecificationProperties, type StageRange, type StakeholderProperties, type StatusCategory, type StatusReportProperties, type Step, type StepKind, type StepOutput, type StepOutputKind, type StoryTaskProperties, type StrategicPillarProperties, type StrategicQuestionProperties, type StrategicThemeProperties, type StructurePattern, type SubSequenceStep, type SubscriptionProperties, type SuccessMilestoneProperties, type SupportTicketProperties, type SurfaceArbitrationState, type SurfaceCardinality, type SurfaceCompositionMode, type SurfaceExtensibility, type SurfaceId, type SurfaceInstanceScope, type SurfaceKind, type SurfacePersistence, type SurfaceProperties, type SurveyResponseProperties, type SwitchingCostProperties, type SymptomProperties, THIN_GRAPH_THRESHOLD, type TableColumn, type TargetCustomerSegmentProperties, type TaskProperties, type TeamOkrProperties, type TeamProperties, type TechnicalDebtItemProperties, type TerritoryProperties, type TestCaseProperties, type TestCoverageReportProperties, type TestEnvironmentProperties, type TestPlanProperties, type TestResultProperties, type TestSuiteProperties, type ThreatModelProperties, type ThreatProperties, type Timeframe, type TotalEntityCountCheck, type TouchpointProperties, type TranslationBundleProperties, type TranslationKeyProperties, type TrialConfigProperties, type TutorialProperties, type UPGAnchorEntity, type UPGAntiPattern, type UPGAntiPatternConcern, type UPGAntiPatternSeverity, type UPGApproach, type UPGApproachEnvelope, type UPGApproachId, type UPGAreaTaxonomyEntry, type UPGAssessment, type UPGBaseNode, type UPGBenchmarkSource, type UPGBoundaryDirection, type UPGBoundaryEdge, type UPGCrossEdge, type UPGCrossEdgeType, type UPGCrossOnlyEdgeType, type UPGCuratedAntiPattern, type UPGDocument, type UPGDomain, type UPGDomainBridge, type UPGDomainId, type UPGDomainPattern, type UPGDomainRing, type UPGDomainUsageGuide, type UPGEdge, type UPGEdgeDefinition, type UPGEdgeMigration, type UPGEdgeMigrationEndpoints, type UPGEdgePickHint, type UPGEdgeType, type UPGEntityType, type UPGEntityTypeMaturity, type UPGEnumScaleDefinition, type UPGEnumScaleValue, type UPGFramework, type UPGFrameworkMeta, type UPGHeader, type UPGHeaderCountsMismatch, type UPGHeaderIntegrity, type UPGHeaderIntegrityMismatch, type UPGHeaderProvenance, type UPGHeaderSealReport, type UPGIntegrity, type UPGLens, type UPGLensIntelligencePrompt, type UPGLifecycle, type UPGMappingConfidence, type UPGMemberKindKey, type UPGNode, type UPGOrganization, type UPGPlaybook, type UPGPortfolio, type UPGPortfolioDocument, type UPGPortfolioKind, type UPGPresenceExceptSpec, type UPGProduct, type UPGProductArea, type UPGProductStage, type UPGPropertyMap, type UPGPropertyMigration, type UPGPropertyMigrationChange, type UPGRegion, type UPGRegionEntityMembership, type UPGRegionEntityRole, type UPGRegionId, type UPGRegionShape, type UPGRegistry, type UPGScalarToEdgeMigration, type UPGScaleDefinition, type UPGScalePoint, type UPGSource, type UPGSplitEdge, type UPGSplitMigration, type UPGSplitRoute, type UPGSplitRouteTarget, type UPGSplitTarget, type UPGTreeChild, type UPGTreeGapPolicy, type UPGTreePattern, type UPGTreePatternDetail, type UPGTreePatternEdge, type UPGTreePatternSummary, type UPGTypeLabel, type UPGTypeMigration, type UPGValidationError, type UPGValidationProfile, type UPGValidationResult, type UPGValidationWarning, type UPGWildcardEndpoint, UPG_ACTIVE_TYPES, UPG_ANTI_PATTERNS, UPG_ANTI_PATTERN_CONCERNS, UPG_APPROACHES, UPG_APPROACHES_BY_ID, UPG_AREA_TAXONOMY, UPG_AREA_TAXONOMY_BY_COVERAGE_KEY, UPG_CANONICAL_FORMAT_VERSION, UPG_CONTAINMENT_FREE_TYPES, UPG_COUNT_BENCHMARKS, UPG_CROSS_EDGE_TYPES, UPG_CROSS_ELIGIBLE_CATALOG_EDGE_TYPES, UPG_CROSS_ONLY_EDGE_TYPES, UPG_DELIBERATE_ONLY_EDGE_TYPES, UPG_DEPRECATED_TYPES, UPG_DOMAINS, UPG_DOMAIN_ACTIVATION, UPG_DOMAIN_COUNT, UPG_DOMAIN_GUIDES, UPG_DOMAIN_RINGS, UPG_EDGE_CATALOG, UPG_EDGE_COUNT, UPG_EDGE_MIGRATIONS, UPG_EDGE_PAIR_MAP, UPG_EDGE_TYPES, UPG_ENTITY_COUNT, UPG_ENTITY_META, UPG_ENTITY_META_BY_ID, UPG_ENTITY_META_BY_NAME, UPG_ENTITY_TO_DOMAIN, UPG_ENUM_SCALES, UPG_FORMAT_VERSION, UPG_FRAMEWORKS, UPG_FRAMEWORKS_BY_CATEGORY, UPG_FRAMEWORKS_BY_ID, UPG_FRAMEWORK_CATEGORIES, UPG_LENSES, UPG_LIFECYCLES, UPG_LIFECYCLE_FREE_TYPES, UPG_LIFECYCLE_PLANNED_TYPES, UPG_META_COUNT, UPG_MIGRATIONS, UPG_PLAYBOOKS, UPG_POLYMORPHIC_EDGE_KEYS, UPG_PORTFOLIO_KINDS, UPG_PORTFOLIO_SHARED_TYPES, UPG_PRESENCE_EXCEPT_SPECS, UPG_PRODUCT_STAGES, UPG_PRODUCT_STAGE_COERCION_MAP, UPG_PROPERTY_MIGRATIONS, UPG_PROPERTY_SCHEMA, UPG_RATIO_BENCHMARKS, UPG_REGIONS, UPG_REGION_COUNT, UPG_REGION_MAP, UPG_RELATIONSHIP_BENCHMARKS, UPG_SCALAR_TO_EDGE_MIGRATIONS, UPG_SCALES, UPG_SPLIT_MIGRATIONS, UPG_STATUS_MIGRATIONS, UPG_STRUCTURE_PATTERNS, UPG_TREE_PATTERNS, UPG_TREE_PATTERNS_BY_ID, UPG_TYPES, UPG_TYPES_SET, UPG_TYPE_ALIASES, UPG_TYPE_LABELS, UPG_TYPE_LABELS_MAP, UPG_TYPE_NAMES, UPG_VALIDATION_PROFILES, UPG_VALID_CHILDREN, UPG_VERSION, UPG_WILDCARD_ENDPOINT, USERS_NEEDS_PLAYBOOK, type UnitEconomicsProperties, UnknownEntityTypeError, type UserAdvisoryBoardProperties, type UserFlowProperties, type UserJourneyProperties, type UserStoryProperties, type ValueObjectProperties, type ValuePropositionProperties, type ValueStreamProperties, type VariantProperties, type VisionProperties, type VulnerabilityProperties, type WalkMigrationChainResult, type WalkthroughProperties, type WebinarProperties, type WireframeProperties, type WorkflowArtifactProperties, type WorkflowRunProperties, type WorkflowTemplateProperties, type WorkspaceProperties, backfillSlug, buildTypeAliases, canBeChildOf, checkHeaderSeal, checkHeaderSealText, coerceProductStage, collectSlugsForType, compareVersions, computeBodyChecksum, concernEvaluatedFor, concernFor, concernGatesFor, crossProductScope, deriveCounts, derivePortfolioCounts, deriveSingleCounts, describeTreePattern, edgeCarriesProperties, evaluateAntiPatterns, findInvalidStatusMigrationTargets, formatUpgText, friendlyToAssessment, generateSlug, getAnchorEntity, getAntiPatternById, getAntiPatterns, getAntiPatternsBySeverity, getAntiPatternsForStage, getAreaTaxonomyEntry, getBenchmark, getBenchmarksByDomain, getBusinessAreasForRegion, getCanonicalPlaybookForRegion, getCoverageKeysForRegion, getDefaultLens, getDeprecatedTypes, getDomainForType, getDomainIdForType, getDomainsInRing, getEdgePropertySchema, getEntityModifierSummary, getEnumScale, getEnumValueMeta, getGuideForDomain, getLens, getLensIds, getLensPlaybook, getLensesForDomain, getLifecycleForType, getLifecycleRenderShape, getMigrationMap, getPlaybookById, getPlaybooksForRegion, getPropertiesForScale, getPropertyDefaultScale, getPropertyMigrations, getPropertyModifier, getPropertySchema, getRegion, getRegionForEntityType, getReplacementType, getRingForDomain, getScalarToEdgeMigrations, getScale, getSplitMigrations, getTreePattern, getTypeId, getTypeName, getTypes, getUPGEdgeMigrations, getValidChildren, getVisibleTypes, hasStatusMigration, isAggregateShapedProperty, isCanonical, isCanonicalProductStage, isContainmentFreeType, isCrossCapable, isCrossProductEligible, isCuratedCrossEligible, isDeliberateOnlyEdge, isDeprecatedType, isDomainGuideStep, isEntitySequenceStep, isFrameworkInvocationStep, isLegacyProductStage, isLifecycleFreeType, isLifecyclePlannedType, isPolymorphicEdge, isPortfolio, isPortfolioSharedType, isRecordEntity, isRegisteredPolymorphicEdge, isRuntimeStateShapedProperty, isSubSequenceStep, isThinCoverageAdvisory, isUPGDocument, listPropertiesByModifier, listStatusMigrations, listTreePatternSummaries, migrateEdge, migrateNode, migrateNodeProperties, migrateProductStage, migrateStatusValue, normalizeDocument, parseUpg, pickCanonicalEdge, presenceExceptKey, resolveAllEdges, resolveContainmentEdge, resolveEntityType, resolveLabel, resolveSlugCollision, resolveTreePatternEdges, ringOrderedDomainIds, rotateSlug, serializeCanonical, validateEdgeProperties, validateProductStageStrict, validateUPGDocument, validateUPGFramework, validationProfileFor, walkMigrationChainToCanonical };
+export { type A11yAnnotationProperties, type A11yAuditProperties, type A11yGuidelineProperties, type A11yIssueProperties, type A11yStandardProperties, ACTIVE_WHEN_PROPERTY, ANALYTICS_DATA_PLAYBOOK, type AcceptanceCriterionProperties, type AccessPolicyProperties, type AccountProperties, type AcquisitionChannelProperties, type AdCreativeProperties, type AffinityClusterProperties, type AgentDefinitionProperties, type AgentHookProperties, type AgentSessionProperties, type AgentSkillProperties, type AgentTaskProperties, type AggregateProperties, type AiCostTrackerProperties, type AiDatasetProperties, type AiExperimentProperties, type AiGuardrailProperties, type AiModelProperties, type AiTraceProperties, type AlertRuleProperties, type AnnotationProperties, type AntiPatternInputs, type AntiPatternViolation, type AnyUPGEntityType, type ApiContractProperties, type ApiEcosystemProperties, type ApiEndpointProperties, type ApproachBinding, type ApproachFilter, type ApproachRun, type ApproachRuntime, type ApprovalRecordProperties, type AssumptionProperties, type AttributionModelProperties, type AuditLogPolicyProperties, BUSINESS_GROWTH_METRIC_DRIVEN_PLAYBOOK, BUSINESS_GTM_GROWTH_PLAYBOOK, BUSINESS_MARKETING_AUDIENCE_FIRST_PLAYBOOK, type BehavioralSegmentProperties, type BenchmarkCheck, type BetaProgramProperties, type BoundedContextProperties, type BrandAssetProperties, type BrandColourProperties, type BrandIdentityProperties, type BrandImageryProperties, type BrandLogoProperties, type BrandTypographyProperties, type BrandVoiceProperties, type BugProperties, type BuildArtifactProperties, type BusinessModelProperties, CLASSIFICATION_EDGE_PROPERTY_SCHEMA, CONFIGURATION_QUALIFIER_EDGE_PROPERTY_SCHEMA, CONFIGURATION_VARIANCE_EDGE_PROPERTY_SCHEMA, CONTENT_DEPTH_WARNING_RULES, COVERAGE_ANTI_PATTERNS, type Cadence, type CapabilityProperties, type CapacityPlanProperties, type CauseConfidence, type CeremonyProperties, type CertificationProperties, type ChangeRequestProperties, type ChangelogProperties, type ChurnReasonProperties, type CiPipelineProperties, type ClassificationAxisProperties, type ClassificationCapability, type ClassificationCapabilitySurface, type ClassificationCommitment, type ClassificationValueProperties, type CodeRepositoryProperties, type CohortProperties, type ComfortLevel, type CommandProperties, type CommunityInitiativeProperties, type CompetitiveAnalysisProperties, type CompetitiveBattleCardProperties, type CompetitorFeatureProperties, type CompetitorProperties, type CompetitorSignalProperties, type ComplianceFrameworkProperties, type ComplianceRequirementProperties, type Confidence, type Configuration, type ConfigurationAxisKind, type ConfigurationAxisProperties, type ConfigurationDriftFinding, type ConfigurationDriftKind, type ConformanceLevel, type ConstraintKind, type ConstraintOrigin, type ConstraintProperties, type ConstraintStatus, type ContactProperties, type ContentCalendarProperties, type ContentPieceProperties, type ContentStrategyProperties, type ContentThemeProperties, type ContractClauseProperties, type ContractProperties, type CostStructureProperties, type CountBenchmark, type Cron, type CrossProductEligibleEdgeType, type CrossProductScope, type CulturalAdaptationProperties, type CustomerFeedbackProperties, type CustomerHealthScoreProperties, type CustomerJourneyStageProperties, type CustomerRelationshipProperties, DEFAULT_ENTITY_EMOJI, DEFERRED_PROPOSED_BY_CONTRACT, DEFER_EDGE_PROPERTY_SCHEMA, DISCOVERY_RESEARCH_VALIDATION_PLAYBOOK, type DashboardProperties, type DataClassificationProperties, type DataContractProperties, type DataDomainProperties, type DataFlowProperties, type DataLineageProperties, type DataModelProperties, type DataPipelineProperties, type DataProductProperties, type DataQualityRuleProperties, type DataSensitivity, type DataSourceProperties, type DatabaseSchemaProperties, type DealProperties, type DecisionProperties, type DeliberateOnlyEdgeType, type DeliverableProperties, type DemandGenProgramProperties, type DepartmentProperties, type DependencyProperties, type DeploymentProperties, type DeprecatedUPGEntityType, type DesignComponentProperties, type DesignConceptProperties, type DesignGuidelineProperties, type DesignPatternProperties, type DesignQuestionProperties, type DesignSprintProperties, type DesignSystemProperties, type DesignTokenProperties, type DesiredOutcomeProperties, type DeveloperPortalProperties, type DifficultyLevel, type DiscountStrategyProperties, type DistributionChannelProperties, type DocumentProperties, type DocumentationTemplateProperties, type DomainActivation, type DomainCountCheck, type DomainEntityProperties, type DomainEventProperties, type DomainGuideStep, type DomainPopulationCheck, type Duration, ENGINEERING_PLATFORM_PLAYBOOK, ENTITY_EMOJI, EXPERIENCE_DESIGN_BRAND_PLAYBOOK, type EdgeCountVsPropertyCheck, type EducationProgramProperties, type EmailSequenceProperties, type EmptyCell, type EmptyCellRationaleKind, type EntityCheck, type EntitySequenceStep, type EntityTypeMeta, type EntityTypeResolution, type EntryMode, type EpicProperties, type ErrorBudgetProperties, type EvalBenchmarkProperties, type EvalRunProperties, type EvaluateAntiPatternsOptions, type EventProperties, type EventSchemaProperties, type EvidenceDirection, type EvidenceProperties, type ExperimentPlanProperties, type ExperimentProperties, type ExperimentRunProperties, type ExternalApiProperties, FOUNDATIONS_PLAYBOOK, type FeasibilityStudyProperties, type FeatureAreaProperties, type FeatureFlagProperties, type FeatureProperties, type FeatureRequestProperties, type FeedbackProgramProperties, type FeedbackThemeProperties, type FeedbackVoteProperties, type FixProperties, type ForecastProperties, type FrameworkCategory, type FrameworkComputedProperty, type FrameworkConstant, type FrameworkDataSpec, type FrameworkEducation, type FrameworkEntityTypeSpec, type FrameworkExerciseProperties, type FrameworkInvocationStep, type FrameworkLayout, type FrameworkLevel, type FrameworkOrigin, type FrameworkPresentationSpec, type FrameworkPropertyRequirement, type FrameworkScoringMethod, type FrameworkSlot, type FrameworkStep, type FrameworkStructureSpec, type FrameworkValidationResult, type FrequencyRating, type FunnelProperties, type FunnelStage, type FunnelStepProperties, type GlossaryTermProperties, type GrowthCampaignProperties, type GrowthLoopProperties, type GtmStrategyProperties, type GuardrailStatus, type HallucinationReportProperties, type HealthStatus, type HelpVideoProperties, type HypothesisEvidenceProperties, type HypothesisProperties, type ISO4217, type ISODate, type ISODateTime, type IdealCustomerProfileProperties, type IncidentProperties, type IncidentSeverity, type InfrastructureComponentProperties, type InitiativeProperties, type InsightProperties, type IntegrationPartnerProperties, type IntegrationPatternProperties, type IntelligenceCondition, type InteractionSpecProperties, type InternalDocProperties, type InterviewGuideProperties, type InvestigationProperties, type InvoiceProperties, type IpAssetProperties, type JobProperties, type JobStepProperties, type JourneyActionProperties, type JourneyPhaseProperties, type JourneyStepProperties, type JourneyType, type KeyActivityProperties, type KeyResourceProperties, type KeyResultProperties, type KnowledgeBaseArticleProperties, LEGACY_PRODUCT_STAGES, type LaunchProperties, type LeadProperties, type LearningPathProperties, type LearningProperties, type LegalEntityProperties, type LibraryDependencyProperties, type LifecyclePhase, type LifecycleRenderShape, type LifecycleRenderState, type LifecycleRenderTransition, type LifecycleState, type LocaleConfigProperties, type LocaleProperties, type LogLevel, type LowMedHigh, MARKDOWN_FORMAT_VERSION, MARKET_COMPETITIVE_PLAYBOOK, type MarketSegmentProperties, type MarketTrendProperties, type MarketingCampaignPlanProperties, type MarketingChannelProperties, type MarketingPlatform, type MarketingStrategyProperties, type MarketplaceListingProperties, type MatrixSlot, type MaturityLevel, type MessagingProperties, type MetricCategory, type MetricDataPoint, type MetricDesignation, type MetricHealth, type MetricImpactLevel, type MetricIndicatorDirection, type MetricProperties, type MetricQualityAssessmentProperties, type MetricSegmentType, type MetricStatisticalFunction, type MilestoneProperties, type MissionProperties, type ModelComparisonProperties, type ModifiedProperty, type MonitorProperties, type NamedGroup, type NeedMaturity, type NeedProperties, type NeedValence, type NpsCampaignProperties, OPERATIONS_QUALITY_PLAYBOOK, type ObjectionProperties, type ObjectiveProperties, type ObservationProperties, type OnCallRotationProperties, type OperatingLifecycleProperties, type OperatingStageProperties, type OpportunityProperties, type OrganizationProperties, type OrphanCheck, type OutcomeProperties, PRESENT_UNDER_PROPERTY, PRODUCT_DELIVERY_PLAYBOOK, PROPERTY_MODIFIERS, PROPERTY_MODIFIER_SEMANTICS, PROPERTY_SCALE_MAP, type ParticipantProperties, type PartnerProgramProperties, type PartnerRevenueShareProperties, type PartnerTierProperties, type PartnershipProperties, type PaywallProperties, type PenetrationTestProperties, type PersonProperties, type PersonaProperties, type PipelineSalesProperties, type PipelineStageProperties, type PlanningCycleProperties, type PlaybookBinding, type PlaybookFilter, type PlaybookProperties, type PlaybookRun, type PlaybookRuntime, type PortfolioProperties, type PositioningProperties, type PostmortemProperties, type PressReleaseProperties, type PricingStrategyProperties, type PricingTierProperties, type PrimitiveProperties, type Priority, type PrivacyPolicyProperties, type ProductAreaProperties, type ProductProperties, type ProductStageCoercion, type ProgramProperties, type ProjectProperties, type ProjectableEdge, type ProjectableNode, type ProjectionResult, type PromptTemplateProperties, type PromptVersionProperties, type ProofPointProperties, type PropertyDefinition, type PropertyModifier, type PropertySchema, type Protocol, type PrototypeProperties, type ProxyConfidence, type ProxyReason, QUALIFIABLE_EDGE_TYPES, type QaSessionProperties, type QueueTopicProperties, type QuoteDocumentProperties, type QuoteProperties, RECORD_ENTITY_TYPES, REFLECT_MODES, REGISTRY_PRODUCT_ID, type RatioBenchmark, type ReadModelProperties, type RebuttalProperties, type ReflectMode, type RegionalPricingProperties, type RegressionTestProperties, type RelationshipBenchmark, type RelationshipCheck, type ReleaseProperties, type ReleaseStrategyProperties, type ReportProperties, type ResearchPlanProperties, type ResearchQuestionProperties, type ResearchStudyProperties, type ResourceAllocationProperties, type RetrospectiveProperties, type RevenueStreamProperties, type ReviewGateProperties, type RiskProperties, type RiskRegisterProperties, type RoadmapItemProperties, type RoadmapProperties, type RoadmapThemeProperties, type RoleProperties, type RootCauseProperties, type RuleStrength, type RunContext, type RunbookProperties, STRATEGY_OUTCOMES_PLAYBOOK, type SalesMotionProperties, type ScreenProperties, type ScreenStateProperties, type SecurityAuditProperties, type SecurityControlProperties, type SecurityPolicyProperties, type SecurityReviewProperties, type Semver, type SeoKeywordProperties, type SerializeOptions, type ServiceBlueprintProperties, type ServiceLevelAgreementProperties, type ServiceLevelIndicatorProperties, type ServiceLevelObjectiveProperties, type ServiceProperties, type SignalChannel, type SignalSentiment, type SignalUrgency, type SkillProperties, type SocialPostProperties, type SolutionProperties, type SpecificationProperties, type StageRange, type StakeholderProperties, type StatusCategory, type StatusReportProperties, type Step, type StepKind, type StepOutput, type StepOutputKind, type StoryTaskProperties, type StrategicPillarProperties, type StrategicQuestionProperties, type StrategicThemeProperties, type StructurePattern, type SubSequenceStep, type SubscriptionProperties, type SuccessMilestoneProperties, type SupportTicketProperties, type SurfaceArbitrationState, type SurfaceCardinality, type SurfaceCompositionMode, type SurfaceExtensibility, type SurfaceId, type SurfaceInstanceScope, type SurfaceKind, type SurfacePersistence, type SurfaceProperties, type SurveyResponseProperties, type SwitchingCostProperties, type SymptomProperties, THIN_GRAPH_THRESHOLD, type TableColumn, type TargetCustomerSegmentProperties, type TaskProperties, type TeamOkrProperties, type TeamProperties, type TechnicalDebtItemProperties, type TerritoryProperties, type TestCaseProperties, type TestCoverageReportProperties, type TestEnvironmentProperties, type TestPlanProperties, type TestResultProperties, type TestSuiteProperties, type ThreatModelProperties, type ThreatProperties, type Timeframe, type TotalEntityCountCheck, type TouchpointProperties, type TranslationBundleProperties, type TranslationKeyProperties, type TrialConfigProperties, type TutorialProperties, type UPGAnchorEntity, type UPGAntiPattern, type UPGAntiPatternConcern, type UPGAntiPatternSeverity, type UPGApproach, type UPGApproachEnvelope, type UPGApproachId, type UPGAreaTaxonomyEntry, type UPGAssessment, type UPGBaseNode, type UPGBenchmarkSource, type UPGBoundaryDirection, type UPGBoundaryEdge, type UPGCrossEdge, type UPGCrossEdgeType, type UPGCrossOnlyEdgeType, type UPGCuratedAntiPattern, type UPGDocument, type UPGDomain, type UPGDomainBridge, type UPGDomainId, type UPGDomainPattern, type UPGDomainRing, type UPGDomainUsageGuide, type UPGEdge, type UPGEdgeCountSpec, type UPGEdgeDefinition, type UPGEdgeMigration, type UPGEdgeMigrationEndpoints, type UPGEdgePickHint, type UPGEdgeType, type UPGEntityFilterSpec, type UPGEntityType, type UPGEntityTypeMaturity, type UPGEnumScaleDefinition, type UPGEnumScaleValue, type UPGFramework, type UPGFrameworkMeta, type UPGHeader, type UPGHeaderCountsMismatch, type UPGHeaderIntegrity, type UPGHeaderIntegrityMismatch, type UPGHeaderProvenance, type UPGHeaderSealReport, type UPGIntegrity, type UPGLens, type UPGLensIntelligencePrompt, type UPGLifecycle, type UPGMappingConfidence, type UPGMemberKindKey, type UPGNode, type UPGOrganization, type UPGPlaybook, type UPGPortfolio, type UPGPortfolioDocument, type UPGPortfolioKind, type UPGPresenceExceptSpec, type UPGProduct, type UPGProductArea, type UPGProductStage, type UPGPropertyMap, type UPGPropertyMigration, type UPGPropertyMigrationChange, type UPGRegion, type UPGRegionEntityMembership, type UPGRegionEntityRole, type UPGRegionId, type UPGRegionShape, type UPGRegistry, type UPGScalarToEdgeMigration, type UPGScaleDefinition, type UPGScalePoint, type UPGSource, type UPGSplitEdge, type UPGSplitMigration, type UPGSplitRoute, type UPGSplitRouteTarget, type UPGSplitTarget, type UPGTreeChild, type UPGTreeGapPolicy, type UPGTreePattern, type UPGTreePatternDetail, type UPGTreePatternEdge, type UPGTreePatternSummary, type UPGTypeLabel, type UPGTypeMigration, type UPGValidationError, type UPGValidationProfile, type UPGValidationResult, type UPGValidationWarning, type UPGWildcardEndpoint, UPG_ACTIVE_TYPES, UPG_ANTI_PATTERNS, UPG_ANTI_PATTERN_CONCERNS, UPG_APPROACHES, UPG_APPROACHES_BY_ID, UPG_AREA_TAXONOMY, UPG_AREA_TAXONOMY_BY_COVERAGE_KEY, UPG_CANONICAL_FORMAT_VERSION, UPG_CONTAINMENT_FREE_TYPES, UPG_COUNT_BENCHMARKS, UPG_CROSS_EDGE_TYPES, UPG_CROSS_ELIGIBLE_CATALOG_EDGE_TYPES, UPG_CROSS_ONLY_EDGE_TYPES, UPG_DELIBERATE_ONLY_EDGE_TYPES, UPG_DEPRECATED_TYPES, UPG_DOMAINS, UPG_DOMAIN_ACTIVATION, UPG_DOMAIN_COUNT, UPG_DOMAIN_GUIDES, UPG_DOMAIN_RINGS, UPG_EDGE_CATALOG, UPG_EDGE_COUNT, UPG_EDGE_COUNT_SPECS, UPG_EDGE_MIGRATIONS, UPG_EDGE_PAIR_MAP, UPG_EDGE_TYPES, UPG_ENTITY_COUNT, UPG_ENTITY_FILTER_SPECS, UPG_ENTITY_META, UPG_ENTITY_META_BY_ID, UPG_ENTITY_META_BY_NAME, UPG_ENTITY_TO_DOMAIN, UPG_ENUM_SCALES, UPG_FORMAT_VERSION, UPG_FRAMEWORKS, UPG_FRAMEWORKS_BY_CATEGORY, UPG_FRAMEWORKS_BY_ID, UPG_FRAMEWORK_CATEGORIES, UPG_LENSES, UPG_LIFECYCLES, UPG_LIFECYCLE_FREE_TYPES, UPG_LIFECYCLE_PLANNED_TYPES, UPG_META_COUNT, UPG_MIGRATIONS, UPG_PLAYBOOKS, UPG_POLYMORPHIC_EDGE_KEYS, UPG_PORTFOLIO_KINDS, UPG_PORTFOLIO_SHARED_TYPES, UPG_PRESENCE_EXCEPT_SPECS, UPG_PRODUCT_STAGES, UPG_PRODUCT_STAGE_COERCION_MAP, UPG_PROPERTY_MIGRATIONS, UPG_PROPERTY_SCHEMA, UPG_RATIO_BENCHMARKS, UPG_REGIONS, UPG_REGION_COUNT, UPG_REGION_MAP, UPG_RELATIONSHIP_BENCHMARKS, UPG_SCALAR_TO_EDGE_MIGRATIONS, UPG_SCALES, UPG_SPLIT_MIGRATIONS, UPG_STATUS_MIGRATIONS, UPG_STRUCTURE_PATTERNS, UPG_TREE_PATTERNS, UPG_TREE_PATTERNS_BY_ID, UPG_TYPES, UPG_TYPES_SET, UPG_TYPE_ALIASES, UPG_TYPE_LABELS, UPG_TYPE_LABELS_MAP, UPG_TYPE_NAMES, UPG_VALIDATION_PROFILES, UPG_VALID_CHILDREN, UPG_VERSION, UPG_WILDCARD_ENDPOINT, USERS_NEEDS_PLAYBOOK, type UnitEconomicsProperties, UnknownEntityTypeError, type UserAdvisoryBoardProperties, type UserFlowProperties, type UserJourneyProperties, type UserStoryProperties, VARIES_BY_EDGE, type ValueObjectProperties, type ValuePropositionProperties, type ValueStreamProperties, type VariantProperties, type VisionProperties, type VulnerabilityProperties, type WalkMigrationChainResult, type WalkthroughProperties, type WebinarProperties, type WireframeProperties, type WorkflowArtifactProperties, type WorkflowRunProperties, type WorkflowTemplateProperties, type WorkspaceProperties, backfillSlug, buildTypeAliases, canBeChildOf, checkConfigurationDrift, checkHeaderSeal, checkHeaderSealText, checkToEdgeCountSpec, classifyEntityFilter, coerceProductStage, collectSlugsForType, collectTargetEntities, compareVersions, computeBodyChecksum, concernEvaluatedFor, concernFor, concernGatesFor, crossProductScope, deriveCounts, derivePortfolioCounts, deriveSingleCounts, describeTreePattern, edgeCarriesProperties, edgeCountSpecKey, entityFilterKey, enumerateProjections, evaluateAntiPatterns, findInvalidStatusMigrationTargets, formatUpgText, friendlyToAssessment, generateSlug, getAnchorEntity, getAntiPatternById, getAntiPatterns, getAntiPatternsBySeverity, getAntiPatternsForStage, getAreaTaxonomyEntry, getBenchmark, getBenchmarksByDomain, getBusinessAreasForRegion, getCanonicalPlaybookForRegion, getCoverageKeysForRegion, getDefaultLens, getDeprecatedTypes, getDomainForType, getDomainIdForType, getDomainsInRing, getEdgePropertySchema, getEntityModifierSummary, getEnumScale, getEnumValueMeta, getGuideForDomain, getLens, getLensIds, getLensPlaybook, getLensesForDomain, getLifecycleForType, getLifecycleRenderShape, getMigrationMap, getPlaybookById, getPlaybooksForRegion, getPropertiesForScale, getPropertyDefaultScale, getPropertyMigrations, getPropertyModifier, getPropertySchema, getRegion, getRegionForEntityType, getReplacementType, getRingForDomain, getScalarToEdgeMigrations, getScale, getSplitMigrations, getTreePattern, getTypeId, getTypeName, getTypes, getUPGEdgeMigrations, getValidChildren, getVisibleTypes, hasStatusMigration, isAggregateShapedProperty, isCanonical, isCanonicalProductStage, isContainmentFreeType, isCrossCapable, isCrossProductEligible, isCuratedCrossEligible, isDeliberateOnlyEdge, isDeprecatedType, isDomainGuideStep, isEntitySequenceStep, isFrameworkInvocationStep, isLegacyProductStage, isLifecycleFreeType, isLifecyclePlannedType, isPolymorphicEdge, isPortfolio, isPortfolioSharedType, isRecordEntity, isRegisteredPolymorphicEdge, isRuntimeStateShapedProperty, isSubSequenceStep, isThinCoverageAdvisory, isUPGDocument, listPropertiesByModifier, listStatusMigrations, listTreePatternSummaries, migrateEdge, migrateNode, migrateNodeProperties, migrateProductStage, migrateStatusValue, normalizeDocument, parseUpg, pickCanonicalEdge, presenceExceptKey, projectGraph, readActiveWhen, readStringArray, resolveAllEdges, resolveContainmentEdge, resolveEntityType, resolveLabel, resolveSlugCollision, resolveTreePatternEdges, ringOrderedDomainIds, rotateSlug, serializeCanonical, validateEdgeProperties, validateProductStageStrict, validateUPGDocument, validateUPGFramework, validationProfileFor, walkMigrationChainToCanonical };