@unified-product-graph/core 0.33.1 → 0.35.0

package/dist/index.d.cts

@@ -154,18 +154,61 @@ declare function friendlyToAssessment(scaleId: string, word: string): {
  * `packages/upg-spec/src/properties/domains/` (audited at v0.4.0).
  */
 declare const PROPERTY_SCALE_MAP: Record<string, string>;
+/**
+ * Per-ENTITY scale overrides (0.35.0). Beats `PROPERTY_SCALE_MAP` for the one
+ * entity named, and only that entity.
+ *
+ * This activates the per-entity disambiguation `getPropertyDefaultScale` has
+ * reserved since v0.4.0. It exists for a narrow, real class: a property name
+ * that means one thing on most entities and its opposite on one.
+ *
+ * `risk.impact` is that case. `impact_5` is benefit-framed ("Minimal →
+ * Transformative") and reads high-is-good, which on discovery and market
+ * entities is correct — a high-impact opportunity is good news. On a `risk`,
+ * the same word means severity of consequences, and a catastrophic risk was
+ * rendering GREEN. `severity_5` ("Mild inconvenience → Blocker") is the
+ * risk-shaped ladder and reads low-is-good, so the traffic-light story arrives
+ * from the existing polarity map with no bespoke bucketing.
+ *
+ * `risk.probability` is the second entry, and it is the same instrument used
+ * for the opposite purpose (Captain-ratified 2026-08-22). `probability` is
+ * DEPRECATED on `risk` in favour of `likelihood`, and the name-level map holds
+ * it at `confidence_5` for `forecast.probability`, which is a bare sales
+ * percentage and genuinely belongs there. Leaving `risk.probability` on that
+ * name-level entry meant the deprecated field and its replacement rendered on
+ * DIFFERENT ladders for the whole deprecation window: the same stored 4 reading
+ * "Confident" through the old name and "Likely" through the new one, on one
+ * card, from one graph. A staged deprecation exists so a reader can migrate
+ * WITHOUT their data changing meaning, and a ladder swap at the rename is
+ * exactly that meaning changing. So the override pins the legacy spelling to
+ * `likelihood_5` — the ladder the field always should have had — and the two
+ * names agree until 1.0.0 drops the old one.
+ *
+ * Note what this does NOT do: `forecast.probability` is untouched and still
+ * resolves to `confidence_5` through the name-level map. Being able to correct
+ * ONE entity without disturbing the other is the entire reason this layer
+ * exists, and this is the first time it has been used for that rather than for
+ * a polarity fix.
+ *
+ * Keep this layer SMALL. A name that needs an override on three entities is a
+ * name that should be split, not overridden; renaming `risk.probability` to
+ * `likelihood` in the same release is that lesson applied. The two entries here
+ * are both `risk`, both from one audit, and both close when 1.0.0 lands.
+ */
+declare const PROPERTY_SCALE_MAP_BY_ENTITY: Record<string, Record<string, string>>;
 /**
  * Return the default scale ID for a given entity-type / property-name pair.
  *
- * Resolution order:
- * 1. Check `PROPERTY_SCALE_MAP` for a property-level override.
- * 2. Fall back to `'scale_5'` (generic 1–5 ordinal) for all other properties.
+ * Resolution order (0.35.0 — the entity layer is new; the other two are not):
+ * 1. `PROPERTY_SCALE_MAP_BY_ENTITY[entityType][propertyName]` — a per-entity
+ *    override, for a name that means something different on one entity.
+ * 2. `PROPERTY_SCALE_MAP[propertyName]` — the property-level default.
+ * 3. `'scale_5'` (generic 1–5 ordinal).
  *
- * The `entityType` parameter is accepted for API stability; future versions
- * may add per-entity overrides, but the initial implementation ignores it.
+ * Adding layer 1 is non-breaking: every pair with no entity override resolves
+ * exactly as before.
  *
- * @param entityType  - The UPG entity type string (e.g. `'problem_statement'`).
- *                      Currently unused; reserved for future per-entity overrides.
+ * @param entityType   - The UPG entity type string (e.g. `'problem_statement'`).
  * @param propertyName - The property name on that entity (e.g. `'severity'`).
  * @returns A scale ID string (always a key of `UPG_SCALES` or `'scale_5'`).
  *
@@ -173,10 +216,15 @@ declare const PROPERTY_SCALE_MAP: Record<string, string>;
  * getPropertyDefaultScale('problem_statement', 'reach')     // → 'reach_5'
  * getPropertyDefaultScale('problem_statement', 'frequency') // → 'frequency_5'
  * getPropertyDefaultScale('problem_statement', 'severity')  // → 'severity_5'
- * getPropertyDefaultScale('risk', 'risk_level')             // → 'scale_5'
+ * getPropertyDefaultScale('risk', 'risk_level')             // → 'severity_5'
+ * getPropertyDefaultScale('risk', 'likelihood')             // → 'likelihood_5'
+ * getPropertyDefaultScale('risk', 'impact')                 // → 'severity_5' (entity override)
+ * getPropertyDefaultScale('risk', 'probability')            // → 'likelihood_5' (entity override; deprecated name, same ladder as `likelihood`)
+ * getPropertyDefaultScale('forecast', 'probability')        // → 'confidence_5' (unchanged)
+ * getPropertyDefaultScale('opportunity', 'impact')          // → 'impact_5'   (unchanged)
  * getPropertyDefaultScale('anything', 'unknown_property')   // → 'scale_5'
  */
-declare function getPropertyDefaultScale(_entityType: string, propertyName: string): string;
+declare function getPropertyDefaultScale(entityType: string, propertyName: string): string;
 /**
  * Inverse of `PROPERTY_SCALE_MAP`: the canonical property names that default to
  * a given scale, in declaration order. Useful for documentation surfaces that
@@ -185,6 +233,13 @@ declare function getPropertyDefaultScale(_entityType: string, propertyName: stri
  * Returns an empty array for scales no property defaults to (e.g. the generic
  * `'scale_5'` fallback, which is never an explicit entry).
  *
+ * Scope: the NAME-level map only. Per-entity overrides
+ * (`PROPERTY_SCALE_MAP_BY_ENTITY`, 0.35.0) are deliberately not folded in,
+ * because a bare property name cannot express "impact, but only on risk" and a
+ * documentation surface that listed `impact` under both ladders would be
+ * telling the reader less than it does now. Read that map directly when the
+ * question is per-entity.
+ *
  * @example
  * getPropertiesForScale('effort_5') // → ['effort', 'effort_estimate', 'effort_to_fix']
  */
@@ -617,32 +672,81 @@ interface UPGBaseNode {
      * about the thing (the same cut that keeps `composition.rev`, which is a fact,
      * and excludes a concurrency token, which is not).
      *
-     * WHICH PREFIX (0.33.0 normative, ladder restated in 0.33.1). Four rungs, tried
-     * in order. (1) A create NAMES its prefix explicitly. (2) Otherwise the
-     * prefixes DECLARED by the product's teams (`team.key_prefix`) are the
-     * candidates; `product.key_prefix` applies only when no team declares one, and
-     * is `@deprecated` for that reason. (3) Otherwise the prefixes OBSERVED on the
-     * product's existing keys are the candidates. That rung is the quiet case a
-     * graph reaches when its keys were imported rather than declared, and it is a
-     * real mint path: the two paragraphs below both name an INFERRED prefix, and
-     * `team.key_prefix` rule 3 presupposes it. (4) A product with none of the three
-     * mints no keys. Key uniqueness is scoped to the product across entity types; a
-     * prefix names a team within that scope, not a separate number line.
+     * WHICH PREFIX (normative; ladder stated as built in 0.33.1, candidate set
+     * narrowed in 0.34.0). Three rungs, tried in order.
+     *
+     *   1. A create NAMES its prefix explicitly.
+     *   2. Otherwise the CANDIDATE SET is consulted. It is the UNION of the prefixes
+     *      DECLARED by the product's teams (`team.key_prefix`) and the prefixes
+     *      OBSERVED on the product's existing keys. One candidate resolves; more
+     *      than one, and the create surface asks. `product.key_prefix` is consulted
+     *      only when no team declares one, and is `@deprecated` for that reason.
+     *   3. A product with an empty candidate set and no explicit prefix mints no
+     *      keys.
+     *
+     * THE OBSERVED RUNG IS A REAL MINT PATH, and 0.33.0 published two sentences that
+     * disagreed about whether it existed. This paragraph used to end "A product where
+     * nothing declares a prefix mints no keys", which deletes it; the two paragraphs
+     * below both name a prefix INFERRED from existing keys, and `team.key_prefix`
+     * rule 3 presupposes it by construction. The field settles it: the only keyed
+     * graph in the estate carries 1,032 keys minted by inference in a product that
+     * declares no prefix at all, and under the deleted rung that graph could not
+     * exist. Corrected in the 0.33.1 patch and restated here.
+     *
+     * A DECLARATION ADDS A CANDIDATE; IT DOES NOT REMOVE ONE (0.34.0). Declaring a
+     * team prefix suppresses `product.key_prefix` and nothing else. It never
+     * suppresses an OBSERVED prefix, which is evidence of a namespace already in
+     * use. The full argument, the measurement behind it and the reason it ships as a
+     * change rather than as a patch are on `team.key_prefix`.
      *
-     * NOT ENFORCED. The uniqueness and immutability invariants are stated here and
-     * no check fires on them. A duplicate-key detector needs a labeled corpus
-     * including the near-miss, two products in one workspace legitimately sharing a
-     * prefix, and that corpus does not exist yet.
+     * Key uniqueness is scoped to the product across entity types; a prefix names a
+     * team within that scope, not a separate number line.
+     *
+     * ENFORCED WITHIN THE PRODUCT (0.34.1). A create naming a key another node in
+     * this product already holds is REFUSED, across entity types, with a typed
+     * `DuplicateNodeKeyError`. Immutability was already enforced on the update
+     * path from 0.33.0, through the typed field and through `properties` both.
+     *
+     * THE REFUSAL IS AN ERROR AND NOT A SILENT NO-KEY, and the distinction is the
+     * one the minting rules draw two paragraphs down. A portfolio-shared team's
+     * prefix mints nothing in a second product, and there the refusal IS no-key
+     * and never an exception — because nobody asked for that key; it was inferred.
+     * A duplicate arrives the other way round: the caller NAMED it. Returning
+     * success for a node whose citation was quietly dropped is the failure mode
+     * the 0.32.2 field guards exist to end.
+     *
+     * ENFORCED ON CREATE, NOT ON OPEN. A graph minted before the check existed may
+     * hold a collision, and a store that refuses to load it leaves its owner no
+     * way to repair it. The index is therefore built first-wins at load and the
+     * invariant is held at the only moment it can still be honoured.
+     *
+     * THE PRECEDING TWO PARAGRAPHS SHIPPED AS AN OVERCLAIM AND ARE CORRECTED HERE.
+     * 0.33.0 wrote "uniqueness is enforced per product (the store index is
+     * `(product_id, key)`)" as settled fact, and 0.34.0 restated the within-product
+     * case as stated-but-unchecked without reconciling the two. Neither was
+     * describing anything that ran: no index existed and no check fired, on any
+     * release through 0.34.0. It was measured on the only keyed graph in the
+     * estate — 1,032 keys, and a second node claiming one of them was accepted
+     * without a warning. This matters more than a wrong sentence usually would,
+     * because the portfolio detector below names the per-product invariant as its
+     * premise: a portfolio check that assumes each product is internally clean was
+     * resting on nothing. 0.34.1 makes the sentence true rather than deleting it.
      *
      * PORTFOLIO-WIDE UNIQUENESS IS DEFINED AND UNENFORCED (0.33.0). Within a
      * portfolio, one `(prefix, number)` pair should identify one node. Uniqueness
-     * is enforced per product (the store index is `(product_id, key)`), so two
-     * products minting under one prefix produce the same citation for two different
-     * things. This is measured rather than feared: a fixture reproduces the
+     * is enforced per product (the store index is `(product_id, key)`, and from
+     * 0.34.1 that index exists), so two products minting under one prefix produce
+     * the same citation for two different things. This is measured rather than
+     * feared: a fixture reproduces the
      * collision through the ordinary create path, including the quiet case where
-     * nobody declares a prefix and it is inferred from existing keys. No check
-     * enforces it, and no per-product check ever can, because each product reports
-     * its own key as valid.
+     * nobody declares a prefix and it is inferred from existing keys. No PER-PRODUCT
+     * check can ever see it, because each product reports its own key as valid —
+     * which is why the detector that ships in 0.34.0 is a PORTFOLIO-scope
+     * anti-pattern (`duplicate-key-across-products`) rather than a graph validation.
+     * It is ENFORCED from the day it ships; what was staged is the corpus, and the
+     * distinction matters because there is no defined-then-enforced mechanic and
+     * inventing one would have been worse than either real option. A detector that is
+     * registered but declines to fire is a detector nobody can reason about.
      *
      * MINTING IS PRODUCT-SCOPED (normative, 0.33.0). The `(product_id, key)` index
      * is the enforced invariant and the scope of a key sequence is the product.
@@ -652,7 +756,13 @@ interface UPGBaseNode {
      * an exception, and the rule applies on the MINT path including a prefix that
      * was INFERRED from existing keys rather than requested by any caller.
      * Portfolio-shared team minting is deferred until a supra-product uniqueness
-     * design exists. See `team.key_prefix` for the rule in full.
+     * design exists. See `team.key_prefix` for the rule in full, including the three
+     * mechanics 0.34.0 made normative that this rule needs and 0.33.0 left open: HOW
+     * a minter decides which product a prefix belongs to (evidence, not a stored
+     * marker), what happens when nothing can decide (NEITHER mints, no invented
+     * tiebreak), and what "in scope" means (engine-defined, with a floor at every
+     * product the engine can enumerate for this caller and a ceiling at every product
+     * the caller could not otherwise read).
      *
      * WHERE THE BEHAVIOUR LIVES, because this is a contract and not an
      * implementation. Nothing in this package mints a key. Deriving the next number
@@ -729,6 +839,25 @@ interface UPGBaseNode {
      * fields whose names differ by a plural and whose semantics differ by
      * canonicality is a misreading waiting to happen in every consumer.
      *
+     * MIGRATION NOTE, CORRECTED 0.34.0 ON TWO FIGURES. Both were carried forward
+     * from the 0.33.0 pass and both were wrong, and the second would have broken
+     * this field's own contract on its first real population.
+     *
+     *   THE RESIDUE IS 179, NOT 162. Seventeen further attachments sat in a second
+     *   vendor bag key and were equally homeless. They were never counted because
+     *   the census read one key.
+     *
+     *   THE CANONICAL URL MUST BE SUBTRACTED BEFORE THE COPY. 524 of the 528 nodes
+     *   holding a parked bag DUPLICATE their own `external_ref` inside it. A
+     *   straight copy of the bag into this list would therefore put the canonical
+     *   artifact into the NON-canonical list on 99% of the field's first real
+     *   population, breaking the exact invariant this field was minted to
+     *   establish. A migration reads the bag, removes the entry matching
+     *   `external_ref`, and copies what remains.
+     *
+     * The correction is recorded here rather than in a plan because this is where a
+     * migration author will be standing when they need it.
+     *
      * @example
      * [{ url: 'https://github.com/acme/api/pull/812', label: 'PR 812', kind: 'pull_request' }]
      */
@@ -769,12 +898,25 @@ interface UPGBaseNode {
      *
      * ONE UNDECLARED EXTENSION IS KNOWN, MEASURED AND DELIBERATELY LEFT UNDECLARED.
      * A tracker import carries raw ordered state-transition history for every issue
-     * (1,032 issues, 2,862 transitions in the measured corpus) under a namespaced
+     * (1,032 issues, 2,862 transitions in the measured corpus) under a vendor-owned
      * key. It has no declared shape because nothing reads it: declaring a shape for
      * records nobody queries is dead schema, and it would freeze one vendor's
      * transition model into the format before a second source has been seen. The
      * pull-forward condition is the first reader. Silence and a decision look
      * identical six months later, so this is written down as a decision.
+     *
+     * THAT KEY IS NOT ACTUALLY NAMESPACED, AND THE PARAGRAPH ABOVE USED TO CLAIM IT
+     * WAS (corrected 0.34.1). The rule two paragraphs up mandates `<tool>:<key>`
+     * with a COLON. The import writes `linear_state_history`, with an underscore —
+     * the precise shape the rule was written to forbid, cited here as the example
+     * of compliance. It went unnoticed because nothing could see it: no drift class
+     * examined undeclared bag keys until `undeclared_property_drift` shipped in
+     * 0.34.1, which measured 5,779 such keys across eight `linear_*` shapes on the
+     * one imported graph in the estate.
+     *
+     * Recorded rather than migrated, because renaming a key on 1,032 nodes is a
+     * migration with its own cycle and this paragraph is where its author will be
+     * standing. What changes here is the claim, not the data.
      */
     properties?: Record<string, unknown>;
 }
@@ -1364,6 +1506,13 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    research_study_captures_quote: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "hierarchy";
+        source_type: string;
+        target_type: string;
+    };
     research_study_clusters_into_affinity_cluster: {
         forward_verb: string;
         reverse_verb: string;
@@ -2143,6 +2292,13 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    feature_specified_by_user_story: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "hierarchy";
+        source_type: string;
+        target_type: string;
+    };
     user_story_verified_by_acceptance_criterion: {
         forward_verb: string;
         reverse_verb: string;
@@ -5798,6 +5954,58 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    /**
+     * A document EMBEDS this node's live value at a position in its prose.
+     *
+     * @remarks
+     * NOT `describes`. `document_describes_persona` says the document is ABOUT the
+     * persona. Transclusion says the document RENDERS that node where the prose
+     * sits, so the value a reader sees is the node's current value rather than a
+     * copy taken when the sentence was written. A PRD that transcludes a metric is
+     * not "about" the metric, and collapsing the two would lose the only property
+     * transclusion is bought for: current by construction. The nine-member
+     * `document_describes_*` family is untouched and keeps its meaning.
+     *
+     * POLYMORPHIC because the target set is genuinely open. Anything renderable can
+     * be embedded, and the nine enumerated describe-targets are none of `metric`,
+     * `research_study`, `specification` or `architecture_decision`, which is what
+     * 65% of measured documents carrying zero outbound edges were reaching for.
+     *
+     * THE ANCHOR BINDING (normative). `@unified-product-graph/markdown` already
+     * parses an inline reference form and records the source line of every
+     * occurrence: `[[type:id]]`, `[[type:id|label]]`, `[[type:id|k:v|...]]`,
+     * `[[+type:id]]` for creation, and `[[type:id@product]]` across products. The
+     * grammar is published as Appendix F of the specification paper. The rule that
+     * was missing, and is stated here: an anchor appearing in the body of a
+     * `document` IS a transclusion anchor, and a conformant parser WRITES this edge
+     * beside it. Anchor and edge are one fact recorded twice, so they must be
+     * written together or they drift.
+     *
+     * NO POSITION PROPERTY, deliberately. The obvious `anchor_line` is the most
+     * volatile value a text document has: every insertion above moves every anchor
+     * below, so a stored line number is wrong after the next paragraph and nothing
+     * reports the drift. The anchor IS the position, and it lives in the prose
+     * where ordinary editing moves it for free. What the law asks is that the edge
+     * be written BESIDE the anchor, which is a write-time discipline rather than a
+     * stored field.
+     *
+     * `deliberate_only`, and the 0.33.0 trap is why that is safe here. Flagging a
+     * widened edge `deliberate_only` silently switched five adapters off in the
+     * last release, two of them under a green suite. The rule that came out of it:
+     * an adapter reading an explicit field the SOURCE stores carries an authored
+     * fact rather than an inferred one and must emit deliberate-only edges
+     * EXPLICITLY. A `[[type:id]]` anchor is as explicit as a source gets, because a
+     * person typed it, so the markdown emitter keys on the ANCHOR and never on the
+     * `node` wildcard. No generic pair-resolution path may ever produce one.
+     */
+    document_transcludes_node: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "semantic";
+        source_type: string;
+        target_type: string;
+        deliberate_only: true;
+    };
     product_educates_via_education_program: {
         forward_verb: string;
         reverse_verb: string;
@@ -5959,6 +6167,13 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    person_holds_role: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "semantic";
+        source_type: string;
+        target_type: string;
+    };
     team_staffed_with_role: {
         forward_verb: string;
         reverse_verb: string;
@@ -6029,6 +6244,13 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    stakeholder_invested_in_outcome: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "cross-domain";
+        source_type: string;
+        target_type: string;
+    };
     team_okr_aligns_with_objective: {
         forward_verb: string;
         reverse_verb: string;
@@ -6268,6 +6490,20 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    risk_threatens_node: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "cross-domain";
+        source_type: string;
+        target_type: string;
+    };
+    risk_mitigated_by_node: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "cross-domain";
+        source_type: string;
+        target_type: string;
+    };
     data_contract_governs_data_source: {
         forward_verb: string;
         reverse_verb: string;
@@ -8782,7 +9018,7 @@ declare function isDeliberateOnlyEdge(type: string): boolean;
 /**
  * Canonical allow-list of edges that use the `'node'` wildcard endpoint.
  *
- * Fourteen semantic families are sanctioned. The count and the partition are
+ * Sixteen semantic families are sanctioned. The count and the partition are
  * asserted in `spec-integrity.test.ts`, so this list cannot silently fall out
  * of step with the array below the way it did between 0.28.0 and 0.31.0:
  *
@@ -8840,12 +9076,53 @@ declare function isDeliberateOnlyEdge(type: string): boolean;
  *    `delivers` and NOT `contains`, because a containment verb would oblige a
  *    `UPG_VALID_CHILDREN` pair that a wildcard endpoint can never supply; the
  *    parent axis is containment and the project axis is a reference.
- *
- * Adding a new polymorphic edge requires extending this array AND the
- * spec-integrity regression test, which forces a conscious decision and
- * keeps consumers (MCP, Entopo, audit tools) able to enumerate the full set.
+ * 15. **Document transclusion** (0.34.0): a document embeds a node's live value
+ *    at a position in its prose. The only family whose target set is open by
+ *    NATURE rather than by a bounded enumeration nobody wanted to write out:
+ *    anything renderable can be embedded. Deliberately NOT merged with the
+ *    nine-member `document_describes_*` family, which says the document is ABOUT
+ *    a thing rather than that it renders it.
+ * 16. **Risk exposure** (0.35.0): what a risk puts at stake, and what mitigates
+ *    it. Deliberately mirrors family 2 ("decision-to-anything") with `risk` in
+ *    the source slot, for the same reason: both target sets are open (outcome,
+ *    key_result, release, service, contract, launch on one side; decision,
+ *    feature, experiment, security_control on the other) and neither endpoint
+ *    carries a structural role. Both `cross-domain`, so the containment tree is
+ *    untouched. The typed `security_control_mitigates_threat` is NOT absorbed:
+ *    it stays the security-domain edge, and this is the product generalisation.
+ *
+ * Adding a new polymorphic edge requires extending this array AND naming the
+ * family it joins in `UPG_POLYMORPHIC_EDGE_FAMILIES` below, which the
+ * spec-integrity regression test asserts against. That forces a conscious
+ * decision and keeps consumers (MCP, Entopo, audit tools, the editorial gate)
+ * able to enumerate the full set and attribute a wildcard edge to real types.
  */
 declare const UPG_POLYMORPHIC_EDGE_KEYS: readonly _UPGEdgeTypeLocal[];
+/**
+ * The partition of `UPG_POLYMORPHIC_EDGE_KEYS` into named families.
+ *
+ * @remarks
+ * WHY THIS IS AN EXPORT AND NOT A TEST LITERAL. It lived inside
+ * `spec-integrity.test.ts` until 0.34.0, which made it unreachable by every
+ * consumer that needs it, and there is now a real one: `check:editorial` matches
+ * `source_type === type` and `target_type === type` LITERALLY when it derives an
+ * entity's attached-edge set, so an edge whose endpoint is the `node` wildcard is
+ * attributed to nobody. `project_delivers_work_item` moved zero fingerprints on
+ * `task`, `bug`, `user_story` or `feature`. A gate cannot fix that without a map
+ * from a wildcard key to the types the family actually ranges over, and duplicating
+ * the map in the gate would recreate the drift the test was written to catch.
+ *
+ * THE MEMBER LIST IS THE KEYS, NOT THE TYPES. A family names which polymorphic
+ * KEYS belong together. What a consumer does with that — which concrete entity
+ * types to attribute a wildcard edge to — is its own decision, made against the
+ * catalog. This export does not pretend to answer it.
+ *
+ * The prose list in the JSDoc above drifted once already: it still read "Eight
+ * semantic families" after the ninth and tenth had shipped. `spec-integrity`
+ * asserts this object against `UPG_POLYMORPHIC_EDGE_KEYS` in both directions, so
+ * a new key fails until its author names the family it joins.
+ */
+declare const UPG_POLYMORPHIC_EDGE_FAMILIES: Readonly<Record<string, readonly _UPGEdgeTypeLocal[]>>;
 /**
  * True if the edge uses the `'node'` wildcard at either endpoint. Derived
  * dynamically from `source_type`/`target_type`, not from the allow-list,
@@ -8894,6 +9171,47 @@ declare function getEdgePropertySchema(type: string): PropertySchema | undefined
 
 /** Union of all edge type keys from the canonical edge registry */
 type UPGEdgeType = keyof typeof UPG_EDGE_CATALOG;
+/**
+ * Where an edge came from, when it was not authored directly.
+ *
+ * @remarks
+ * WHY UNGATED, and the precedent settles it. The obvious objection is that this
+ * belongs behind `carries_properties`. It does not: `mapping_confidence` is
+ * ALREADY an ungated provenance field on every edge. The `carries_properties`
+ * gate exists to keep semantic edges free of domain PAYLOAD — a MoSCoW bucket, a
+ * RICE score, a canvas slot, facts about the relationship's content. Provenance
+ * is not content; it is a fact about the record, in the same class as the field
+ * already sitting ungated beside it. Gating it would mean an edge has to opt in
+ * to having a history, which is the wrong shape for a universal fact and would
+ * make an emission pass check whether the edge it is writing is allowed to
+ * remember anything.
+ *
+ * WHY NESTED, and it is a collision rather than a preference. `UPGEdge.source`
+ * already means the source NODE. A flat `source_id` copied from the node side
+ * would sit one character from it and mean something entirely different — the
+ * exact misreading generator `external_refs` was rejected for at 0.33.0. Nesting
+ * removes the collision completely and costs one field.
+ *
+ * WHY IT EXISTS AT ALL. The node side has carried `source_id`, `source_type`,
+ * `mapping_confidence`, `external_tool`, `external_ref`, `external_id` and, since
+ * 0.33.0, `created_at` / `updated_at`. A node knows where it came from; an edge
+ * knew only how sure the importer was. A bulk emission of 651 derived edges had
+ * nowhere ON THE EDGE to record derived-by-what, from-which-fact, or when, so the
+ * record lived in a sidecar ledger outside the graph. That is the sibling of the
+ * question documents-as-entities exists to answer: provenance belongs to the
+ * thing, not beside it.
+ *
+ * NOT a substitute for `mapping_confidence`, which answers a different question
+ * (how sure an import was that this edge TYPE was right) and stays where it is.
+ */
+interface UPGEdgeProvenance {
+    /** The tool or pass that derived it. Same posture as `UPGBaseNode.external_tool`. */
+    tool?: string;
+    /** The fact it was derived FROM: a source field, a property key, a ledger id. */
+    from?: string;
+    /** ISO timestamp of the derivation. */
+    at?: ISODateTime;
+}
 /** Interface for a semantic relationship between two nodes */
 interface UPGEdge {
     /** Unique identifier within the graph */
@@ -8908,15 +9226,30 @@ interface UPGEdge {
     mapping_confidence?: UPGMappingConfidence;
     /**
      * Edge-scoped properties. Permitted ONLY on edge types whose catalog
-     * definition sets `carries_properties: true` — currently the
-     * `framework_exercise_includes_node` edge, which stores a framework's
-     * per-entity result here (a MoSCoW bucket, a RICE score, a canvas slot, a
-     * funnel stage). A value that exists only within a specific exercise of a
-     * framework is a fact about the *relationship*, not about either endpoint,
-     * so it belongs on the edge. Plain semantic edges stay payload-free;
-     * validators reject `properties` on edges that do not opt in.
+     * definition sets `carries_properties: true`. `framework_exercise_includes_node`
+     * is the archetype, storing a framework's per-entity result here (a MoSCoW
+     * bucket, a RICE score, a canvas slot, a funnel stage). A value that exists
+     * only within a specific exercise of a framework is a fact about the
+     * *relationship*, not about either endpoint, so it belongs on the edge. Plain
+     * semantic edges stay payload-free; validators reject `properties` on edges
+     * that do not opt in.
+     *
+     * @remarks
+     * CORRECTED 0.34.0. This said the gate applies "currently the
+     * `framework_exercise_includes_node` edge". ELEVEN catalog edges set
+     * `carries_properties: true`. One word — "currently" — was doing the work of a
+     * gate nobody wired, and the sentence had been wrong for ten mints. The set is
+     * derivable from the catalog and is not restated here, for the reason this
+     * correction exists: a hand-maintained census in a comment is a claim with
+     * nothing recomputing it.
+     *
+     * NOT the home for provenance. See `provenance` below: a fact about the record
+     * is not domain payload, and requiring an opt-in to have a history is the wrong
+     * shape.
      */
     properties?: Record<string, unknown>;
+    /** Where this edge came from, when it was not authored directly. */
+    provenance?: UPGEdgeProvenance;
 }
 
 /**
@@ -8975,6 +9308,26 @@ type UPGProductStage = 'concept' | 'validation' | 'build' | 'beta' | 'launch' |
  * stable half of the whitelist (these change rarely); the growing, dual-registered
  * half is derived from the `cross_product_eligible` catalog flag — see
  * `CrossProductEligibleEdgeType` and `UPG_CROSS_ELIGIBLE_CATALOG_EDGE_TYPES`.
+ *
+ * @remarks
+ * DECLARED AND UNENFORCED (recorded 0.34.0, exhaustively). No WRITER reads this
+ * array. Not the SDK, not the local MCP server, not the cloud server, not the
+ * graph service. Outside `node_modules` and `dist` it is referenced by its own
+ * definition, two prose comments, one spec test, `check-editorial.mjs`, one
+ * generated mirror, and documents. The tier is a declared vocabulary that nothing
+ * validates at write time, so a graph can carry one of these types anywhere and no
+ * gate objects.
+ *
+ * That is worth stating rather than leaving to be rediscovered, because it changes
+ * what a "non-colliding key" would buy. A within-graph edge minted under a key that
+ * does not collide with one of these would not be safe BECAUSE nothing collides at
+ * runtime; it would be safe by discipline. Discipline and a guarantee should not be
+ * confused in a comment that reads like a contract.
+ *
+ * This is the third artifact damaged by reading one of the two edge registries in
+ * isolation, after the vocabulary check (fixed 0.33.0) and the withdrawn 0.33.0
+ * Item G. The fingerprint half of `check:editorial` was the fourth and is fixed in
+ * 0.34.0.
  */
 declare const UPG_CROSS_ONLY_EDGE_TYPES: readonly ["shares_persona", "shares_competitor", "shares_metric", "shares_job", "shares_need", "depends_on_product", "cannibalises", "succeeds", "hosts", "contributes_to", "rolls_up_to", "instance_of", "area_serves_persona", "area_targets_market_segment", "product_implements_specification", "product_exposes_specification", "feature_conforms_to_specification", "api_contract_speaks_specification", "product_exposes_primitive", "feature_manipulates_primitive", "primitive_stored_as_data_type"];
 /** One portfolio-native cross-product edge type (see `UPG_CROSS_ONLY_EDGE_TYPES`). */
@@ -9384,6 +9737,48 @@ declare function migrateProductStage<T extends string | undefined | null>(stage:
  */
 declare function isLegacyProductStage(stage: unknown): stage is string;
 
+/**
+ * The authored one-line description of every entity type.
+ *
+ * WHY THIS LIVES IN THE SPEC PACKAGE (0.34.1). It used to live only in the
+ * documentation site's generator, which is an application. That put the one
+ * sentence explaining what a type IS somewhere no consumer of the format could
+ * reach: `get_entity_schema` returned `type, domain, expected_properties,
+ * edges_out, edges_in, domain_guide` and no description, and
+ * `get_catalog_entry({ kind: 'entity_meta' })` returned `name, type_id,
+ * maturity, since, domain_id` and no description. The MCP server's own
+ * instructions say "Before creating an entity or edge, call `get_entity_schema`
+ * for the type", and the sentence that answers the question the caller actually
+ * has was the one thing that call did not return.
+ *
+ * It also meant 0.32.1's editorial gate — which turns a release red until every
+ * type has an authored description, after 0.32.0 shipped `capture` with the
+ * generator's fallback text — protected a surface no agent could see.
+ *
+ * PULLED FORWARD BY NECESSITY, and worth saying plainly: promoting these to a
+ * public export was a banked item, not a planned part of this patch. There is no
+ * other way for an agent surface to return an authored description, because the
+ * only authored copy was in an app. The alternative was a second copy in this
+ * package, and a second copy of a hand-maintained string table is the exact
+ * defect the derived base-node field list exists to prevent.
+ *
+ * SINGLE SOURCE. The site generator now READS this table instead of holding its
+ * own; `check:generated` proves the emitted site data is unchanged by the move.
+ * A new entity type without an entry here is caught by `check:editorial`.
+ *
+ * Descriptions are prose for a human reader and carry no contract. The
+ * normative statements about a type are its properties, its edges and its
+ * lifecycle.
+ */
+declare const UPG_ENTITY_DESCRIPTIONS: Readonly<Record<string, string>>;
+/**
+ * The authored description for an entity type, or `undefined`.
+ *
+ * A lookup rather than direct indexing so a caller handed a runtime string does
+ * not have to assert the key exists.
+ */
+declare function getEntityDescription(type: string): string | undefined;
+
 /**
  * UPG Entity Type Metadata. Immutable `type_id`, human-readable `name`,
  * `maturity` (draft → proposed → stable → deprecated → removed), and version
@@ -17524,7 +17919,7 @@ interface ComplianceRequirementProperties {
  * @example
  * const properties: RiskProperties = {
  *   risk_type: 'technical',
- *   probability: 4,
+ *   likelihood: 4,
  *   impact: 4,
  * }
  */
@@ -17538,11 +17933,74 @@ interface RiskProperties {
      * parallel `risk_domain` field free to drift from this one.
      */
     risk_type?: 'technical' | 'business' | 'legal' | 'security' | 'operational' | 'program';
-    /** How likely this risk is to materialise (1 = unlikely, 5 = near certain) */
+    /**
+     * How likely this risk is to materialise. Rated on `likelihood_5`
+     * (Rare → Almost certain).
+     * @remarks
+     * Canonical name since 0.35.0, superseding `probability` below. Three
+     * reasons, in order of weight. (1) `probability` was one name for two
+     * incompatible types (`UPGAssessment` here, a bare `number` on
+     * `forecast.probability`), and `PROPERTY_SCALE_MAP` is keyed by name alone,
+     * so a sales percentage and a risk judgment resolved to the same ladder.
+     * (2) `likelihood` is already the spec's own word: the RISK_ITEM lifecycle
+     * prose says "Likelihood and impact have been evaluated", and
+     * `threat.likelihood` has been a `UPGAssessment` all along: one name, one
+     * type, one ladder. (3) ISO 31000 says likelihood.
+     *
+     * The ladder moved with the name: `likelihood_5` is new in 0.35.0 because no
+     * probability ladder existed and `confidence_5` is epistemic. It says how
+     * sure the assessor is, not how likely the event is.
+     */
+    likelihood?: UPGAssessment;
+    /**
+     * How likely this risk is to materialise (1 = unlikely, 5 = near certain).
+     * @deprecated since="0.35.0" removeIn="1.0.0". Use `likelihood`, which is the
+     * spec's own word for this in the risk lifecycle and on `threat`.
+     *
+     * Both names resolve to the same `likelihood_5` ladder for the length of the
+     * deprecation window (`PROPERTY_SCALE_MAP_BY_ENTITY.risk.probability`,
+     * Captain-ratified 2026-08-22): a deprecated field that renders on a
+     * DIFFERENT ladder from its replacement would make one stored 4 read
+     * "Confident" under the old name and "Likely" under the new one, which is the
+     * data changing meaning at the rename, which is the exact thing staging
+     * exists to prevent. `forecast.probability` is untouched and stays on `confidence_5`.
+     *
+     * STAGED, not renamed. The field is KEPT and still read: 0.35.0 changes what
+     * writers emit and what readers prefer, and changes NO stored bytes. A graph
+     * written before 0.35.0 carries `probability` and no `likelihood`, and reads
+     * correctly, which is the whole point of staging it.
+     *
+     * Writers: emit `likelihood`. Readers: prefer `likelihood`, fall back to
+     * `probability`. The fallback is a CONTRACT on consumers, not executable
+     * spec machinery, exactly as it is for `epic.estimate` → `effort`.
+     *
+     * `removeIn="1.0.0"` is a deadline, not a wish: at 1.0.0 this field is
+     * dropped by a `drop_props` rule in `UPG_PROPERTY_MIGRATIONS`, the same
+     * two-step the `removeIn="0.5.0"` properties followed (declared at 0.4.0,
+     * dropped by the 0.5.0 rules). Until then there is deliberately no
+     * executable rule: see the `'0.35.0'` block in `grammar/migrations.ts`.
+     */
     probability?: UPGAssessment;
-    /** Severity of consequences if the risk materialises (1 = negligible, 5 = catastrophic) */
+    /**
+     * Severity of consequences if the risk materialises. Rated on `severity_5`
+     * (Mild inconvenience → Blocker), NOT the benefit-framed `impact_5`.
+     * @remarks
+     * The ladder is set by `PROPERTY_SCALE_MAP_BY_ENTITY.risk.impact` (0.35.0),
+     * the per-entity override layer. `impact` legitimately means magnitude of
+     * BENEFIT on discovery and market entities, where high is good; on a risk it
+     * means severity of harm, where high is bad. Sharing `impact_5` rendered a
+     * catastrophic risk green.
+     */
     impact?: UPGAssessment;
-    /** Planned or implemented mitigation strategy */
+    /**
+     * Planned or implemented mitigation strategy, as prose.
+     * @remarks
+     * Prose only. A structured list of mitigating ACTIONS is a set of edges:
+     * `risk_mitigated_by_node` (0.35.0), pointing at the decisions, features and
+     * experiments that actually do the mitigating; a string array of them is
+     * unqueryable by construction. Likewise, what the risk puts at stake is
+     * `risk_threatens_node`, not a scope-list property.
+     */
     mitigation?: string;
 }
 /** Data contract.
@@ -17641,16 +18099,41 @@ interface TeamProperties {
      * `ENTP-2`, ...).
      *
      * @remarks
-     * SUPERSEDES `product.key_prefix` FOR THIS PRODUCT. The moment any team
-     * declares a prefix, the product-level prefix stops being consulted and the
-     * declared team prefixes become the candidate set a create surface offers. A
-     * product-level prefix that still resolved would win on order alone, and a
-     * multi-team product would then silently mint everything under it, which is the
-     * defect this field exists to end.
+     * SUPERSEDES `product.key_prefix` FOR THIS PRODUCT, AND NOTHING ELSE
+     * (normative, narrowed in 0.34.0). The moment any team declares a prefix, the
+     * PRODUCT-LEVEL prefix stops being consulted. A product-level prefix that still
+     * resolved would win on order alone, and a multi-team product would then
+     * silently mint everything under it, which is the defect this field exists to
+     * end.
+     *
+     * THE CANDIDATE SET IS THE UNION OF DECLARED AND OBSERVED PREFIXES. A
+     * declaration adds a candidate; it does not remove one. A prefix stops being
+     * offered only when something claims it or when nothing has ever minted under
+     * it, and while more than one candidate stands the create surface keeps asking.
+     *
+     * WHY THIS WAS NARROWED, stated because 0.33.0 shipped the wider reading and an
+     * implementer built against it. The paragraph above made ANY declaration replace
+     * the candidate set outright, and its own stated rationale is entirely about
+     * `product.key_prefix`: a SINGLE STRING, declared once, that cannot represent
+     * two teams. An OBSERVED prefix is not that. It is evidence of a namespace
+     * already in active use. Suppressing it reproduces the precise defect this field
+     * exists to end, inside one product, and does so silently. Measured on the only
+     * keyed graph in the estate: it carries two observed prefixes, 370 keys under
+     * one and 662 under the other, and declares neither. Under the wider reading,
+     * one team declaring the smaller prefix collapses the candidate set to it, the
+     * picker disappears, and every later create mints under it, including the 662
+     * keys' worth of work belonging to the other namespace. The sentence over-reached
+     * beyond its own reason, and this narrows it back to that reason.
+     *
+     * Shipped as a CHANGE in 0.34.0 rather than as a patch correction. Read as a
+     * correction it is defensible, but implementers had already built to the wider
+     * text, and moving a contract under them in a patch is how a patch becomes a
+     * surprise.
      *
      * A DECLARED PREFIX IS A CANDIDATE BEFORE IT IS OBSERVED. Candidates derived
      * only from keys that already exist cannot see a team's first create, which is
-     * the one that most needs asking about.
+     * the one that most needs asking about. That is why declaration ADDS to the
+     * candidate set; it is not a reason for it to subtract.
      *
      * UNIQUENESS IS PRODUCT-SCOPED, AND A TEAM PREFIX DOES NOT WIDEN IT. The key
      * sequence runs per product across entity types, so two teams in one product
@@ -17683,6 +18166,82 @@ interface TeamProperties {
      * citation, with nothing objecting. Portfolio-shared team minting is DEFERRED
      * until a supra-product uniqueness design exists, rather than approximated.
      *
+     * HOW RULE 1 IS DECIDED: THE EVIDENCE RULE (normative, 0.34.0). Rule 1 names a
+     * first product without saying how a minter knows which one it is. It is decided
+     * by EVIDENCE, not by a stored marker: at mint, if any other IN-SCOPE product
+     * already holds a key under the prefix, refuse. Evidence is derivable from the
+     * graphs themselves, needs no migration, cannot go stale, and cannot disagree
+     * with the keys. A durable home marker could do all three, and would mint state
+     * for a fact the graph already carries. The cost is stated rather than hidden:
+     * evidence is SCOPE-DEPENDENT, which is why the scope is ruled below in the same
+     * breath rather than left open.
+     *
+     * THE UNDECIDABLE CASE: NEITHER MINTS (normative, 0.34.0). When two products
+     * already hold keys under one prefix and nothing establishes which was first,
+     * NEITHER mints. No tiebreak is invented. Creation order is not recorded, and
+     * `max(existing)` measures import volume rather than precedence, so any tiebreak
+     * would be a guess wearing a rule, and a silent one, since it would attribute a
+     * namespace to a product with nothing to say it was wrong. Refusing both is the
+     * NO-KEY outcome rule 2 already sanctions, and it is recoverable: once either
+     * product declares the prefix, the other is unambiguous and a backfill can run.
+     *
+     * WHAT "IN SCOPE" MEANS: ENGINE-DEFINED, WITH A FLOOR AND A CEILING (normative,
+     * 0.34.0). The scope over which the evidence rule looks is defined by the
+     * engine, bounded on both sides.
+     *
+     *   FLOOR. It MUST include every product the engine can enumerate for this
+     *   caller. An engine that looks at fewer products than it can see is choosing
+     *   not to notice a collision it could have seen.
+     *
+     *   CEILING. It MUST NEVER include a product the caller could not otherwise
+     *   read. A wider read is a cross-tenant information channel: refusing a mint
+     *   because of a key in a graph the caller cannot see leaks that the graph
+     *   exists and what is in it. This half is a security constraint and is not
+     *   negotiable.
+     *
+     * PORTFOLIO ALTITUDE IS THE WRONG NORMATIVE ALTITUDE, and it was measured rather
+     * than argued: deleting the portfolio document changes nothing about minting,
+     * because no minter consults the portfolio seam. Stating the invariant there
+     * states it where nobody looks. In practice the local engine's scope is every
+     * graph in the workspace folder and the cloud engine's is the caller's own
+     * product list.
+     *
+     * THE HONEST CONSEQUENCE, which belongs in the text rather than in a later
+     * surprise: the invariant is SCOPE-RELATIVE. Two engines can legitimately
+     * disagree about whether one mint is safe, because they can legitimately see
+     * different sets of products. That is a real limitation of the evidence rule and
+     * the price of the ceiling.
+     *
+     * IMMUTABLE ONCE ANYTHING HAS MINTED UNDER IT, PER PRODUCT (normative, 0.34.0).
+     * Once any key exists under this prefix IN A GIVEN PRODUCT, the declaration
+     * cannot be edited for that product. Refusal-shaped and NO-KEY, matching rule 2:
+     * never an exception, because a keyless create is legal everywhere else in the
+     * ladder.
+     *
+     *   SCOPED PER PRODUCT, NOT PER TEAM, and the reason is that `team` is
+     *   `portfolio_shared`: a team that has never minted in product B must still be
+     *   free to declare there. A per-team global lock would strand it.
+     *
+     *   WHAT IT PREVENTS. Without it, a team edits its prefix after four hundred
+     *   mints and one product silently carries two number lines under two names,
+     *   with nothing recording that they were ever one sequence.
+     *
+     *   RENAMING STAYS POSSIBLE BY THE HONEST ROUTE: a migration that rewrites the
+     *   existing keys. That is a deliberate act with a visible cost, which is the
+     *   difference between renaming a namespace and forking it by accident.
+     *
+     * THE PICKER MAY OFFER WHAT THE MINT REFUSES, AND THE SURFACE OWNS THE
+     * DIVERGENCE (0.34.0). Rule 3 applies on the MINT path and not the picker path,
+     * which is deliberate: the picker cannot cheaply know the answer, since knowing
+     * it requires reading other products. The consequence is that a surface can
+     * present a choice that then fails. The owner is named here rather than left
+     * implicit: A CREATE SURFACE THAT OFFERS A PREFIX THE MINT MAY REFUSE MUST BE
+     * ABLE TO REPORT THE REFUSAL, AND MUST BE ABLE TO PRESENT NO-KEY AS AN OUTCOME
+     * RATHER THAN AS AN ERROR. This is a design obligation on the surface, not a
+     * spec mechanic: the spec cannot fix a UX gap and should not pretend to. The
+     * union ruling above shrinks the divergence considerably, because the picker now
+     * keeps asking in exactly the case that would otherwise resolve wrongly.
+     *
      * This rule states the CONTRACT. The behaviour belongs to whatever mints keys,
      * which is not this package: see `UPGBaseNode.key`.
      *
@@ -17737,6 +18296,11 @@ interface PersonProperties {
     /** IANA time zone (e.g. "Europe/Berlin"). Useful for capacity / on-call planning. */
     time_zone?: string;
 }
+/**
+ * Which way a stakeholder leans. Pairs with `UPG_ENUM_SCALES.EngagementPosture`
+ * for per-value labels and descriptions.
+ */
+type EngagementPosture = 'champion' | 'supporter' | 'neutral' | 'skeptic' | 'blocker';
 /** Stakeholder entity.
  *
  * @example
@@ -17744,6 +18308,8 @@ interface PersonProperties {
  *   stakeholder_type: 'internal',
  *   influence: 4,
  *   interest: 4,
+ *   engagement_posture: 'skeptic',
+ *   engagement_cadence: 'monthly',
  * }
  */
 interface StakeholderProperties {
@@ -17753,6 +18319,30 @@ interface StakeholderProperties {
     influence?: UPGAssessment;
     /** How much interest this stakeholder has in the outcome (1 = passive, 5 = deeply invested) */
     interest?: UPGAssessment;
+    /**
+     * Which way this stakeholder leans: actively for, actively against, or
+     * neither. The third axis of the stakeholder model (0.35.0), beside the
+     * power/interest grid `influence` and `interest` describe.
+     * @remarks
+     * `influence` and `interest` are magnitudes and carry no direction: a
+     * high-influence, high-interest stakeholder can be the strongest champion or
+     * the one who kills it, and the grid renders them identically. This closed
+     * enum is what makes "who blocks this?" a query rather than a reading
+     * exercise. Pairs with `UPG_ENUM_SCALES.EngagementPosture`. Posture is about
+     * the person's stance; it is NOT delivery health, which belongs to work
+     * items, and NOT the relationship's operational state.
+     */
+    engagement_posture?: EngagementPosture;
+    /**
+     * How often this stakeholder is engaged. Uses the shared `Cadence` scale.
+     * @remarks
+     * Typed as `Cadence` rather than free text on purpose: v0.4.0 introduced that
+     * enum precisely to retire strings like `"2x/week"`, and a cadence that
+     * cannot be compared across stakeholders cannot answer "who have we not
+     * spoken to this quarter?". WHERE you meet them (the channel) is an
+     * app-level concern and is deliberately not modelled here.
+     */
+    engagement_cadence?: Cadence;
 }
 /** TeamOkr entity.
  *
@@ -21062,16 +21652,43 @@ interface UPGViewEdgeClause {
  * and which still could not express "not (A and B)" as distinct from "(not A)
  * and (not B)". A uniform clause list carries it with one flag.
  *
+ * A DISCRIMINATED UNION ON `dimension` SINCE 0.34.0, and the reason is that the
+ * two tiers disagreed about types. `values` was `string[]` while the shorthand
+ * `UPGViewQuery.types` is `UPGEntityType[]`, so the FAITHFUL tier admitted a
+ * value the SHORTHAND tier could not describe, and a round-trip through the
+ * shorthand could silently narrow what the clause list said. The shipped example
+ * `{ dimension: 'type', values: ['task', 'bug'] }` puts both halves on one line.
+ * The field evidence is a cast at exactly that boundary in the first consumer,
+ * carrying the comment "the clause list is the authority" — a cast is the tell
+ * that the author knew the tiers disagreed and had to assert past it.
+ *
+ * THIS IS A COMPILE-TIME BREAK AND CALLING IT ADDITIVE WOULD BE DISHONEST. The
+ * WIRE FORMAT does not change at all: the JSON is identical, so there is no
+ * migration, no fixture and no canonical-format entry. What changes is that a
+ * TypeScript consumer writing a plain `string[]` on a `type` clause stops
+ * compiling. Two measured facts make that acceptable: the field shipped ONE
+ * release ago, and the only known consumer already casts at this exact boundary,
+ * so the break lands where someone has already written down why the tiers
+ * disagree. A stated break with one known site is better than a silent narrowing
+ * with none, which is what shipping nothing preserves.
+ *
+ * THE ROUND-TRIP NARROWING RULE (normative, and it holds regardless of the
+ * union, because a union constrains AUTHORS and not JSON arriving from a file).
+ * The clause list is AUTHORITATIVE. The named shorthand fields on
+ * {@link UPGViewQuery} are a positive-only PROJECTION of it. A consumer that
+ * rewrites clauses into shorthand and back MUST NOT narrow the admitted set, and
+ * MUST REFUSE rather than narrow when it cannot represent a clause. Silently
+ * dropping what it cannot express is the one behaviour this rule forbids.
+ *
  * @example
  * const c: UPGViewClause = { dimension: 'tag', values: ['spike'], negate: true }
+ *
+ * @example
+ * const t: UPGViewClause = { dimension: 'type', values: ['task', 'bug'] }
  */
-interface UPGViewClause {
-    /** The axis this clause selects on. */
-    dimension: UPGViewDimension;
+interface UPGViewClauseBase {
     /** Property name when `dimension` is `property`; the date field when `date`. */
     field?: string;
-    /** Admitted values. */
-    values?: string[];
     /** Present exactly when `dimension` is `date`. */
     window?: UPGTimeWindow;
     /** Present exactly when `dimension` is `edge`. */
@@ -21079,6 +21696,19 @@ interface UPGViewClause {
     /** Negates this clause and only this clause. */
     negate?: boolean;
 }
+/** A clause on the `type` axis. `values` are entity types, not free strings. */
+interface UPGViewTypeClause extends UPGViewClauseBase {
+    dimension: 'type';
+    /** Admitted entity types. */
+    values?: UPGEntityType[];
+}
+/** A clause on any axis other than `type`, whose admitted values are strings. */
+interface UPGViewGenericClause extends UPGViewClauseBase {
+    dimension: Exclude<UPGViewDimension, 'type'>;
+    /** Admitted values. */
+    values?: string[];
+}
+type UPGViewClause = UPGViewTypeClause | UPGViewGenericClause;
 /** A declarative, portable selection over the graph.
  *
  * Selection ONLY. What a surface should look like once the nodes are chosen is
@@ -21223,6 +21853,45 @@ interface UPGViewPresentation {
      * A consumer may ignore this entirely, render flat, and remain conformant.
      */
     nest_by?: string[];
+    /**
+     * What to do with a selected member the nest relation does not reach.
+     * Absent means `'root'`.
+     *
+     * @remarks
+     * THE ASYMMETRY THIS CLOSES. 0.33.0's `nest_by` made NESTING portable and left
+     * the FAILURE of nesting unportable. A member the scope selected that the nest
+     * relation cannot reach may be drawn as an additional root or silently omitted,
+     * both conformant, and the spec could not say which the author meant.
+     *
+     * ABSENT MEANS `'root'`, deliberately, and this is the whole safety argument. A
+     * consumer that ignores this field must never silently DROP a node the scope
+     * admitted. Measured on a real imported tracker graph of 1,118 nodes and 3,685
+     * edges: one tree selects 218 members and renders ONE card under `hide`; three
+     * more go 185 to 1, and one goes 11 to 1. Under absent-means-hide a conformant
+     * consumer renders a blank tree over 218 matching nodes with no way to tell the
+     * author anything is missing. Under absent-means-root, "everything the scope
+     * admits is visible somewhere" becomes a checkable invariant, and the majority
+     * (51 of 57 registry trees prefer hiding) pays for hiding EXPLICITLY — which is
+     * the right way round for a default that decides whether data disappears.
+     *
+     * The orphans ARE the dataset rather than an edge case, and the cause is
+     * structural: tracker-imported work wires through cycle and project relations,
+     * which are reference-axis edges, never nesting, so the containment edges these
+     * trees traverse do not reach it.
+     *
+     * WHY THIS IS SPEC AND NOT APPLICATION CHASSIS, which the filing author first
+     * concluded and measurement overturned. Running the two dispositions changes
+     * WHICH NODES APPEAR, not where pixels go. Presentation is advisory precisely
+     * because a consumer may ignore it and stay conformant, and a field that
+     * decides membership visibility cannot be ignored safely. Selection-class facts
+     * belong in the spec; that is the line, and the measurement is what located it.
+     *
+     * PRESENTATION STAYS ADVISORY OVERALL. This field does not break that: a
+     * consumer may ignore it and remain conformant, because the default it then
+     * applies is the safe one. That property is exactly what the absent-means-root
+     * cut buys.
+     */
+    orphan_disposition?: 'root' | 'hide';
 }
 /** A layer whose membership is produced by a query rather than by placement.
  *
@@ -21244,7 +21913,10 @@ interface UPGViewPresentation {
 interface UPGQueryDrivenLayer {
     /**
      * When present, membership is DERIVED: members are produced by running this
-     * query rather than authored by placement.
+     * query rather than authored by placement. The clause list is authoritative and
+     * the named fields are a positive-only projection of it; since 0.34.0 a clause
+     * is a discriminated union on `dimension`, so the `type` axis carries entity
+     * types rather than free strings.
      *
      * @remarks
      * This is the portable statement of what the layer shows. On a composition,
@@ -21264,8 +21936,18 @@ interface UPGQueryDrivenLayer {
      */
     member_query?: UPGViewQuery;
     /**
-     * Advisory rendering intent for the layer as a whole. A consumer may ignore it
-     * entirely and still be conformant.
+     * Advisory rendering intent for the layer as a whole: `group_by`, `sort`,
+     * `layout`, `nest_by`, and `orphan_disposition` (0.34.0, absent means
+     * `'root'`). A consumer may ignore it entirely and still be conformant,
+     * because every default it then applies is the safe one.
+     *
+     * @remarks
+     * THE DESCRIPTION LISTS THE FIELDS ON PURPOSE. This property is `object` in the
+     * runtime property registry, so an agent reading `get_entity_schema` gets an
+     * opaque blob and this sentence. For an object-typed property the description IS
+     * the declared shape, which is why `check:editorial` hashes it (E.4, 0.34.0) and
+     * why a field added to `UPGViewPresentation` without a word here would be
+     * invisible to every gate and every agent at once.
      */
     presentation?: UPGViewPresentation;
 }
@@ -25923,6 +26605,47 @@ interface UPGHeader {
  * classify base fields use `UPG_BASE_NODE_FIELDS`, not this.
  */
 declare const NODE_KEY_ORDER: string[];
+/**
+ * Canonical key order for a within-graph edge.
+ *
+ * @remarks
+ * EXPORTED AT 0.34.0 so the subset assertion can be written, exactly as
+ * `NODE_KEY_ORDER` was exported at 0.33.0 and for the same reason. K1 of the
+ * 0.33.0 bundle fixed this class for nodes and left both edge twins as
+ * hand-maintained, unexported, unasserted consts — and the very next release
+ * added a field to `UPGEdge`, which is the regression the node-side assertion
+ * exists to prevent. `canonical-format.test.ts` asserts every declared `UPGEdge`
+ * key appears here. A SUBSET, never equality, for the reason the node comment
+ * gives: an equality check would fail on tolerated keys and push the next author
+ * to delete them.
+ */
+declare const EDGE_KEY_ORDER: string[];
+/**
+ * Canonical key order for a portfolio cross-product edge. The third instance of
+ * the class `NODE_KEY_ORDER` fixed at 0.33.0, exported at 0.34.0 with the same
+ * subset assertion.
+ *
+ * @remarks
+ * NO `provenance` ENTRY, deliberately. 0.34.0 added `provenance?` to `UPGEdge`
+ * and NOT to `UPGCrossEdge`, so an entry here would order a key that cannot be
+ * written. The assertion is the point of touching this const at all: it is the
+ * direction that can regress, and the next field added to `UPGCrossEdge` now
+ * cannot go unordered.
+ *
+ * `properties` WAS MISSING UNTIL 0.34.0, and the new assertion found it on its
+ * first run. It has been declared on `UPGCrossEdge` since 0.10.0 (the parity
+ * assessment a `feature_rivals_competitor_feature` cross-edge carries), and it
+ * fell through to the sorted-tail pass instead: deterministic, so nothing was
+ * corrupt, but positioned alphabetically among unlisted keys rather than in the
+ * slot the shape implies. That is precisely the regression the node twin got a
+ * guard for at 0.33.0, sitting unnoticed in the edge twin for eleven minors.
+ *
+ * Measured before changing it, because a canonical-order edit rewrites bytes:
+ * across all 61 cross-edges in the estate, ZERO carry `properties`. So no file
+ * re-serialises differently and the fix is free today, which it would not have
+ * been after the first parity assessment landed.
+ */
+declare const CROSS_EDGE_KEY_ORDER: string[];
 /** Element counts for a single-product document, as stamped into `$upg.counts`. */
 declare function deriveSingleCounts(doc: UPGDocument): Record<string, number>;
 /**
@@ -26063,7 +26786,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.33.1";
+declare const UPG_VERSION: "0.35.0";
 /**
  * The `.upg` JSON document format version. Written to the `upg_version` field.
  * Evolves independently from `UPG_VERSION` (the catalogue version).
@@ -26187,5 +26910,38 @@ declare const UPG_EDGE_COUNT: number;
  * gap is the deprecated-alias set.
  */
 declare const UPG_META_COUNT: number;
+/**
+ * How much lifecycle vocabulary the spec defines: the number of DISTINCT
+ * (template, phase) pairs across `UPG_LIFECYCLES`.
+ *
+ * @remarks
+ * WHAT IT COUNTS, and the definition IS the decision. A lifecycle is either
+ * generated from a reusable template (`template_id` set) or hand-authored for one
+ * entity type. Two entity types sharing the `OPERATIONAL` template have not
+ * defined its phases twice, so the pair is keyed on the TEMPLATE where there is
+ * one and on the ENTITY TYPE where there is not.
+ *
+ * WHY NOT THE OTHER TWO CANDIDATES, both of which were live when this was wired:
+ *
+ *   869 — every phase row across all 193 lifecycles. The literal size of the
+ *   grammar, and it double-counts a template reused by nine entity types. The
+ *   number appears in prose as a claim about how much vocabulary the spec HAS,
+ *   which is not what 869 measures.
+ *
+ *   334 — carried in planning documents since 0.32.0 and never computed by
+ *   anything. It does not reproduce under either real computation. It was
+ *   transcribed forward, which is exactly the failure `check:count-drift` exists
+ *   to end, and it is recorded here so nobody restores it.
+ *
+ * WIRED INTO `check:count-drift` AT 0.34.0. The condition was declared met in the
+ * 0.33.0 CHANGELOG and deferred on the ground that adding a check would change
+ * the shape of a release ratified as adding none. That ground is gone. Until now
+ * this was the one figure in the truth line that no check asserted, which is why
+ * it is also the one that drifted.
+ *
+ * Derived, never a literal: the count and any docket or CHANGELOG row quoting it
+ * come from this computation, so two numbers cannot be derived twice.
+ */
+declare const UPG_PHASE_COUNT: number;
 
-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 CaptureProperties, 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 CompositionMember, type CompositionProperties, 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 FrameworkSlotPredicate, type FrameworkSlotPredicateAtom, 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 MetricScore, type MetricSegmentType, type MetricStatisticalFunction, type MilestoneProperties, type MissionProperties, type ModelComparisonProperties, type ModifiedProperty, type MonitorProperties, NODE_KEY_ORDER, 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 PathResolution, 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 RelationalColumn, type RelationalComputedColumn, type RelationalEdgeStep, type RelationalFieldColumn, type RelationalProjectionColumn, type RelationalSurfaceSpec, type RelationshipBenchmark, type RelationshipCheck, type ReleaseProperties, type ReleaseStrategyProperties, type ReportProperties, type ResearchPlanProperties, type ResearchQuestionProperties, type ResearchStudyProperties, type ResolvedStep, 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 UPGExternalLink, 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 UPGQueryDrivenLayer, 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 UPGTimeWindow, 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 UPGViewClause, type UPGViewDimension, type UPGViewEdgeClause, type UPGViewPredicate, type UPGViewPresentation, type UPGViewQuery, 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_BASE_NODE_FIELDS, UPG_BASE_NODE_FIELD_SET, UPG_BASE_NODE_SPECIAL_MERGE_FIELDS, 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, WORKSPACE_ARRANGEMENT_EDGE_PROPERTY_SCHEMA, type WalkMigrationChainResult, type WalkthroughProperties, type WebinarProperties, type WireframeProperties, type WorkflowArtifactProperties, type WorkflowRunProperties, type WorkflowTemplateProperties, type WorkspaceCanvas, 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, predicatesProvablyDisjoint, presenceExceptKey, projectGraph, readActiveWhen, readStringArray, relationalCoveredEntityTypes, resolveAllEdges, resolveContainmentEdge, resolveEntityType, resolveLabel, resolveRelationalPath, 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, CROSS_EDGE_KEY_ORDER, type Cadence, type CapabilityProperties, type CapacityPlanProperties, type CaptureProperties, 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 CompositionMember, type CompositionProperties, 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, EDGE_KEY_ORDER, ENGINEERING_PLATFORM_PLAYBOOK, ENTITY_EMOJI, EXPERIENCE_DESIGN_BRAND_PLAYBOOK, type EdgeCountVsPropertyCheck, type EducationProgramProperties, type EmailSequenceProperties, type EmptyCell, type EmptyCellRationaleKind, type EngagementPosture, 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 FrameworkSlotPredicate, type FrameworkSlotPredicateAtom, 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 MetricScore, type MetricSegmentType, type MetricStatisticalFunction, type MilestoneProperties, type MissionProperties, type ModelComparisonProperties, type ModifiedProperty, type MonitorProperties, NODE_KEY_ORDER, 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, PROPERTY_SCALE_MAP_BY_ENTITY, type ParticipantProperties, type PartnerProgramProperties, type PartnerRevenueShareProperties, type PartnerTierProperties, type PartnershipProperties, type PathResolution, 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 RelationalColumn, type RelationalComputedColumn, type RelationalEdgeStep, type RelationalFieldColumn, type RelationalProjectionColumn, type RelationalSurfaceSpec, type RelationshipBenchmark, type RelationshipCheck, type ReleaseProperties, type ReleaseStrategyProperties, type ReportProperties, type ResearchPlanProperties, type ResearchQuestionProperties, type ResearchStudyProperties, type ResolvedStep, 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 UPGEdgeProvenance, type UPGEdgeType, type UPGEntityFilterSpec, type UPGEntityType, type UPGEntityTypeMaturity, type UPGEnumScaleDefinition, type UPGEnumScaleValue, type UPGExternalLink, 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 UPGQueryDrivenLayer, 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 UPGTimeWindow, 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 UPGViewClause, type UPGViewDimension, type UPGViewEdgeClause, type UPGViewGenericClause, type UPGViewPredicate, type UPGViewPresentation, type UPGViewQuery, type UPGViewTypeClause, 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_BASE_NODE_FIELDS, UPG_BASE_NODE_FIELD_SET, UPG_BASE_NODE_SPECIAL_MERGE_FIELDS, 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_DESCRIPTIONS, 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_PHASE_COUNT, UPG_PLAYBOOKS, UPG_POLYMORPHIC_EDGE_FAMILIES, 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, WORKSPACE_ARRANGEMENT_EDGE_PROPERTY_SCHEMA, type WalkMigrationChainResult, type WalkthroughProperties, type WebinarProperties, type WireframeProperties, type WorkflowArtifactProperties, type WorkflowRunProperties, type WorkflowTemplateProperties, type WorkspaceCanvas, 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, getEntityDescription, 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, predicatesProvablyDisjoint, presenceExceptKey, projectGraph, readActiveWhen, readStringArray, relationalCoveredEntityTypes, resolveAllEdges, resolveContainmentEdge, resolveEntityType, resolveLabel, resolveRelationalPath, resolveSlugCollision, resolveTreePatternEdges, ringOrderedDomainIds, rotateSlug, serializeCanonical, validateEdgeProperties, validateProductStageStrict, validateUPGDocument, validateUPGFramework, validationProfileFor, walkMigrationChainToCanonical };