diff --git a/libs/features/jsonld-graph-manager/jsonld-graph-manager.js b/libs/features/jsonld-graph-manager/jsonld-graph-manager.js
new file mode 100644
index 00000000000..8075175ccd9
--- /dev/null
+++ b/libs/features/jsonld-graph-manager/jsonld-graph-manager.js
@@ -0,0 +1,433 @@
+/* eslint-disable no-use-before-define, no-continue */
+import { debounce } from '../../utils/action.js';
+
+const MANAGED_ATTR = 'data-milo-jsonld';
+const MANAGED_VAL = 'graph';
+const MANAGED_SEL = `script[type="application/ld+json"][${MANAGED_ATTR}="${MANAGED_VAL}"]`;
+const UNMANAGED_SEL = `script[type="application/ld+json"]:not([${MANAGED_ATTR}="${MANAGED_VAL}"])`;
+const DEBOUNCE_MS = 1000;
+const REF_ARRAY_KEYS = new Set(['hasPart', 'mainEntity', 'itemListElement']);
+
+const RULES = {
+  WebPage: {
+    idFragment: '#webpage',
+    singleton: true,
+    root: true,
+    links: { publisher: 'Organization', breadcrumb: 'BreadcrumbList' },
+  },
+  Organization: { idSuffix: '/#organization', siteScoped: true, singleton: true },
+  Article: {
+    idFragment: '#article',
+    linksBack: { isPartOf: 'WebPage', mainEntityOfPage: 'WebPage', publisher: 'Organization' },
+  },
+  BreadcrumbList: {
+    idFragment: '#breadcrumb',
+    singleton: true,
+    linksBack: { isPartOf: 'WebPage' },
+  },
+  SoftwareApplication: {
+    idFragment: '#softwareapplication',
+    linksBack: { provider: 'Organization' },
+  },
+  HowTo: { idFragment: '#howto', linksBack: { isPartOf: 'WebPage' } },
+  FAQPage: { idFragment: '#faq', linksBack: { isPartOf: 'WebPage' } },
+  VideoObject: { idFragment: '#videoobject', repeatable: true },
+  Event: { idFragment: '#event' },
+  Offer: { idFragment: '#offer', repeatable: true },
+  AggregateRating: { idFragment: '#aggregaterating', singleton: true },
+};
+
+const TYPE_TRANSFORMS = { Product: 'SoftwareApplication' };
+
+const SOFTWARE_APP_SUBTYPES = new Set(['WebApplication', 'MobileApplication', 'VideoGame']);
+
+const ORG_ID_ALIASES = new Set(['#org', '#publisher', '#adobe']);
+
+export function siteRoot(hostname = window.location.hostname) {
+  return /business|bacom/i.test(hostname)
+    ? 'https://business.adobe.com'
+    : 'https://www.adobe.com';
+}
+
+const ADOBE_CORPORATE_LOGO = 'https://www.adobe.com/content/dam/cc/icons/Adobe_Corporate_Horizontal_Red_HEX.svg';
+
+export function defaultOrg(hostname) {
+  const root = siteRoot(hostname);
+  const isBusiness = root.includes('business');
+  return {
+    '@type': 'Organization',
+    '@id': `${root}/#organization`,
+    name: isBusiness ? 'Adobe for Business' : 'Adobe',
+    url: `${root}/`,
+    logo: {
+      '@type': 'ImageObject',
+      url: ADOBE_CORPORATE_LOGO,
+      contentUrl: ADOBE_CORPORATE_LOGO,
+    },
+  };
+}
+
+export function canonicalUrl() {
+  const link = document.head.querySelector('link[rel="canonical"]');
+  if (link?.href) {
+    const u = new URL(link.href);
+    return `${u.origin}${u.pathname}`;
+  }
+  const u = new URL(window.location.href);
+  return `${u.origin}${u.pathname}`;
+}
+
+export function pageScopedId(type) {
+  const rule = RULES[type];
+  if (!rule) return null;
+  if (rule.siteScoped) return `${siteRoot()}${rule.idSuffix}`;
+  return `${canonicalUrl()}${rule.idFragment}`;
+}
+
+export function flattenPayload(data) {
+  if (!data || typeof data !== 'object') return [];
+  if (Array.isArray(data)) return data;
+  if (data['@graph']) return Array.isArray(data['@graph']) ? data['@graph'] : [data['@graph']];
+  return [data];
+}
+
+export function parsePayload(scriptEl) {
+  try {
+    const data = JSON.parse(scriptEl.textContent);
+    return flattenPayload(data);
+  } catch (e) {
+    lanaLog(`Failed to parse JSON-LD: ${e.message}`, 'warn');
+    return [];
+  }
+}
+
+export function normalizeNode(node) {
+  const out = { ...node };
+  delete out['@context'];
+  if (TYPE_TRANSFORMS[out['@type']]) out['@type'] = TYPE_TRANSFORMS[out['@type']];
+  const type = out['@type'];
+  if (!type) return out;
+  if (SOFTWARE_APP_SUBTYPES.has(type)) {
+    out['@id'] = pageScopedId('SoftwareApplication');
+    return out;
+  }
+  const rule = RULES[type];
+  if (!rule) return out;
+  out['@id'] = pageScopedId(type);
+  return out;
+}
+
+export function canonicalizeOrgId(id) {
+  if (typeof id !== 'string') return id;
+  const hashIdx = id.lastIndexOf('#');
+  if (hashIdx < 0) return id;
+  const fragment = id.slice(hashIdx);
+  if (!ORG_ID_ALIASES.has(fragment)) return id;
+  const root = id.slice(0, hashIdx).replace(/\/$/, '');
+  return `${root}/#organization`;
+}
+
+export function canonicalizeReferences(node) {
+  for (const v of Object.values(node)) {
+    if (Array.isArray(v)) {
+      for (const item of v) {
+        if (item && typeof item === 'object') canonicalizeReferences(item);
+      }
+    } else if (v && typeof v === 'object') {
+      if (v['@id'] && !v['@type']) v['@id'] = canonicalizeOrgId(v['@id']);
+    }
+  }
+}
+
+const PARENT_PAGE_PROPS = ['isPartOf', 'mainEntityOfPage'];
+
+function maybeRewriteWebPageRef(val) {
+  if (!val || typeof val !== 'object' || Array.isArray(val)) return val;
+  const isInlineWebPage = val['@type'] === 'WebPage';
+  const id = val['@id'];
+  const looksLikeWebPageRef = typeof id === 'string' && id.endsWith('#webpage');
+  if (isInlineWebPage || looksLikeWebPageRef) {
+    return { '@id': pageScopedId('WebPage') };
+  }
+  return val;
+}
+
+export function rewriteCrossPageRefs(node) {
+  for (const prop of PARENT_PAGE_PROPS) {
+    const val = node[prop];
+    if (val == null) continue;
+    if (Array.isArray(val)) {
+      const rewritten = val.map(maybeRewriteWebPageRef);
+      node[prop] = rewritten.length === 1 ? rewritten[0] : rewritten;
+    } else {
+      node[prop] = maybeRewriteWebPageRef(val);
+    }
+  }
+}
+
+function asArray(v) {
+  if (v == null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+
+export function unionByRef(a, b) {
+  const arrA = asArray(a);
+  const arrB = asArray(b);
+  const seen = new Set(arrA.map((n) => n['@id'] ?? JSON.stringify(n)));
+  const result = [...arrA];
+  for (const item of arrB) {
+    const key = item['@id'] ?? JSON.stringify(item);
+    if (!seen.has(key)) { seen.add(key); result.push(item); }
+  }
+  return result;
+}
+
+function priorityWeight(src) {
+  if (src === 'generated') return 2;
+  if (src === 'runtime') return 1;
+  return 0;
+}
+
+export function mergeNodes(a, b, srcA, srcB) {
+  const aWins = priorityWeight(srcA) >= priorityWeight(srcB);
+  const [winner, loser] = aWins ? [a, b] : [b, a];
+  const winnerSrc = aWins ? srcA : srcB;
+  const loserSrc = aWins ? srcB : srcA;
+  const out = { ...loser, ...winner };
+  for (const key of Object.keys(loser)) {
+    if (['@type', '@id', '@context'].includes(key)) continue;
+    const vW = winner[key];
+    const vL = loser[key];
+    if (!(key in winner)) { out[key] = vL; continue; }
+    if (REF_ARRAY_KEYS.has(key) || Array.isArray(vW) || Array.isArray(vL)) {
+      out[key] = unionByRef(vW, vL);
+    } else if (vW !== null && vL !== null && typeof vW === 'object' && typeof vL === 'object') {
+      out[key] = mergeNodes(vW, vL, winnerSrc, loserSrc);
+    }
+  }
+  const subtype = [a['@type'], b['@type']].find((t) => SOFTWARE_APP_SUBTYPES.has(t));
+  if (subtype && [a['@type'], b['@type']].some((t) => t === 'SoftwareApplication' || SOFTWARE_APP_SUBTYPES.has(t))) {
+    out['@type'] = subtype;
+  }
+  return out;
+}
+
+function effectiveType(t) {
+  return SOFTWARE_APP_SUBTYPES.has(t) ? 'SoftwareApplication' : t;
+}
+
+export function injectLinks(nodes) {
+  const byType = {};
+  for (const node of nodes) {
+    const t = node['@type'];
+    if (!t) continue;
+    if (!byType[t]) byType[t] = node;
+    const eff = effectiveType(t);
+    if (eff !== t && !byType[eff]) byType[eff] = node;
+  }
+  for (const node of nodes) {
+    const rule = RULES[effectiveType(node['@type'])];
+    if (!rule?.linksBack) continue;
+    for (const [prop, targetType] of Object.entries(rule.linksBack)) {
+      const target = byType[targetType];
+      if (target?.['@id'] && !node[prop]) node[prop] = { '@id': target['@id'] };
+    }
+  }
+  const webpage = byType.WebPage;
+  if (webpage) {
+    for (const [prop, targetType] of Object.entries(RULES.WebPage.links ?? {})) {
+      const target = byType[targetType];
+      if (target?.['@id'] && !webpage[prop]) webpage[prop] = { '@id': target['@id'] };
+    }
+    if (!webpage.mainEntity) {
+      const primary = byType.Article ?? byType.NewsArticle ?? byType.SoftwareApplication;
+      if (primary?.['@id']) webpage.mainEntity = { '@id': primary['@id'] };
+    }
+  }
+}
+
+function sortNodes(nodes) {
+  const order = ['WebPage', 'Organization', 'Article', 'SoftwareApplication', 'BreadcrumbList'];
+  return [...nodes].sort((a, b) => {
+    const ai = order.indexOf(a['@type'] ?? '');
+    const bi = order.indexOf(b['@type'] ?? '');
+    return (ai === -1 ? order.length : ai) - (bi === -1 ? order.length : bi);
+  });
+}
+
+const ENTITY_PROPS = ['publisher', 'author', 'creator', 'provider', 'brand', 'seller', 'offers', 'itemOffered', 'aggregateRating'];
+
+function extractEntity(val) {
+  if (!val || typeof val !== 'object' || Array.isArray(val) || !val['@type']) return null;
+  if (!RULES[val['@type']] && !TYPE_TRANSFORMS[val['@type']]) return null;
+  const normalized = normalizeNode(val);
+  return normalized['@id'] ? normalized : null;
+}
+
+export function extractInlineEntities(node) {
+  const extracted = [];
+  for (const prop of ENTITY_PROPS) {
+    const val = node[prop];
+    if (val == null) continue;
+    if (Array.isArray(val)) {
+      node[prop] = val.map((item) => {
+        const ent = extractEntity(item);
+        if (!ent) return item;
+        extracted.push(ent);
+        return { '@id': ent['@id'] };
+      });
+    } else {
+      const ent = extractEntity(val);
+      if (ent) {
+        extracted.push(ent);
+        node[prop] = { '@id': ent['@id'] };
+      }
+    }
+  }
+  return extracted;
+}
+
+const DEBUG = new URLSearchParams(window.location.search).get('jsonld-graph-manager-debug') === 'true';
+
+function debugLog(label, fn) {
+  if (!DEBUG) return;
+  // eslint-disable-next-line no-console
+  console.log('[jsonld-graph-manager]', label, fn());
+}
+
+function lanaLog(msg, severity = 'info') {
+  window.lana?.log(`JSON-LD: ${msg}`, { tags: 'jsonld-graph-manager', severity });
+  const { hostname, search } = window.location;
+  if (hostname === 'localhost' || hostname.endsWith('.page') || new URLSearchParams(search).has('lanadebug')) {
+    // eslint-disable-next-line no-console
+    if (severity === 'error') console.error(`JSON-LD: ${msg}`);
+    // eslint-disable-next-line no-console
+    else if (severity === 'warn') console.warn(`JSON-LD: ${msg}`);
+  }
+}
+
+export class JsonLdGraphManager {
+  constructor() {
+    this.graph = new Map();
+    this.sources = new Map();
+    this.queue = [];
+    this.observer = null;
+    this.isProcessing = false;
+    this.debouncedRebuild = debounce(() => this.rebuild(), DEBOUNCE_MS);
+  }
+
+  init() {
+    document.querySelectorAll(UNMANAGED_SEL).forEach((el) => this.enqueue(el, 'bootDom'));
+
+    this.observer = new MutationObserver((mutations) => {
+      for (const { addedNodes } of mutations) {
+        for (const node of addedNodes) this.collect(node);
+      }
+    });
+    this.observer.observe(document.documentElement, { childList: true, subtree: true });
+
+    this.rebuild();
+  }
+
+  destroy() {
+    this.observer?.disconnect();
+    this.observer = null;
+  }
+
+  collect(node) {
+    if (node.nodeType !== Node.ELEMENT_NODE) return;
+    if (node.matches?.(MANAGED_SEL)) return;
+    if (node.matches?.('script[type="application/ld+json"]')) {
+      this.enqueue(node, 'runtime');
+      return;
+    }
+    node.querySelectorAll?.(UNMANAGED_SEL).forEach((el) => this.enqueue(el, 'runtime'));
+  }
+
+  enqueue(scriptEl, source = 'runtime') {
+    debugLog('enqueue', () => ({
+      source,
+      location: `${scriptEl.parentElement?.tagName ?? 'detached'} > script`,
+      payload: scriptEl.textContent.trim(),
+    }));
+    this.queue.push({ scriptEl, source });
+    if (source === 'runtime') this.debouncedRebuild();
+  }
+
+  rebuild() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+    try {
+      const batch = this.queue.splice(0);
+      debugLog('rebuild', () => ({ batchSize: batch.length, graphSize: this.graph.size }));
+      for (const { scriptEl, source } of batch) {
+        const nodes = parsePayload(scriptEl);
+        debugLog('parsed', () => ({ source, types: nodes.map((n) => n['@type']), nodeCount: nodes.length }));
+        const parentTagName = scriptEl.parentElement?.tagName ?? 'already detached';
+        scriptEl.remove();
+        debugLog('removed from DOM', () => parentTagName);
+        for (const raw of nodes) {
+          const node = normalizeNode(raw);
+          const inlined = extractInlineEntities(node);
+          const toMerge = [node, ...inlined];
+          for (const n of toMerge) {
+            rewriteCrossPageRefs(n);
+            canonicalizeReferences(n);
+          }
+          for (const n of toMerge) {
+            const id = n['@id'] ?? n['@type'] ?? JSON.stringify(n);
+            const prevSrc = this.sources.get(id) ?? 'bootDom';
+            if (this.graph.has(id)) {
+              this.graph.set(id, mergeNodes(this.graph.get(id), n, prevSrc, source));
+            } else {
+              this.graph.set(id, n);
+            }
+            if (priorityWeight(source) >= priorityWeight(prevSrc)) {
+              this.sources.set(id, source);
+            }
+          }
+        }
+      }
+      this.rewrite();
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+
+  rewrite() {
+    const webpageId = pageScopedId('WebPage');
+    if (!this.graph.has(webpageId)) {
+      const url = canonicalUrl();
+      this.graph.set(webpageId, { '@type': 'WebPage', '@id': webpageId, url });
+    }
+    const org = defaultOrg();
+    const orgId = org['@id'];
+    if (!this.graph.has(orgId)) {
+      this.graph.set(orgId, org);
+      this.sources.set(orgId, 'generated');
+    } else {
+      const prevSrc = this.sources.get(orgId) ?? 'bootDom';
+      this.graph.set(orgId, mergeNodes(org, this.graph.get(orgId), 'generated', prevSrc));
+      this.sources.set(orgId, 'generated');
+    }
+    const nodes = sortNodes([...this.graph.values()]);
+    injectLinks(nodes);
+    const payload = JSON.stringify({ '@context': 'https://schema.org', '@graph': nodes }, null, 2);
+    let managed = document.head.querySelector(MANAGED_SEL);
+    if (!managed) {
+      managed = document.createElement('script');
+      managed.type = 'application/ld+json';
+      managed.setAttribute(MANAGED_ATTR, MANAGED_VAL);
+      document.head.appendChild(managed);
+    }
+    managed.textContent = payload;
+    debugLog('rewrite', () => ({ nodeCount: nodes.length, graph: nodes }));
+  }
+}
+
+export default async function init() {
+  if (window.miloJsonLdGraphManager) return;
+  const manager = new JsonLdGraphManager();
+  window.miloJsonLdGraphManager = manager;
+  manager.init();
+}
diff --git a/libs/features/jsonld-graph-manager/jsonld-graph-manager.md b/libs/features/jsonld-graph-manager/jsonld-graph-manager.md
new file mode 100644
index 00000000000..047156706cb
--- /dev/null
+++ b/libs/features/jsonld-graph-manager/jsonld-graph-manager.md
@@ -0,0 +1,995 @@
+# Milo JSON-LD Graph Manager
+
+> **Status:** DRAFT  
+
+## Summary 
+
+The JSON-LD Graph Manager is a Milo feature that collects all the JSON-LD on a page and rewrites it as **one canonical, linked `@graph`**. This centralization enables the manager to automatically apply JSON-LD graph features that may improve search engine and LLM visibility, such as cross-entity `@id` linking and singleton enforcement for certain types.
+
+The feature is **disabled by default**. To enable, set the `jsonld-graph-manager` page metadata or URL query parameter to the string `true` (case-insensitive). The string `false` explicitly disables it. Presence without a value does not enable the feature. To enable debug logging of queue lifecycle events, add `jsonld-graph-manager-debug=true` as a URL query parameter.
+
+## 1. Introduction
+
+One strategy which may improve Adobe.com visibility across search engines and LLMs is to improve the consistency of JSON-LD across pages. We can define default nodes and relate individual nodes to one another to eliminate duplicated and contradictory nested nodes. This relationship may also improve understanding. Methods include using `@id` references, `mainEntity`, `sameAs`, `isPartOf`, etc.
+
+Many Milo blocks and features produce JSON-LD. The problem is these producers write their JSON-LD to the page independently without any coordination or knowledge of each other. As of April 17, 2026 there were **33 integrations spread across 7 active sites**. Only 17 of those integrations are in `milo` itself. This makes these techniques difficult to coordinate manually.
+
+The `JsonLdGraphManager` exists to convert these entities into a single graph. Consider a product page that today emits JSON-LD from `richresults` (Article, Organization), `gnav` (BreadcrumbList), `seotech` (VideoObject). The `<head>` ends up with four independent scripts, with overlapping entity definitions and inconsistent identifiers:
+
+**Before** — `jsonld-graph-manager: false` — four isolated scripts, no links between them:
+
+```html
+<head>
+  <!-- richresults -->
+  <script type="application/ld+json">
+  {
+    "@type": "Organization",
+    "name": "Adobe",
+    "url": "https://www.adobe.com/"
+  }
+  </script>
+  <!-- richresults -->
+  <script type="application/ld+json">
+  {
+    "@type": "Article",
+    "headline": "Photoshop",
+    "author": { 
+      "@type": "Organization",
+      "name": "Adobe"
+    }
+  }
+  </script>
+  <!-- gnav -->
+  <script type="application/ld+json">
+  {
+    "@type": "BreadcrumbList",
+    "itemListElement": [ … ]
+  }
+  </script>
+  <!-- seotech -->
+  <script type="application/ld+json">
+  {
+    "@type": "VideoObject",
+    "name": "Photoshop overview"
+  }
+  </script>
+</head>
+```
+
+`Organization` is emitted twice (once standalone, once anonymous inside `Article`). Nothing links `Article` to `WebPage`.
+
+**After** — `jsonld-graph-manager: true` — one script, entities linked by `@id`:
+
+```html
+<head>
+  <script type="application/ld+json" data-milo-jsonld="graph">
+  {
+    "@context": "https://schema.org",
+    "@graph": [
+      {
+        "@type": "Organization",
+        "@id": "https://www.adobe.com/#organization",
+        "name": "Adobe"
+      },
+      {
+        "@type": "WebPage",
+        "@id": "…#webpage",
+        "publisher": { "@id": "https://www.adobe.com/#organization" },
+        "breadcrumb": { "@id": "…#breadcrumb" },
+        "mainEntity": { "@id": "…#article" }
+      },
+      {
+        "@type": "Article",
+        "@id": "…#article",
+        "headline": "Photoshop",
+        "isPartOf": { "@id": "…#webpage" },
+        "mainEntityOfPage": { "@id": "…#webpage" },
+        "publisher": { "@id": "https://www.adobe.com/#organization" }
+      },
+      {
+        "@type": "BreadcrumbList",
+        "@id": "…#breadcrumb",
+        "isPartOf": { "@id": "…#webpage" },
+        "itemListElement": [ … ]
+      },
+      {
+        "@type": "VideoObject",
+        "@id": "…#videoobject",
+        "name": "Photoshop overview"
+      }
+    ]
+  }
+  </script>
+</head>
+```
+
+`Organization` appears once and is referenced by `@id` from both `WebPage.publisher` and `Article.publisher`. `WebPage` is the graph root — it declares its `breadcrumb` and `mainEntity` by reference. `Article` links back via `isPartOf` and `mainEntityOfPage`. `BreadcrumbList` also declares `isPartOf` the `WebPage`. Every relationship is bidirectional and traversable.
+
+§3 Requirements specifies the normative rules for the managed graph. §4 Per-Type Strategy maps each supported schema.org type to its Google rich-result requirements, manager handling, and known producers in the Milo repository.
+
+## 2. Design
+
+### 2.1 Architecture Overview
+
+The `JsonLdGraphManager` is a document-level runtime object initialized from the document branch of `loadArea()` in `libs/utils/utils.js`.
+
+There are three main stages:
+
+1. **Observe** — scan the DOM at boot, and watch for later appends via `MutationObserver`. Ingest and remove unmanaged JSON-LD scripts.
+1. **Normalize** — apply canonical page-scoped identity to known entity types; merge conflicts by producer priority; dedupe singletons.
+1. **Rewrite** — serialize one `@graph` into a single managed `<script>` in `<head>`.
+
+### 2.2 Runtime Lifecycle
+
+#### Ingestion and rebuild
+
+Unmanaged JSON-LD reaches the manager through two entry points — a one-time boot scan and an ongoing `MutationObserver` — that both feed the same rebuild pipeline.
+
+**At boot**, during document-level `loadArea()`, the manager initializes a singleton instance, scans the full document for `script[type="application/ld+json"]`, ignoring its own managed graph if one already exists, and attaches a `MutationObserver` for future additions.
+
+**At runtime**, when a block, feature, experiment, or third-party script appends JSON-LD anywhere in the document subtree, the observer detects it and enqueues the event for sequential processing.
+
+Both entry points converge on the same pipeline: for each unmanaged payload, the manager parses it, normalizes discovered entities, removes the unmanaged script from the DOM, updates the in-memory graph, reruns graph transforms, and rewrites the managed script in `document.head`.
+
+```mermaid
+sequenceDiagram
+    participant L as loadArea()
+    participant P as Producer (block/feature/3p)
+    participant D as document
+    participant O as MutationObserver
+    participant Q as Queue
+    participant M as JsonLdGraphManager
+    L->>M: init() (boot)
+    M->>D: scan script[type=application/ld+json]
+    D-->>M: unmanaged scripts
+    M->>Q: enqueue initial batch
+    M->>O: attach to documentElement<br/>(childList, subtree)
+    P->>D: append script[type=application/ld+json]
+    D->>O: mutation event
+    O->>Q: enqueue (if matches filter)
+    Q->>M: process (immediate at boot, debounced after)
+    M->>M: parse, normalize,<br/>update graph, rerun transforms
+    M->>D: remove unmanaged scripts
+    M->>D: write managed script to head
+```
+
+The observer target is `document.documentElement` with `childList` and `subtree` enabled. Only added nodes that are, or contain, `script[type="application/ld+json"]` are enqueued. Managed output is excluded by filtering on the manager-owned selector `script[type="application/ld+json"][data-milo-jsonld="graph"]`.
+
+#### Queueing and rebuild policy
+
+Although JavaScript execution is single-threaded, the manager still uses an explicit queue. The queue provides:
+
+- deterministic processing order
+- protection from re-entrant writes
+- one rebuild path for all producer types
+- batching during high DOM churn
+
+The manager performs an immediate boot write, then batches later rewrites on a debounce interval. The target behavior is that rebuilds do not occur faster than roughly once per second during steady-state mutation bursts.
+
+### 2.3 Output Contract
+
+The shape of the managed `<script>` and `@graph`, including required and optional attributes, identity rules, singletons, and entity linkage, is defined in §3 Requirements. The manager's job is to produce output that satisfies every `error`-severity rule there.
+
+Accepted input forms include a single JSON-LD object, an array of JSON-LD objects, or an object containing `@graph`. All accepted forms are flattened into one internal graph representation before transforms run.
+
+Non-managed JSON-LD scripts are candidates for ingestion and removal regardless of where they appear in the document; the manager ignores its own managed graph (identified by the `data-milo-jsonld="graph"` attribute) during scan and observation.
+
+### 2.4 Normalization And Merge Policy
+
+The canonical `@id` values the manager assigns to each recognized entity type are defined in §3 Requirements (`page-scoped-id-format`, `organization-site-wide-id`). Incoming producer `@id` values are treated as merge hints — for recognized entities, the manager rewrites `@id` to the canonical value. Unknown nodes that lack stable identity are retained provisionally until they can be normalized or deduplicated.
+
+#### Merge priority
+
+When multiple sources describe the same entity, the default source priority is:
+
+1. graph-manager-generated transforms
+1. Milo feature or block sources
+1. third-party runtime sources
+1. initial page DOM
+
+#### Default merge rules
+
+Unless a type-specific rule overrides them, the manager applies the following defaults:
+
+- scalar field conflicts are resolved by source priority
+- object fields are merged by key, with conflicting child fields resolved by source priority
+- relationship arrays are unioned by canonical `@id`
+- anonymous array members are deduplicated by normalized content hash when no stable `@id` exists
+- unknown anonymous top-level nodes are retained provisionally until they can be normalized or deduplicated
+
+Singleton, supplemental, and repeatable type policies are defined in §3.4 Graph composition (`webpage-canonical-singleton`, `organization-singleton`, `breadcrumblist-singleton`, `required-primary-type`, `supplemental-singletons`, `repeatable-types`). Relationship arrays such as `hasPart` are unioned by canonical `@id`.
+
+#### Type-specific transforms
+
+In addition to identity rewrite and merge, the manager applies a small set of type-specific transforms.
+
+**Product → SoftwareApplication.** Adobe.com pages do not market physical products. The merch card system, however, emits `Product` nodes (see Appendix A.3). Because the canonical primary type for product-oriented pages is `SoftwareApplication`, the manager normalizes any incoming `Product` node into a `SoftwareApplication`:
+
+- rewrites `@type` from `Product` to `SoftwareApplication`
+- re-derives `@id` to `{canonicalPageURL}#softwareapplication`
+- preserves `name`, `brand`, `image`, `offers`, and other shared properties
+- hoists nested `Brand` and `Offer` entities to the top-level `@graph` and replaces inline values with `@id` references
+
+This transform is governed by the `product-to-softwareapplication` requirement.
+
+**SoftwareApplication subtype preservation.** Schema.org defines `WebApplication`, `MobileApplication`, and `VideoGame` as subtypes of `SoftwareApplication`, and Google's Software App rich result explicitly supports them. When a producer supplies one of these subtypes (e.g., team-hardcoded `WebApplication` markup), the manager preserves the more specific `@type`, lands the node at the canonical `#softwareapplication` `@id`, and merges contributions from other producers (e.g., the review block emitting `Product` → `SoftwareApplication`) at the same id. The baseline `Product → SoftwareApplication` transform does NOT rewrite a producer-supplied subtype down to plain `SoftwareApplication`. Governed by `softwareapplication-subtype-allowed`.
+
+**Cross-page WebPage references.** Producers occasionally assert `isPartOf` or `mainEntityOfPage` against a different page's WebPage (e.g., a sub-app belonging to a parent /online/ index). Schema.org permits this and Google's rich-result spec is silent on it. To keep the page graph coherent on a single-page basis, the manager rewrites such references to the current canonical `#webpage` id and discards the inline cross-page WebPage body. Governed by `webpage-canonical-singleton`. (We may revisit this if a consumer ever surfaces a need for cross-page parent linkage.)
+
+#### Reference shape
+
+References to other graph nodes are encoded as `{ "@id": "…" }` (see `nodes-referenced-by-id`). Because all referenced entities — including the site-wide `Organization` — are present as top-level nodes in the managed `@graph`, consumers can follow any `@id` to find the full node and its properties. Adding `url` to a reference object would be redundant.
+
+### 2.5 Canonical Page Graph Model
+
+The manager treats `WebPage` as the page container and links related entities to it. Canonical `@id` values are defined in the preceding section.
+
+#### Editorial page shape
+
+```mermaid
+graph TD
+    WP["WebPage<br/>#webpage"]
+    A["Article<br/>#article"]
+    BC["BreadcrumbList<br/>#breadcrumb"]
+    HT["HowTo<br/>#howto"]
+    FAQ["FAQPage<br/>#faq"]
+    ORG["Adobe Organization<br/>https://www.adobe.com/#organization"]
+    WP -->|mainEntity| A
+    WP -->|breadcrumb| BC
+    WP -->|publisher| ORG
+    A -->|isPartOf| WP
+    A -->|publisher| ORG
+    A -->|hasPart| HT
+    A -->|hasPart| FAQ
+    BC -->|isPartOf| WP
+    HT -->|isPartOf| WP
+    FAQ -->|isPartOf| WP
+```
+
+This model is intended to be stable across separate producer implementations. The relationships shown — `mainEntity`, `breadcrumb`, `publisher`, `isPartOf`, `hasPart` — and their cardinality constraints are encoded as rules in §3 Requirements.
+
+#### Product page shape
+
+```mermaid
+graph TD
+    WP["WebPage<br/>#webpage"]
+    SA["SoftwareApplication<br/>#softwareapplication<br/>(transformed from Product)"]
+    BC["BreadcrumbList<br/>#breadcrumb"]
+    ORG["Adobe Organization"]
+    OFF1["Offer<br/>#offer-paid"]
+    OFF2["Offer<br/>#offer-trial"]
+    WP -->|mainEntity| SA
+    WP -->|publisher| ORG
+    WP -->|breadcrumb| BC
+    SA -->|provider| ORG
+    SA -->|offers| OFF1
+    SA -->|offers| OFF2
+    BC -->|isPartOf| WP
+```
+
+For product-oriented pages, `WebPage.mainEntity` points to `SoftwareApplication` rather than `Article`. Producer payloads of `@type: Product` are transformed to `SoftwareApplication` per §2.4. Offers (paid subscription, free trial, etc.) are hoisted to the top-level `@graph` and referenced by `@id`. The page-family-to-primary-entity mapping is owned by the public `tests` dataset.
+
+### 2.6 Alternatives Considered
+
+There are two additional approaches that have been tabled but should be reexamined in future.
+
+**Coordinated producer migration.** Require every producer to adopt a shared interface — a direct-push API, a publish-subscribe bus, a declarative schema — before shipping anything. Rejected: the producer landscape currently spans 33 integrations across 7 repos, including legacy, external, and non-Milo sources, plus inline author-authored JSON-LD. Any such approach requires every producer to opt in on day one, cannot be feature-flagged per page, and strands producers that cannot be refactored at all. The observation-first design lets the ecosystem converge incrementally without blocking on any single producer. In the future we can offer a direct-push function as the preferred method and refactor existing components.
+
+**Build-time aggregation.** Collect and normalize JSON-LD at publish time instead of at runtime. Rejected: much of today's JSON-LD is produced by runtime code (feature fetches, DOM derivations, experimentation) and by author-hand-coded inline scripts. A build-time aggregator would miss both categories, and the managed graph would not reflect what the browser actually renders. There are still valid use-cases for this approach to perform major portions of node generation.
+
+## 3. Requirements
+
+The normative rules for the managed graph. Every rule has a stable `Name`, a `Severity`, the `Requirement` itself, and optional `Notes`. Severity meanings:
+
+- **error** — the manager MUST satisfy this rule. Output that violates an error-rule is non-conformant.
+- **warn** — the manager SHOULD satisfy this rule. Violations should be logged via Lana but do not block emission.
+- **info** — informational guidance. Captures defaults, conventions, and rules the manager applies but that consumers and producers MAY also rely on.
+
+Rules are grouped by concern. Cross-type behavior (singletons, defaults, transforms, source priority) lives here; per-type policy and producer inventory lives in §4.
+
+### 3.1 Output shape
+
+| Name | Severity | Requirement |
+|---|---|---|
+| `single-script-tag` | error | The HTML page MUST contain exactly one `<script type="application/ld+json">` tag, located in `<head>`. |
+| `managed-script-marker` | error | The managed script MUST carry the attribute `data-milo-jsonld="graph"` so the graph manager can identify it for ingestion and rewrite. |
+| `managed-script-metadata` | info | The managed script MAY carry the optional attributes `data-milo-jsonld-version` and `data-milo-jsonld-updated`. |
+| `graph-container-shape` | error | The script content MUST be a single graph object with `@context` set to `https://schema.org` and a `@graph` array. |
+| `no-per-node-context` | error | `@context` MUST NOT appear on individual nodes. |
+
+### 3.2 Identity
+
+| Name | Severity | Requirement |
+|---|---|---|
+| `all-nodes-have-id` | error | Every node in `@graph` MUST have an `@id`. |
+| `all-nodes-have-type` | error | Every node in `@graph` MUST have an `@type`. |
+| `unique-node-ids` | error | Every `@id` in `@graph` MUST be unique; no two nodes may share the same `@id`. |
+| `page-scoped-id-format` | error | Page-scoped node `@id` values MUST follow the format `{canonicalPageURL}#{role}` where `{role}` is the lowercase entity role on the page, e.g. `https://example.com/page#webpage`, `#article`, `#breadcrumb`, `#howto`, `#faq`. |
+| `organization-site-wide-id` | error | The Adobe publisher Organization is a site-wide singleton; its `@id` MUST be `https://www.adobe.com/#organization` rather than the page-scoped format. |
+| `organization-site-root` | info | Site root is `https://www.adobe.com` unless `window.location.hostname` contains `business` or `bacom`, in which case `https://business.adobe.com`. |
+
+### 3.3 References
+
+| Name | Severity | Requirement |
+|---|---|---|
+| `nodes-referenced-by-id` | error | Nodes that appear in `@graph` MUST NOT be inlined as nested objects; they MUST be referenced by `@id`. |
+
+The previous `external-reference-includes-url` rule is retired. Because every referenced entity — including the site-wide `Organization` and any `Offer` — is present as a top-level node in the same `@graph`, an `@id`-only reference is sufficient; consumers can follow `@id` to retrieve `url` and other properties.
+
+### 3.4 Graph composition
+
+| Name | Severity | Requirement |
+|---|---|---|
+| `manager-baseline-graph` | error | When the manager is enabled, the managed `<script>` MUST be emitted containing at minimum the canonical WebPage and Organization nodes — even on pages where no producers contribute JSON-LD. Enabling the manager via `jsonld-graph-manager=true` is the explicit opt-in to a managed graph. |
+| `webpage-canonical-singleton` | error | The graph MUST contain exactly one WebPage node whose `@id` is the canonical page id (`{canonicalPageURL}#webpage`). Producer-supplied cross-page WebPage references in `isPartOf` / `mainEntityOfPage` are rewritten to the canonical page id and any inline cross-page WebPage body is discarded. |
+| `organization-singleton` | error | The graph MUST contain exactly one Organization node. |
+| `breadcrumblist-singleton` | error | The graph MUST contain exactly one BreadcrumbList node when applicable. (BreadcrumbList is optional; some pages have no breadcrumbs. When breadcrumbs are present, exactly one BreadcrumbList is required.) |
+| `required-primary-type` | warn | The graph SHOULD contain exactly one node of a recognised primary page type: `Article`, `NewsArticle`, `SoftwareApplication`, or any SoftwareApplication subtype permitted by `softwareapplication-subtype-allowed`. |
+| `supplemental-singletons` | warn | The graph MAY contain at most one HowTo node and at most one FAQPage node. (Presence is optional; count > 1 is a hard violation.) |
+| `aggregaterating-singleton` | error | The graph MUST contain at most one AggregateRating node. When multiple producers contribute an `aggregateRating` (e.g., team-hardcoded markup and the review block), they merge at the canonical `@id` (`{canonicalPageURL}#aggregaterating`) and source priority resolves scalar conflicts. |
+| `repeatable-types` | info | The graph MAY contain multiple instances of `VideoObject` and `Offer`. These types are NOT deduplicated as singletons. (v1 limitation: when multiple repeatable nodes are emitted without distinct producer-supplied `@id` values, they collapse to a single node at the canonical id, e.g., `#videoobject` or `#offer`. Distinct `@id` values from producers are required to materialize multiple instances. Sequential `@id` assignment by the manager is planned for a future iteration.) |
+
+`webpage-canonical-singleton` replaces the prior `webpage-singleton`. Schema.org allows `isPartOf` to point at a cross-page resource and Google's rich-result spec doesn't constrain it, but a managed page-graph that contains two WebPage nodes is internally inconsistent for our consumers (the WebPage of the rendered page is the only one with full link wiring). We therefore rewrite cross-page `isPartOf`/`mainEntityOfPage` to the current canonical `#webpage` id. This is policy choice C from the design review — to be revisited if a consumer ever surfaces a need for cross-page parent linkage.
+
+### 3.5 Linking
+
+| Name | Severity | Requirement |
+|---|---|---|
+| `webpage-publisher-link` | error | The WebPage node MUST have a `publisher` property referencing the Organization node by `@id`. |
+| `webpage-mainentity-link` | error | The WebPage node SHOULD have a `mainEntity` property referencing the primary page type node by `@id`. (Assuming a primary entity exists: `Article`, `NewsArticle`, or `SoftwareApplication`.) |
+| `webpage-breadcrumb-link` | warn | The WebPage node SHOULD have a `breadcrumb` property referencing the BreadcrumbList node by `@id`. (Only evaluated when a BreadcrumbList is present.) |
+| `primary-type-ispartof` | error | The primary page type node MUST have an `isPartOf` property referencing the WebPage node by `@id`. |
+| `breadcrumblist-ispartof` | error | The BreadcrumbList node MUST have an `isPartOf` property referencing the WebPage node by `@id`. |
+| `primary-type-publisher` | warn | The primary page type node SHOULD have a `publisher` property referencing the Organization node by `@id`. |
+| `primary-type-mainentityofpage` | info | The primary page type node MAY have a `mainEntityOfPage` property referencing the WebPage node by `@id`. |
+
+### 3.6 Type transforms
+
+| Name | Severity | Requirement |
+|---|---|---|
+| `product-to-softwareapplication` | error | A `Product` node MUST be transformed by the graph manager into a `SoftwareApplication` node. The transform rewrites `@type` from `Product` to `SoftwareApplication`, re-derives `@id` to `{canonicalPageURL}#softwareapplication`, and preserves `name`, `brand`, `image`, `offers`, and other shared properties. Nested `Brand` and `Offer` entities are hoisted to the top-level `@graph` by `@id`. (Required because Adobe.com pages do not market physical products; the merch card system emits `Product` but the canonical primary type for product-oriented pages is `SoftwareApplication`.) |
+| `softwareapplication-subtype-allowed` | info | The manager preserves a more specific `@type` when supplied by a producer. Recognized SoftwareApplication subtypes are `WebApplication`, `MobileApplication`, and `VideoGame` (per the [Google Software App rich result](https://developers.google.com/search/docs/appearance/structured-data/software-app) and schema.org). When a subtype is present, the node retains its specific `@type`, lands at the canonical `#softwareapplication` `@id`, and merges with any other SoftwareApplication-family contributions from the same page. The `Product → SoftwareApplication` baseline transform does NOT rewrite a producer-supplied subtype down to plain `SoftwareApplication`. |
+
+### 3.7 Defaults and precedence
+
+| Name | Severity | Requirement |
+|---|---|---|
+| `organization-default-name` | error | `Organization.name` MUST be present; manager default is `"Adobe"` (or `"Adobe for Business"` when site root is `https://business.adobe.com`). |
+| `organization-default-url` | error | `Organization.url` MUST be the site root homepage URL (e.g., `https://www.adobe.com/` or `https://business.adobe.com/`), not a page-scoped URL. |
+| `organization-default-logo` | warn | `Organization.logo` SHOULD be present as a schema.org `ImageObject` whose `url` and `contentUrl` point at the canonical Adobe corporate horizontal red logo (`https://www.adobe.com/content/dam/cc/icons/Adobe_Corporate_Horizontal_Red_HEX.svg`). The manager applies this default when no producer-supplied logo is present. Per [Google's Logo guidelines](https://developers.google.com/search/docs/appearance/structured-data/logo) the image must be at least 112×112 pixels (SVG satisfies this); the `ImageObject` form is preferred over a bare URL string for richer metadata. |
+| `organization-default-precedence` | info | Manager-synthesized Organization fields (`name`, `url`, `logo`) take graph-manager-generated priority — they win over any producer-supplied values for those three fields. Producer-supplied fields not in the default set (`sameAs`, `address`, `description`, etc.) are preserved. |
+| `organization-nested-extraction` | info | Organization objects embedded as inline property values (e.g. `publisher`, `author`, `provider`) are hoisted to the top-level `@graph` and merged into the canonical Organization node. The inline value is replaced with `{ "@id": "<canonical-org-id>" }`. |
+| `organization-id-aliases` | info | Producer-supplied non-canonical Organization `@id` values whose fragment matches `#org`, `#publisher`, or `#adobe` are rewritten to the canonical `#organization` fragment in reference stubs (objects with `@id` but no `@type`). Full Organization nodes already get the canonical `@id` via the identity rewrite. (Defensive measure for known producer drift; producer-side fix-up is preferred long-term.) |
+| `aggregaterating-extraction` | info | AggregateRating objects embedded as inline property values (typically on `SoftwareApplication`, `Article`, `Product`, etc.) are hoisted to the top-level `@graph` and merged into the canonical AggregateRating node at `{canonicalPageURL}#aggregaterating`. The inline value is replaced with `{ "@id": "<canonical-aggregaterating-id>" }`. |
+| `source-priority` | error | When the same node is contributed by multiple sources, scalar conflicts are resolved by source priority: graph-manager-generated > Milo feature/block runtime > third-party runtime > initial page DOM (`bootDom`). Object fields merge by key with the same precedence; relationship arrays are unioned by `@id`. This applies to all types unless a type-specific override exists. The recorded source for a node is ratcheted to the maximum-priority source that has contributed to it; subsequent merges of lower-priority sources keep the higher source as the "previous" source for priority comparison, ensuring a generated default cannot be overwritten by later `bootDom` payloads arriving out of order. (Codifies that runtime producers — for example, the review block's `aggregateRating` — win over hardcoded `bootDom` values, ensuring the freshest data reaches consumers.) |
+
+### 3.8 Type-specific rules
+
+#### SoftwareApplication
+
+| Name | Severity | Requirement |
+|---|---|---|
+| `softwareapplication-name` | error | A SoftwareApplication node MUST have a `name` property. (Required for the Google software-app rich result. Only evaluated when primary type is SoftwareApplication or a subtype.) |
+| `softwareapplication-offers` | warn | A SoftwareApplication node SHOULD have an `offers` property referencing one or more Offer nodes by `@id`. Multiple offers (e.g., paid subscription and free trial) are encoded as separate Offer nodes. (Each Offer MAY include a `potentialAction` property to express usage actions, e.g., `BuyAction`, `TryAction`.) |
+| `softwareapplication-rating-or-review` | warn | A SoftwareApplication node SHOULD have either an `aggregateRating` or a `review` property. Required for the Google software-app rich result. The manager will produce incomplete nodes when this data is not available from producers. |
+| `softwareapplication-provider` | info | A SoftwareApplication node MAY have a `provider` property referencing the Organization node by `@id`. |
+
+#### Offer
+
+| Name | Severity | Requirement |
+|---|---|---|
+| `offer-price` | error | An Offer node MUST have `price` and `priceCurrency` properties. (Required for the Google software-app rich result. Evaluated for any Offer node referenced by `SoftwareApplication.offers`.) |
+
+#### BreadcrumbList
+
+| Name | Severity | Requirement |
+|---|---|---|
+| `breadcrumblist-items` | error | The BreadcrumbList `itemListElement` MUST be a non-empty array of ListItem nodes, each with `position`, `name`, and `item` properties. |
+
+## 4. Per-Type Strategy
+
+Each subsection covers one schema.org type the manager handles. The structure is:
+
+- **Schema.org** — type hierarchy and accepted subtypes.
+- **Google rich result** — what consumer behavior depends on the markup, with required and recommended fields.
+- **Manager handling** — `@id` pattern, cardinality, defaults, transforms.
+- **Known producers** — Milo blocks and features that emit this type today.
+
+Coverage strategy: Google rich-result eligibility is consumer #1. Other consumers (LLMs, knowledge graphs) benefit indirectly from the same shape. The manager preserves producer fields beyond what Google requires.
+
+Producer inventory in this section is scoped to the `milo` repository. The full cross-repo inventory lives in the `integrations` sheet of [structured-data-json-ld.json](https://milo.adobe.com/docs/authoring/structured-data-json-ld.json).
+
+### 4.1 WebPage
+
+**Schema.org.** `Thing > CreativeWork > WebPage`. No subtypes accepted by the manager.
+
+**Google rich result.** Not directly eligible, but acts as the page-graph root that other rich-result types attach to via `isPartOf` / `mainEntity` / `breadcrumb`. Required for Article, NewsArticle, SoftwareApplication, and BreadcrumbList rich results to have a coherent parent.
+
+**Manager handling.**
+- `@id`: `{canonicalPageURL}#webpage`
+- Cardinality: singleton (`webpage-canonical-singleton`)
+- Synthesized when absent from producers
+- Cross-page WebPage references in `isPartOf` / `mainEntityOfPage` are rewritten to the canonical page id
+
+**Known producers (milo).** None. The manager always synthesizes WebPage.
+
+### 4.2 Organization
+
+**Schema.org.** `Thing > Organization`. No subtypes used.
+
+**Google rich result.** Logo, knowledge panel, and publisher attribution on Article rich results. Required: `name`. Logo SHOULD be present (112×112 pixel minimum). See [Google Logo guidelines](https://developers.google.com/search/docs/appearance/structured-data/logo).
+
+**Manager handling.**
+- `@id`: `{siteRoot}/#organization` (site-wide, not page-scoped)
+- Cardinality: singleton (`organization-singleton`)
+- Synthesized when absent. Default `name`, `url`, `logo` overrides any producer-supplied values for those three fields (`organization-default-precedence`). Producer-supplied fields not in the default set (`sameAs`, `address`, etc.) are preserved.
+- Inline Organization values in `publisher` / `author` / `provider` are extracted and merged into the canonical node (`organization-nested-extraction`)
+- Producer-supplied non-canonical `@id` aliases (`#org`, `#publisher`, `#adobe`) are rewritten to `#organization`
+
+**Known producers (milo).**
+
+| Block / feature | Trigger | Source |
+|---|---|---|
+| `richresults` | `richresults=Organization` page metadata | [`libs/features/richresults.js`](https://github.com/adobecom/milo/blob/stage/libs/features/richresults.js) |
+
+### 4.3 BreadcrumbList
+
+**Schema.org.** `Thing > Intangible > ItemList > BreadcrumbList`.
+
+**Google rich result.** [Breadcrumb](https://developers.google.com/search/docs/appearance/structured-data/breadcrumb). Required: `itemListElement` array of `ListItem` with `position`, `name`, `item` (URL).
+
+**Manager handling.**
+- `@id`: `{canonicalPageURL}#breadcrumb`
+- Cardinality: singleton when applicable (`breadcrumblist-singleton`)
+- `WebPage.breadcrumb` is set to `{ @id: '#breadcrumb' }` when present
+- `BreadcrumbList.isPartOf` is set to `{ @id: '#webpage' }`
+
+**Known producers (milo).**
+
+| Block / feature | Trigger | Source |
+|---|---|---|
+| `global-navigation breadcrumbs` | Breadcrumbs render and SEO not disabled | [`libs/blocks/global-navigation/features/breadcrumbs/breadcrumbs.js`](https://github.com/adobecom/milo/blob/stage/libs/blocks/global-navigation/features/breadcrumbs/breadcrumbs.js) |
+| `legacy gnav breadcrumbs` | Breadcrumbs render and `breadcrumb-seo` is not `off` | [`libs/blocks/gnav/gnav.js`](https://github.com/adobecom/milo/blob/stage/libs/blocks/gnav/gnav.js#L522) |
+| `MEP breadcrumbs` | MEP breadcrumbs render and SEO not disabled | [`libs/mep/ace1151/global-navigation/features/breadcrumbs/breadcrumbs.js`](https://github.com/adobecom/milo/blob/stage/libs/mep/ace1151/global-navigation/features/breadcrumbs/breadcrumbs.js) |
+
+### 4.4 SoftwareApplication (and subtypes)
+
+**Schema.org.** `Thing > CreativeWork > SoftwareApplication`. Accepted subtypes: `WebApplication`, `MobileApplication`, `VideoGame` (the latter requires co-typing with another SoftwareApplication subtype).
+
+**Google rich result.** [Software App](https://developers.google.com/search/docs/appearance/structured-data/software-app). Required: `name`, `offers.price`, and one of `aggregateRating` or `review`. Recommended: `applicationCategory`, `operatingSystem`. Subtypes `WebApplication`, `MobileApplication`, `VideoGame` are explicitly supported.
+
+**Manager handling.**
+- `@id`: `{canonicalPageURL}#softwareapplication` (regardless of subtype)
+- Cardinality: singleton; one primary type per page
+- Transform: `Product` → `SoftwareApplication` (`product-to-softwareapplication`)
+- Subtypes preserved when producer supplies them (`softwareapplication-subtype-allowed`); the canonical `#softwareapplication` `@id` lets the manager merge contributions from the review block (`Product` → `SoftwareApplication`) with team-hardcoded `WebApplication` markup
+- Inline `Offer` and `Brand` are extracted; `offers` becomes `{ @id }` references; anonymous `Brand` may stay inline
+- `provider` set to `{ @id: '<org>' }` when manager-synthesized; producer-supplied `provider` is canonicalized to the same shape
+
+**Known producers (milo).**
+
+| Block / feature | Type emitted | Trigger | Source |
+|---|---|---|---|
+| `merch autoblock` | `Product` (→ SA) | merch options include `jsonld=on` | [`libs/blocks/merch-card-autoblock/merch-card-autoblock.js`](https://github.com/adobecom/milo/blob/stage/libs/blocks/merch-card-autoblock/merch-card-autoblock.js#L137) |
+| `review flow` | `Product` (→ SA) | Review block has `product-name` and rating response | [`libs/blocks/review/utils/setJsonLdProductInfo.js`](https://github.com/adobecom/milo/blob/stage/libs/blocks/review/utils/setJsonLdProductInfo.js#L2) |
+
+The Acrobat team's hardcoded `WebApplication` markup is a `da-dc` repo producer, not a milo producer; it appears in the cross-repo `integrations` sheet.
+
+### 4.5 Article / NewsArticle
+
+**Schema.org.** `Thing > CreativeWork > Article`. `NewsArticle` is a subtype of `Article`.
+
+**Google rich result.** [Article](https://developers.google.com/search/docs/appearance/structured-data/article). Required: `headline`, `image`, `datePublished`, `author`, `publisher`. NewsArticle is the same shape with stricter content guidelines.
+
+**Manager handling.**
+- `@id`: `{canonicalPageURL}#article`
+- Cardinality: singleton; one primary type per page
+- `isPartOf` and `mainEntityOfPage` set to `{ @id: '#webpage' }`
+- `publisher` reference canonicalized to `{ @id: '<org>' }`
+
+**Known producers (milo).**
+
+| Block / feature | Type emitted | Trigger | Source |
+|---|---|---|---|
+| `richresults` | `Article` | `richresults=Article` page metadata | [`libs/features/richresults.js`](https://github.com/adobecom/milo/blob/stage/libs/features/richresults.js) |
+| `richresults` | `NewsArticle` | `richresults=NewsArticle` page metadata | (same file) |
+
+### 4.6 HowTo
+
+**Schema.org.** `Thing > CreativeWork > HowTo`.
+
+**Google rich result.** Status: HowTo rich results were deprecated in Google Search in 2023 and are no longer eligible for the rich treatment, but the markup is still ingested for general structured-data understanding. Required (per the deprecated spec): `name`, `step` array of `HowToStep`.
+
+**Manager handling.**
+- `@id`: `{canonicalPageURL}#howto`
+- Cardinality: supplemental singleton (`supplemental-singletons`)
+- `isPartOf` set to `{ @id: '#webpage' }`
+- `publisher` reference canonicalized to Organization
+
+**Known producers (milo).**
+
+| Block / feature | Trigger | Source |
+|---|---|---|
+| `how-to` | Block has class `seo` | [`libs/blocks/how-to/how-to.js`](https://github.com/adobecom/milo/blob/stage/libs/blocks/how-to/how-to.js#L19) |
+
+### 4.7 FAQPage
+
+**Schema.org.** `Thing > CreativeWork > WebPage > FAQPage`.
+
+**Google rich result.** [FAQPage](https://developers.google.com/search/docs/appearance/structured-data/faqpage). Eligibility for the rich result is restricted (since 2023) to authoritative government and health sites; for other sites the markup is still consumed by Search and LLMs but does not trigger the rich result. Required: `mainEntity` array of `Question` with `acceptedAnswer.Answer.text`.
+
+**Manager handling.**
+- `@id`: `{canonicalPageURL}#faq`
+- Cardinality: supplemental singleton (`supplemental-singletons`)
+- `isPartOf` set to `{ @id: '#webpage' }`
+
+**Known producers (milo).**
+
+| Block / feature | Trigger | Source |
+|---|---|---|
+| `accordion` | Block has class `seo` | [`libs/blocks/accordion/accordion.js`](https://github.com/adobecom/milo/blob/stage/libs/blocks/accordion/accordion.js#L8) |
+| `MEP accordion ace1151` | MEP accordion SEO path | [`libs/mep/ace1151/accordion/accordion.js`](https://github.com/adobecom/milo/blob/stage/libs/mep/ace1151/accordion/accordion.js#L8) |
+| `MEP accordion emea1443` | MEP accordion SEO path | [`libs/mep/emea1443/accordion/accordion.js`](https://github.com/adobecom/milo/blob/stage/libs/mep/emea1443/accordion/accordion.js#L8) |
+
+### 4.8 VideoObject
+
+**Schema.org.** `Thing > CreativeWork > MediaObject > VideoObject`.
+
+**Google rich result.** [Video](https://developers.google.com/search/docs/appearance/structured-data/video). Required: `name`, `thumbnailUrl`, `uploadDate`. Recommended: `description`, `contentUrl`, `embedUrl`, `duration`.
+
+**Manager handling.**
+- `@id`: producer-supplied (typically `{canonicalPageURL}#video-{slug}`)
+- Cardinality: repeatable (`repeatable-types`); not deduplicated as singletons
+- One canonical `#videoobject` is reserved for the first/only emitter; additional videos require distinct producer-supplied `@id` values
+
+**Known producers (milo).**
+
+| Block / feature | Trigger | Source |
+|---|---|---|
+| `seotech video path` | `seotech-video-url` page metadata | [`libs/features/seotech/seotech.js`](https://github.com/adobecom/milo/blob/stage/libs/features/seotech/seotech.js) |
+| `video-metadata` | Recognized video metadata fields exist | [`libs/blocks/video-metadata/video-metadata.js`](https://github.com/adobecom/milo/blob/stage/libs/blocks/video-metadata/video-metadata.js#L69) |
+
+### 4.9 Offer
+
+**Schema.org.** `Thing > Intangible > Offer`.
+
+**Google rich result.** Used by Software App and Product rich results. Required when referenced from `SoftwareApplication`: `price`, `priceCurrency` (`offer-price`).
+
+**Manager handling.**
+- `@id`: producer-supplied or `{canonicalPageURL}#offer` (singleton when only one Offer is present)
+- Cardinality: repeatable when distinct `@id` values are supplied (e.g., `#offer-paid`, `#offer-trial`)
+- Hoisted from `SoftwareApplication.offers` to top-level `@graph` and replaced with `{ @id }` references
+- Producer-supplied `seller: { @id: '...#org' }` (and similar aliases) is canonicalized to `{ @id: '...#organization' }`
+
+**Known producers (milo).** Emitted as nested values inside `Product`/`SoftwareApplication` from `merch autoblock` and `review flow`. Hoisted by the manager.
+
+### 4.10 AggregateRating
+
+**Schema.org.** `Thing > Intangible > Rating > AggregateRating`.
+
+**Google rich result.** A required property of the [Software App](https://developers.google.com/search/docs/appearance/structured-data/software-app), [Product](https://developers.google.com/search/docs/appearance/structured-data/product), [Course](https://developers.google.com/search/docs/appearance/structured-data/course), and [Review snippet](https://developers.google.com/search/docs/appearance/structured-data/review-snippet) rich results when emitted at the host entity. Required: `ratingValue`, `ratingCount` (or `reviewCount`).
+
+**Manager handling.**
+- `@id`: `{canonicalPageURL}#aggregaterating`
+- Cardinality: singleton (`aggregaterating-singleton`) — at most one AggregateRating per page
+- Hoisted from inline property values on host entities (e.g., `SoftwareApplication.aggregateRating`) to a top-level `@graph` node and replaced with `{ "@id": "<canonical-aggregaterating-id>" }` (`aggregaterating-extraction`)
+- Multi-producer contributions merge at the canonical id; source priority resolves scalar conflicts (e.g., the review block's runtime ratings beat a stale team-hardcoded snapshot from `bootDom`)
+
+**Known producers (milo).** Emitted as a nested value inside `Product`/`SoftwareApplication` from the `review flow` block. Hoisted by the manager.
+
+### 4.11 Event
+
+**Schema.org.** `Thing > Event`.
+
+**Google rich result.** [Event](https://developers.google.com/search/docs/appearance/structured-data/event). Required: `name`, `startDate`, `location`. Recommended: `description`, `endDate`, `image`, `offers`.
+
+**Manager handling.** Currently passed through. Not a primary page type. Producer-supplied `@id` retained.
+
+**Known producers (milo).**
+
+| Block / feature | Trigger | Source |
+|---|---|---|
+| `event-rich-results` | Block present | [`libs/blocks/event-rich-results/event-rich-results.js`](https://github.com/adobecom/milo/blob/stage/libs/blocks/event-rich-results/event-rich-results.js) |
+
+### 4.12 WebSite
+
+**Schema.org.** `Thing > CreativeWork > WebSite`.
+
+**Google rich result.** [Sitelinks search box](https://developers.google.com/search/docs/appearance/structured-data/sitelinks-searchbox). Required: `potentialAction` of type `SearchAction` with a `target` URL template and `query-input`.
+
+**Manager handling.** Site-wide singleton; emitted only when explicitly authored (e.g., `richresults=SiteSearchBox`). Not a primary page type.
+
+**Known producers (milo).**
+
+| Block / feature | Trigger | Source |
+|---|---|---|
+| `richresults` | `richresults=SiteSearchBox` page metadata | [`libs/features/richresults.js`](https://github.com/adobecom/milo/blob/stage/libs/features/richresults.js) |
+
+### 4.13 seotech structured-data path (variable type)
+
+The `seotech` feature can fetch external JSON-LD from a remote API. The emitted type depends on the response payload. The manager applies its standard ingest / transform / merge pipeline per ingested node.
+
+**Known producers (milo).**
+
+| Block / feature | Trigger | Source |
+|---|---|---|
+| `seotech structured-data path` | `seotech-structured-data=on` page metadata | [`libs/features/seotech/seotech.js`](https://github.com/adobecom/milo/blob/stage/libs/features/seotech/seotech.js) |
+
+## 5. Conformance
+
+Testing for the `JsonLdGraphManager` is organized at three levels:
+
+1. **Unit tests** cover the manager's internal behavior: parsing the accepted input shapes, identity-rewrite for known types, merge-priority resolution, and dedupe for singletons. These run under the existing Milo unit-test harness and should not depend on the network. Part of Milo.
+
+2. **Integration tests** cover the boot and mutation lifecycle against representative DOM fixtures. Each fixture represents one page family (editorial, product, breadcrumb-only, multi-producer conflict, etc.) and asserts on the managed `@graph` output plus the removal of unmanaged scripts. Part of Milo.
+
+3. **End-to-end tests** cover cohort pages listed in the public `tests` dataset. For each row, the test asserts the JSON-LD on the page meets all `requirements` and matches the row's defined Expected Primary Entity. End-to-end testing depends on a dev or stage deployment: once the branch is pushed, we can load AEM `.live` or `.page` URLs with `milolib=${BRANCH_NAME}` and `jsonld-graph-manager=true` to exercise the feature before merge. This feature could be considered complete once all `requirements` pass for every row in `tests`. Due to its complexity this test may exist outside of Milo.
+
+Evaluating whether this feature actually improves how search engines and LLMs surface content is not in the scope of this document. 
+
+## 6. Operations
+
+### 6.1 Feature Flagging
+
+**Flag:** `jsonld-graph-manager` (page metadata or URL query parameter, `true`/`false`, default `false`)
+
+The manager is feature-gated by AEM page metadata so it can be enabled or disabled on selected pages and page families without affecting the entire site at once. You can also use the query parameter for quick testing.
+
+**Debug flag:** `jsonld-graph-manager-debug` (URL query parameter only, `true` to enable)
+
+### 6.2 Observability And Diagnostics
+
+The manager should expose both local debugging output and production-safe warning and error reporting.
+
+#### Debug logging
+
+Add `jsonld-graph-manager-debug=true` to the URL query string to enable lifecycle logging via `console.log`. Events logged in queue order:
+
+- **enqueue** — source (`bootDom` or `runtime`), DOM location, original captured payload
+- **rebuild** — batch size, current graph size
+- **parsed** — source, node count, `@type` values found
+- **removed from DOM** — parent element of the ingested script
+- **rewrite** — node count, full expandable `@graph` object
+
+Debug mode is the appropriate place to surface per-source origin when needed; the production manager does not persist a provenance record on the canonical graph.
+
+#### Warning and error reporting
+
+Warnings and errors should be reported through `window.lana?.log(...)` using the existing repo conventions for tags and severity.
+
+Representative cases:
+
+- invalid JSON-LD that fails to parse
+- unsupported payload shapes
+- rewrite failures
+- transform failures
+- producer payloads that violate required assumptions
+
+Recommended logging behavior:
+
+- warnings use Lana warning severity
+- errors use Lana error severity
+- tags should identify the manager and, when useful, the producer (e.g., `jsonld-graph-manager` or `jsonld-graph-manager,seotech`)
+- high-volume success-path events should not be sent to Lana by default
+
+## References
+
+[General structured data guidelines](https://developers.google.com/search/docs/appearance/structured-data/sd-policies). developers.google.com.
+
+[Software App rich results](https://developers.google.com/search/docs/appearance/structured-data/software-app). developers.google.com. Defines required and recommended properties for `SoftwareApplication` to be eligible for software-app rich results: `name`, `offers` (with `price`), and either `aggregateRating` or `review`. Explicitly supports `WebApplication`, `MobileApplication`, and `VideoGame` subtypes. Drives the `softwareapplication-name`, `softwareapplication-rating-or-review`, `offer-price`, and `softwareapplication-subtype-allowed` requirements.
+
+[Logo structured data](https://developers.google.com/search/docs/appearance/structured-data/logo). developers.google.com. Defines requirements for organization logos in structured data: 112×112 pixel minimum, accepts URL string or `ImageObject`. Drives the `organization-default-logo` requirement.
+
+[Schema.org `isPartOf`](https://schema.org/isPartOf). schema.org. Defines `isPartOf` as accepting `CreativeWork` or `URL`, with no constraint that the parent be in the same graph. Informs the policy choice in `webpage-canonical-singleton` to rewrite cross-page references to the current canonical page id.
+
+[Schema.org `WebApplication`](https://schema.org/WebApplication). schema.org. Subtype hierarchy: `Thing > CreativeWork > SoftwareApplication > WebApplication`. Adds `browserRequirements`; otherwise inherits all `SoftwareApplication` properties. Informs `softwareapplication-subtype-allowed`.
+
+[Structured data catalog: structured-data-json-ld.json](https://milo.adobe.com/docs/authoring/structured-data-json-ld.json). milo.adobe.com. This AEM spreadsheet is a companion to this document. The normative `requirements` sheet has been absorbed into §3 of this document and is no longer maintained as a separate sheet. The remaining sheets are:
+
+- `sites` — `adobecom` AEM sites in scope, with their GitHub URLs.
+- `tests` — validation cohort pages with their expected primary entity.
+- `types` — reference of supported schema types with Milo, Google, and Schema.org status and documentation links.
+- `integrations` — reference of known JSON-LD producer integrations across sites, with location, trigger, configuration source, and last-updated date.
+
+## A. Canonical Examples
+
+### Example 1: Editorial page graph
+
+Nodes: `WebPage`, `Article`, `BreadcrumbList`, `HowTo`, `FAQPage`, and shared Adobe `Organization`.
+
+```json
+{
+  "@context": "https://schema.org",
+  "@graph": [
+    {
+      "@type": "Organization",
+      "@id": "https://www.adobe.com/#organization",
+      "name": "Adobe",
+      "url": "https://www.adobe.com/"
+    },
+    {
+      "@type": "WebPage",
+      "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#webpage",
+      "url": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html",
+      "name": "Remove Objects from Photos | Photoshop Elements Tips & Tricks",
+      "publisher": {
+        "@id": "https://www.adobe.com/#organization"
+      },
+      "breadcrumb": {
+        "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#breadcrumb"
+      },
+      "mainEntity": {
+        "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#article"
+      }
+    },
+    {
+      "@type": "Article",
+      "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#article",
+      "headline": "How to Remove Unwanted Objects in Photoshop Elements",
+      "description": "Learn how to remove unwanted objects and distractions from photos using the Remove Object tool in Adobe Photoshop Elements.",
+      "isPartOf": {
+        "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#webpage"
+      },
+      "publisher": {
+        "@id": "https://www.adobe.com/#organization"
+      },
+      "mainEntityOfPage": {
+        "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#webpage"
+      },
+      "hasPart": [
+        {
+          "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#howto"
+        },
+        {
+          "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#faq"
+        }
+      ]
+    },
+    {
+      "@type": "BreadcrumbList",
+      "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#breadcrumb",
+      "isPartOf": {
+        "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#webpage"
+      },
+      "itemListElement": [
+        {
+          "@type": "ListItem",
+          "position": 1,
+          "name": "Photoshop Elements",
+          "item": "https://www.adobe.com/products/photoshop-elements.html"
+        },
+        {
+          "@type": "ListItem",
+          "position": 2,
+          "name": "Features",
+          "item": "https://www.adobe.com/products/photoshop-elements/features.html"
+        }
+      ]
+    },
+    {
+      "@type": "HowTo",
+      "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#howto",
+      "isPartOf": {
+        "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#webpage"
+      },
+      "name": "How to Remove Objects from Photos in Photoshop Elements",
+      "description": "Step-by-step instructions for removing unwanted objects from photos using the Remove Object tool in Photoshop Elements."
+    },
+    {
+      "@type": "FAQPage",
+      "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#faq",
+      "isPartOf": {
+        "@id": "https://www.adobe.com/products/photoshop-elements/features/tips-tricks-object-removal.html#webpage"
+      },
+      "mainEntity": [
+        {
+          "@type": "Question",
+          "name": "What is Photoshop Elements and who is it for?",
+          "acceptedAnswer": {
+            "@type": "Answer",
+            "text": "Photoshop Elements is an easy-to-use photo editing application designed for anyone who wants to enhance and create photos without professional experience."
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+### Example 2: Product-oriented page graph
+
+Primary node/entity is `SoftwareApplication` rather than `Article`.
+
+```json
+{
+  "@context": "https://schema.org",
+  "@graph": [
+    {
+      "@type": "Organization",
+      "@id": "https://www.adobe.com/#organization",
+      "name": "Adobe",
+      "url": "https://www.adobe.com/"
+    },
+    {
+      "@type": "WebPage",
+      "@id": "https://www.adobe.com/products/photoshop.html#webpage",
+      "url": "https://www.adobe.com/products/photoshop.html",
+      "name": "Adobe Photoshop",
+      "publisher": {
+        "@id": "https://www.adobe.com/#organization"
+      },
+      "mainEntity": {
+        "@id": "https://www.adobe.com/products/photoshop.html#softwareapplication"
+      }
+    },
+    {
+      "@type": "SoftwareApplication",
+      "@id": "https://www.adobe.com/products/photoshop.html#softwareapplication",
+      "name": "Adobe Photoshop",
+      "url": "https://www.adobe.com/products/photoshop.html",
+      "applicationCategory": "DesignApplication",
+      "applicationSuite": "Adobe Creative Cloud",
+      "operatingSystem": "Windows, macOS",
+      "provider": {
+        "@id": "https://www.adobe.com/#organization"
+      },
+      "brand": {
+        "@type": "Brand",
+        "@id": "https://www.adobe.com/#photoshop-brand",
+        "name": "Photoshop"
+      },
+      "offers": [
+        {
+          "@type": "Offer",
+          "@id": "https://www.adobe.com/products/photoshop.html#paid-offer",
+          "name": "Photoshop subscription",
+          "price": "19.99",
+          "priceCurrency": "USD",
+          "url": "https://www.adobe.com/products/photoshop.html",
+          "availability": "https://schema.org/InStock"
+        },
+        {
+          "@type": "Offer",
+          "@id": "https://www.adobe.com/products/photoshop.html#free-trial",
+          "name": "Free trial",
+          "price": "0.00",
+          "priceCurrency": "USD",
+          "url": "https://www.adobe.com/products/photoshop.html",
+          "availability": "https://schema.org/InStock"
+        }
+      ]
+    }
+  ]
+}
+```
+
+### Example 3: Merch card Product → SoftwareApplication transformation
+
+The merch card system currently emits a `Product` node per card. The graph manager normalizes this into a `SoftwareApplication` (see §2.4 type-specific transforms). Nested `Brand` and `Offer` entities are hoisted to the top-level `@graph`; references to the site-wide `Organization` are replaced with `{ "@id": "https://www.adobe.com/#organization" }` and the manager-synthesized canonical Organization.
+
+Note that the manager produces incomplete nodes when source data is unavailable. For example, the merch card payload below has no `aggregateRating`, no `review`, no `applicationCategory`, and no `operatingSystem`; the manager preserves what producers provide and does not invent values for these fields.
+
+#### Input — merch card producer payload
+
+```json
+{
+  "@context": "https://schema.org/",
+  "@type": "Product",
+  "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#product",
+  "name": "This is a new card created by Axel.",
+  "brand": {
+    "@type": "Brand",
+    "name": "Adobe"
+  },
+  "offers": [
+    {
+      "@type": "Offer",
+      "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#offer",
+      "url": "https://main--cc--adobecom.aem.page/drafts/axel/document5",
+      "priceCurrency": "USD",
+      "price": "662.9",
+      "availability": "https://schema.org/InStock",
+      "category": "Subscription",
+      "seller": { "@id": "https://www.adobe.com/#org" },
+      "itemOffered": { "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#product" },
+      "priceSpecification": {
+        "@type": "UnitPriceSpecification",
+        "price": "662.9",
+        "priceCurrency": "USD",
+        "billingDuration": "P1Y",
+        "billingIncrement": 1,
+        "priceWithoutDiscount": "779.88"
+      }
+    }
+  ],
+  "image": [
+    "https://www.adobe.com/cc-shared/assets/img/product-icons/svg/creative-cloud.svg?format=png&width=800&height=800",
+    "https://www.adobe.com/cc-shared/assets/img/product-icons/svg/photoshop.svg?format=png&width=800&height=800"
+  ]
+}
+```
+
+#### Output — managed graph
+
+```json
+{
+  "@context": "https://schema.org",
+  "@graph": [
+    {
+      "@type": "Organization",
+      "@id": "https://www.adobe.com/#organization",
+      "name": "Adobe",
+      "url": "https://www.adobe.com/",
+      "logo": {
+        "@type": "ImageObject",
+        "url": "https://www.adobe.com/content/dam/cc/icons/Adobe_Corporate_Horizontal_Red_HEX.svg",
+        "contentUrl": "https://www.adobe.com/content/dam/cc/icons/Adobe_Corporate_Horizontal_Red_HEX.svg"
+      }
+    },
+    {
+      "@type": "WebPage",
+      "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#webpage",
+      "url": "https://main--cc--adobecom.aem.page/drafts/axel/document5",
+      "publisher": {
+        "@id": "https://www.adobe.com/#organization"
+      },
+      "mainEntity": {
+        "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#softwareapplication"
+      }
+    },
+    {
+      "@type": "SoftwareApplication",
+      "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#softwareapplication",
+      "name": "This is a new card created by Axel.",
+      "url": "https://main--cc--adobecom.aem.page/drafts/axel/document5",
+      "isPartOf": {
+        "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#webpage"
+      },
+      "provider": {
+        "@id": "https://www.adobe.com/#organization"
+      },
+      "brand": {
+        "@type": "Brand",
+        "name": "Adobe"
+      },
+      "image": [
+        "https://www.adobe.com/cc-shared/assets/img/product-icons/svg/creative-cloud.svg?format=png&width=800&height=800",
+        "https://www.adobe.com/cc-shared/assets/img/product-icons/svg/photoshop.svg?format=png&width=800&height=800"
+      ],
+      "offers": [
+        { "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#offer" }
+      ]
+    },
+    {
+      "@type": "Offer",
+      "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#offer",
+      "url": "https://main--cc--adobecom.aem.page/drafts/axel/document5",
+      "price": "662.9",
+      "priceCurrency": "USD",
+      "availability": "https://schema.org/InStock",
+      "category": "Subscription",
+      "seller": {
+        "@id": "https://www.adobe.com/#organization"
+      },
+      "itemOffered": {
+        "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#softwareapplication"
+      },
+      "priceSpecification": {
+        "@type": "UnitPriceSpecification",
+        "price": "662.9",
+        "priceCurrency": "USD",
+        "billingDuration": "P1Y",
+        "billingIncrement": 1,
+        "priceWithoutDiscount": "779.88"
+      }
+    }
+  ]
+}
+```
+
+Notes on the transform:
+
+- The producer-supplied `Product#product` `@id` is replaced with the canonical `#softwareapplication` `@id`; the inline `Offer.itemOffered` reference is rewritten to point at the new id.
+- The producer-supplied seller `@id` `https://www.adobe.com/#org` is normalized to the canonical `https://www.adobe.com/#organization`. (Producer-side fix-up planned; manager performs this canonicalization defensively.)
+- The inline `Brand` is small and anonymous; the manager retains it inline rather than hoisting it to a top-level node. Hoisting is reserved for typed entities that have or can derive a stable `@id`.
+- Producer fields not satisfying Google rich-results requirements (`aggregateRating` / `review`, `applicationCategory`, `operatingSystem`) are absent in this example; corresponding `softwareapplication-rating-or-review` warnings would fire for this output until producers supply that data.
diff --git a/libs/utils/utils.js b/libs/utils/utils.js
index 04a60c88a31..eac89052688 100644
--- a/libs/utils/utils.js
+++ b/libs/utils/utils.js
@@ -2526,6 +2526,12 @@ async function decorateDocumentExtras() {
 }
 
 async function documentPostSectionLoading(config) {
+  const jsonLdFlag = (PAGE_URL.searchParams.get('jsonld-graph-manager') || getMetadata('jsonld-graph-manager') || '').toLowerCase();
+  if (jsonLdFlag === 'true') {
+    const { default: initJsonLd } = await import('../features/jsonld-graph-manager/jsonld-graph-manager.js');
+    await initJsonLd();
+  }
+
   const injectBlock = getMetadata('injectblock');
   if (injectBlock) {
     import('./injectblock.js').then((module) => module.default(injectBlock));
diff --git a/test/features/jsonld-graph-manager/jsonld-graph-manager.test.js b/test/features/jsonld-graph-manager/jsonld-graph-manager.test.js
new file mode 100644
index 00000000000..b28e73750c2
--- /dev/null
+++ b/test/features/jsonld-graph-manager/jsonld-graph-manager.test.js
@@ -0,0 +1,1068 @@
+import { readFile } from '@web/test-runner-commands';
+import { expect } from '@esm-bundle/chai';
+import sinon from 'sinon';
+
+import {
+  flattenPayload,
+  parsePayload,
+  normalizeNode,
+  unionByRef,
+  mergeNodes,
+  injectLinks,
+  extractInlineEntities,
+  rewriteCrossPageRefs,
+  canonicalizeOrgId,
+  siteRoot,
+  defaultOrg,
+  JsonLdGraphManager,
+} from '../../../libs/features/jsonld-graph-manager/jsonld-graph-manager.js';
+
+const PAGE_URL = 'https://www.adobe.com/products/photoshop.html';
+const ORG_ID = 'https://www.adobe.com/#organization'; // www default
+const ADOBE_LOGO_URL = 'https://www.adobe.com/content/dam/cc/icons/Adobe_Corporate_Horizontal_Red_HEX.svg';
+const ADOBE_LOGO_OBJECT = {
+  '@type': 'ImageObject',
+  url: ADOBE_LOGO_URL,
+  contentUrl: ADOBE_LOGO_URL,
+};
+
+function setCanonical(url = PAGE_URL) {
+  document.head.querySelector('link[rel="canonical"]')?.remove();
+  const link = document.createElement('link');
+  link.rel = 'canonical';
+  link.href = url;
+  document.head.appendChild(link);
+}
+
+function makeScript(obj) {
+  const el = document.createElement('script');
+  el.type = 'application/ld+json';
+  el.textContent = typeof obj === 'string' ? obj : JSON.stringify(obj);
+  return el;
+}
+
+const activeManagers = new Set();
+
+const OriginalManager = JsonLdGraphManager;
+function trackedManager(...args) {
+  const m = new OriginalManager(...args);
+  activeManagers.add(m);
+  return m;
+}
+
+function resetManager() {
+  activeManagers.forEach((m) => m.destroy?.());
+  activeManagers.clear();
+  window.miloJsonLdGraphManager = null;
+  document.head.querySelector('script[data-milo-jsonld="graph"]')?.remove();
+  document.head.querySelectorAll('script[type="application/ld+json"]').forEach((s) => s.remove());
+  document.body.querySelectorAll('script[type="application/ld+json"]').forEach((s) => s.remove());
+}
+
+before(() => {
+  window.lana = { log: sinon.stub() };
+  setCanonical();
+});
+
+afterEach(() => {
+  resetManager();
+  window.lana.log.resetHistory();
+});
+
+// ---------------------------------------------------------------------------
+// flattenPayload
+// ---------------------------------------------------------------------------
+describe('flattenPayload', () => {
+  it('wraps a single object in an array', () => {
+    const result = flattenPayload({ '@type': 'Article' });
+    expect(result).to.deep.equal([{ '@type': 'Article' }]);
+  });
+
+  it('returns an array as-is', () => {
+    const arr = [{ '@type': 'Article' }, { '@type': 'WebPage' }];
+    expect(flattenPayload(arr)).to.deep.equal(arr);
+  });
+
+  it('extracts @graph nodes', () => {
+    const result = flattenPayload({ '@graph': [{ '@type': 'Article' }] });
+    expect(result).to.deep.equal([{ '@type': 'Article' }]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parsePayload
+// ---------------------------------------------------------------------------
+describe('parsePayload', () => {
+  it('parses a single object', () => {
+    const nodes = parsePayload(makeScript({ '@type': 'Article', headline: 'Hello' }));
+    expect(nodes).to.have.length(1);
+    expect(nodes[0]['@type']).to.equal('Article');
+  });
+
+  it('parses an array payload', () => {
+    const nodes = parsePayload(makeScript([{ '@type': 'Article' }, { '@type': 'WebPage' }]));
+    expect(nodes).to.have.length(2);
+  });
+
+  it('parses a @graph payload', () => {
+    const nodes = parsePayload(makeScript({ '@graph': [{ '@type': 'Article' }, { '@type': 'BreadcrumbList' }] }));
+    expect(nodes).to.have.length(2);
+  });
+
+  it('logs a Lana warning and returns [] on invalid JSON', () => {
+    const nodes = parsePayload(makeScript('{ bad json }'));
+    expect(nodes).to.deep.equal([]);
+    expect(window.lana.log.called).to.be.true;
+    expect(window.lana.log.firstCall.args[1].severity).to.equal('warn');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// normalizeNode
+// ---------------------------------------------------------------------------
+describe('normalizeNode', () => {
+  it('assigns canonical page-scoped @id to Article', () => {
+    const node = normalizeNode({ '@context': 'https://schema.org', '@type': 'Article', headline: 'Hi' });
+    expect(node['@id']).to.equal(`${PAGE_URL}#article`);
+  });
+
+  it('assigns canonical page-scoped @id to WebPage', () => {
+    const node = normalizeNode({ '@type': 'WebPage' });
+    expect(node['@id']).to.equal(`${PAGE_URL}#webpage`);
+  });
+
+  it('assigns site-wide @id to Organization', () => {
+    const node = normalizeNode({ '@type': 'Organization', name: 'Adobe' });
+    expect(node['@id']).to.equal(ORG_ID);
+  });
+
+  it('strips per-node @context', () => {
+    const node = normalizeNode({ '@context': 'https://schema.org', '@type': 'Article' });
+    expect(node['@context']).to.be.undefined;
+  });
+
+  it('retains unknown types without @id', () => {
+    const node = normalizeNode({ '@type': 'UnknownType', name: 'X' });
+    expect(node['@id']).to.be.undefined;
+    expect(node['@type']).to.equal('UnknownType');
+  });
+
+  it('retains nodes with no @type', () => {
+    const node = normalizeNode({ name: 'bare node' });
+    expect(node.name).to.equal('bare node');
+    expect(node['@id']).to.be.undefined;
+  });
+});
+
+// ---------------------------------------------------------------------------
+// unionByRef
+// ---------------------------------------------------------------------------
+describe('unionByRef', () => {
+  it('unions two arrays by @id, deduplicating', () => {
+    const a = [{ '@id': '#a' }, { '@id': '#b' }];
+    const b = [{ '@id': '#b' }, { '@id': '#c' }];
+    const result = unionByRef(a, b);
+    expect(result).to.have.length(3);
+    expect(result.map((n) => n['@id'])).to.include.members(['#a', '#b', '#c']);
+  });
+
+  it('handles undefined inputs', () => {
+    expect(unionByRef(undefined, [{ '@id': '#a' }])).to.deep.equal([{ '@id': '#a' }]);
+    expect(unionByRef([{ '@id': '#a' }], undefined)).to.deep.equal([{ '@id': '#a' }]);
+  });
+
+  it('wraps non-array values', () => {
+    const result = unionByRef({ '@id': '#a' }, { '@id': '#b' });
+    expect(result).to.have.length(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// mergeNodes
+// ---------------------------------------------------------------------------
+describe('mergeNodes', () => {
+  it('runtime source wins over bootDom on scalar conflict', () => {
+    const bootNode = { '@type': 'Organization', '@id': ORG_ID, name: 'Adobe' };
+    const runtimeNode = { '@type': 'Organization', '@id': ORG_ID, name: 'Adobe Inc.' };
+    const result = mergeNodes(bootNode, runtimeNode, 'bootDom', 'runtime');
+    expect(result.name).to.equal('Adobe Inc.');
+  });
+
+  it('bootDom wins over another bootDom (first wins via >=)', () => {
+    const a = { '@type': 'Organization', '@id': ORG_ID, name: 'First' };
+    const b = { '@type': 'Organization', '@id': ORG_ID, name: 'Second' };
+    const result = mergeNodes(a, b, 'bootDom', 'bootDom');
+    expect(result.name).to.equal('First');
+  });
+
+  it('merges fields present only on loser', () => {
+    const a = { '@type': 'Organization', '@id': ORG_ID, name: 'Adobe' };
+    const b = { '@type': 'Organization', '@id': ORG_ID, logo: 'https://www.adobe.com/logo.png' };
+    const result = mergeNodes(a, b, 'runtime', 'bootDom');
+    expect(result.name).to.equal('Adobe');
+    expect(result.logo).to.equal('https://www.adobe.com/logo.png');
+  });
+
+  it('unions reference arrays', () => {
+    const a = { '@type': 'Article', '@id': `${PAGE_URL}#article`, hasPart: [{ '@id': '#howto' }] };
+    const b = { '@type': 'Article', '@id': `${PAGE_URL}#article`, hasPart: [{ '@id': '#faq' }] };
+    const result = mergeNodes(a, b, 'bootDom', 'runtime');
+    expect(result.hasPart).to.have.length(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// injectLinks
+// ---------------------------------------------------------------------------
+describe('injectLinks', () => {
+  it('adds isPartOf to Article pointing at WebPage', () => {
+    const webpage = { '@type': 'WebPage', '@id': `${PAGE_URL}#webpage` };
+    const article = { '@type': 'Article', '@id': `${PAGE_URL}#article` };
+    injectLinks([webpage, article]);
+    expect(article.isPartOf).to.deep.equal({ '@id': `${PAGE_URL}#webpage` });
+  });
+
+  it('adds mainEntity to WebPage pointing at Article', () => {
+    const webpage = { '@type': 'WebPage', '@id': `${PAGE_URL}#webpage` };
+    const article = { '@type': 'Article', '@id': `${PAGE_URL}#article` };
+    injectLinks([webpage, article]);
+    expect(webpage.mainEntity).to.deep.equal({ '@id': `${PAGE_URL}#article` });
+  });
+
+  it('adds publisher to WebPage pointing at Organization', () => {
+    const org = { '@type': 'Organization', '@id': ORG_ID };
+    const webpage = { '@type': 'WebPage', '@id': `${PAGE_URL}#webpage` };
+    injectLinks([org, webpage]);
+    expect(webpage.publisher).to.deep.equal({ '@id': ORG_ID });
+  });
+
+  it('does not overwrite existing links', () => {
+    const webpage = { '@type': 'WebPage', '@id': `${PAGE_URL}#webpage`, mainEntity: { '@id': '#custom' } };
+    const article = { '@type': 'Article', '@id': `${PAGE_URL}#article` };
+    injectLinks([webpage, article]);
+    expect(webpage.mainEntity).to.deep.equal({ '@id': '#custom' });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// JsonLdGraphManager — boot scan & rewrite
+// ---------------------------------------------------------------------------
+describe('JsonLdGraphManager boot scan', () => {
+  it('ingests pre-existing scripts and produces a managed graph', () => {
+    const script = makeScript({ '@type': 'Article', headline: 'Hello' });
+    document.head.appendChild(script);
+
+    const manager = trackedManager();
+    manager.init();
+
+    const managed = document.head.querySelector('script[data-milo-jsonld="graph"]');
+    expect(managed).to.exist;
+    const graph = JSON.parse(managed.textContent);
+    expect(graph['@context']).to.equal('https://schema.org');
+    expect(graph['@graph']).to.be.an('array');
+    const article = graph['@graph'].find((n) => n['@type'] === 'Article');
+    expect(article).to.exist;
+    expect(article['@id']).to.equal(`${PAGE_URL}#article`);
+  });
+
+  it('removes ingested unmanaged scripts from the DOM', () => {
+    const script = makeScript({ '@type': 'Article', headline: 'Hello' });
+    document.head.appendChild(script);
+    const manager = trackedManager();
+    manager.init();
+    expect(document.head.contains(script)).to.be.false;
+  });
+
+  it('does not re-ingest the managed script', () => {
+    const script = makeScript({ '@type': 'Article' });
+    document.head.appendChild(script);
+    const manager = trackedManager();
+    manager.init();
+
+    const managedScripts = document.head.querySelectorAll('script[data-milo-jsonld="graph"]');
+    expect(managedScripts).to.have.length(1);
+    const count = JSON.parse(managedScripts[0].textContent)['@graph'].length;
+
+    manager.rebuild();
+    const afterCount = JSON.parse(document.head.querySelector('script[data-milo-jsonld="graph"]').textContent)['@graph'].length;
+    expect(afterCount).to.equal(count);
+  });
+
+  it('emits a baseline WebPage + Organization graph when no producers are present', () => {
+    const manager = trackedManager();
+    manager.init();
+    const managed = document.head.querySelector('script[data-milo-jsonld="graph"]');
+    expect(managed).to.exist;
+    const graph = JSON.parse(managed.textContent)['@graph'];
+    const types = graph.map((n) => n['@type']);
+    expect(types).to.include.members(['WebPage', 'Organization']);
+    const webpage = graph.find((n) => n['@type'] === 'WebPage');
+    expect(webpage.publisher).to.deep.equal({ '@id': ORG_ID });
+    const org = graph.find((n) => n['@type'] === 'Organization');
+    expect(org['@id']).to.equal(ORG_ID);
+    expect(org.name).to.equal('Adobe');
+    expect(org.url).to.equal('https://www.adobe.com/');
+    expect(org.logo).to.deep.equal(ADOBE_LOGO_OBJECT);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// JsonLdGraphManager — singleton enforcement
+// ---------------------------------------------------------------------------
+describe('JsonLdGraphManager singleton enforcement', () => {
+  it('merges two Organization nodes into one', () => {
+    const s1 = makeScript({ '@type': 'Organization', name: 'Adobe', logo: 'logo.png' });
+    const s2 = makeScript({ '@type': 'Organization', name: 'Adobe Inc.' });
+    document.head.appendChild(s1);
+    document.head.appendChild(s2);
+
+    const manager = trackedManager();
+    manager.init();
+
+    const graph = JSON.parse(document.head.querySelector('script[data-milo-jsonld="graph"]').textContent)['@graph'];
+    const orgs = graph.filter((n) => n['@type'] === 'Organization');
+    expect(orgs).to.have.length(1);
+    expect(orgs[0]['@id']).to.equal(ORG_ID);
+    // generated baseline wins — logo is the manager default, not the producer-supplied value
+    expect(orgs[0].logo).to.deep.equal(ADOBE_LOGO_OBJECT);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// JsonLdGraphManager — output contract
+// ---------------------------------------------------------------------------
+describe('JsonLdGraphManager output contract', () => {
+  it('emits exactly one managed script', () => {
+    document.head.appendChild(makeScript({ '@type': 'Article' }));
+    const manager = trackedManager();
+    manager.init();
+    manager.rebuild();
+    expect(document.head.querySelectorAll('script[data-milo-jsonld="graph"]')).to.have.length(1);
+  });
+
+  it('managed script has @context: https://schema.org at root', () => {
+    document.head.appendChild(makeScript({ '@type': 'Article' }));
+    const manager = trackedManager();
+    manager.init();
+    const graph = JSON.parse(document.head.querySelector('script[data-milo-jsonld="graph"]').textContent);
+    expect(graph['@context']).to.equal('https://schema.org');
+  });
+
+  it('individual nodes do not have @context', () => {
+    document.head.appendChild(makeScript({ '@context': 'https://schema.org', '@type': 'Article' }));
+    const manager = trackedManager();
+    manager.init();
+    const graph = JSON.parse(document.head.querySelector('script[data-milo-jsonld="graph"]').textContent);
+    for (const node of graph['@graph']) {
+      expect(node['@context']).to.be.undefined;
+    }
+  });
+
+  it('WebPage appears first in @graph', () => {
+    document.head.appendChild(makeScript({ '@type': 'Article' }));
+    document.head.appendChild(makeScript({ '@type': 'WebPage' }));
+    const manager = trackedManager();
+    manager.init();
+    const graph = JSON.parse(document.head.querySelector('script[data-milo-jsonld="graph"]').textContent);
+    expect(graph['@graph'][0]['@type']).to.equal('WebPage');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// JsonLdGraphManager — MutationObserver (runtime mutation)
+// ---------------------------------------------------------------------------
+describe('JsonLdGraphManager mutation observer', () => {
+  it('picks up a script appended after init', async () => {
+    const manager = trackedManager();
+    manager.init();
+
+    const script = makeScript({ '@type': 'WebPage' });
+    document.head.appendChild(script);
+
+    // Flush the microtask queue so MutationObserver fires; then rebuild directly
+    // eslint-disable-next-line no-promise-executor-return
+    await new Promise((r) => setTimeout(r, 0));
+    manager.rebuild();
+
+    const managed = document.head.querySelector('script[data-milo-jsonld="graph"]');
+    expect(managed).to.exist;
+    const graph = JSON.parse(managed.textContent)['@graph'];
+    expect(graph.some((n) => n['@type'] === 'WebPage')).to.be.true;
+  });
+});
+
+// ---------------------------------------------------------------------------
+// End-to-end pipeline — editorial fixture
+// ---------------------------------------------------------------------------
+describe('end-to-end: editorial page', () => {
+  beforeEach(async () => {
+    resetManager();
+    document.body.innerHTML = await readFile({ path: './mocks/editorial.html' });
+    // appendChild moves nodes from body to head (no s.remove() needed)
+    [...document.body.querySelectorAll('script[type="application/ld+json"]')]
+      .forEach((s) => document.head.appendChild(s));
+  });
+
+  afterEach(() => {
+    document.body.innerHTML = '';
+    resetManager();
+  });
+
+  it('produces a linked @graph for an editorial page', () => {
+    const manager = trackedManager();
+    manager.init();
+
+    const managed = document.head.querySelector('script[data-milo-jsonld="graph"]');
+    expect(managed).to.exist;
+    const { '@graph': graph } = JSON.parse(managed.textContent);
+
+    const webpage = graph.find((n) => n['@type'] === 'WebPage');
+    const article = graph.find((n) => n['@type'] === 'Article');
+    const org = graph.find((n) => n['@type'] === 'Organization');
+    const bc = graph.find((n) => n['@type'] === 'BreadcrumbList');
+
+    expect(webpage).to.exist;
+    expect(article).to.exist;
+    expect(org).to.exist;
+    expect(bc).to.exist;
+
+    expect(org['@id']).to.equal(ORG_ID);
+    expect(webpage['@id']).to.equal(`${PAGE_URL}#webpage`);
+    expect(article['@id']).to.equal(`${PAGE_URL}#article`);
+    expect(bc['@id']).to.equal(`${PAGE_URL}#breadcrumb`);
+
+    expect(webpage.mainEntity?.['@id']).to.equal(`${PAGE_URL}#article`);
+    expect(webpage.breadcrumb?.['@id']).to.equal(`${PAGE_URL}#breadcrumb`);
+    expect(webpage.publisher?.['@id']).to.equal(ORG_ID);
+    expect(article.isPartOf?.['@id']).to.equal(`${PAGE_URL}#webpage`);
+    expect(bc.isPartOf?.['@id']).to.equal(`${PAGE_URL}#webpage`);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// End-to-end pipeline — product fixture
+// ---------------------------------------------------------------------------
+describe('end-to-end: product page', () => {
+  beforeEach(async () => {
+    resetManager();
+    document.body.innerHTML = await readFile({ path: './mocks/product.html' });
+    [...document.body.querySelectorAll('script[type="application/ld+json"]')]
+      .forEach((s) => document.head.appendChild(s));
+  });
+
+  afterEach(() => {
+    document.body.innerHTML = '';
+    resetManager();
+  });
+
+  it('produces a linked @graph for a product page', () => {
+    const manager = trackedManager();
+    manager.init();
+
+    const { '@graph': graph } = JSON.parse(
+      document.head.querySelector('script[data-milo-jsonld="graph"]').textContent,
+    );
+
+    const webpage = graph.find((n) => n['@type'] === 'WebPage');
+    const app = graph.find((n) => n['@type'] === 'SoftwareApplication');
+
+    expect(webpage).to.exist;
+    expect(app).to.exist;
+    expect(webpage.mainEntity?.['@id']).to.equal(`${PAGE_URL}#softwareapplication`);
+    expect(app.provider?.['@id']).to.equal(ORG_ID);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// End-to-end pipeline — multi-producer conflict
+// ---------------------------------------------------------------------------
+describe('end-to-end: multi-producer conflict', () => {
+  beforeEach(async () => {
+    resetManager();
+    document.body.innerHTML = await readFile({ path: './mocks/multi-producer.html' });
+    // appendChild moves nodes from body to head without an explicit remove
+    [...document.body.querySelectorAll('script[type="application/ld+json"]')]
+      .forEach((s) => document.head.appendChild(s));
+  });
+
+  afterEach(() => {
+    document.body.innerHTML = '';
+    resetManager();
+  });
+
+  it('merges two Organization nodes into one entry', () => {
+    const manager = trackedManager();
+    // Enqueue first script as bootDom, second as runtime to test priority
+    const allScripts = [...document.head.querySelectorAll('script[type="application/ld+json"]')];
+    const orgScripts = allScripts.filter((s) => {
+      try { return JSON.parse(s.textContent)['@type'] === 'Organization'; } catch { return false; }
+    });
+
+    orgScripts.forEach((s, i) => manager.enqueue(s, i === 0 ? 'bootDom' : 'runtime'));
+    manager.rebuild();
+
+    const { '@graph': graph } = JSON.parse(
+      document.head.querySelector('script[data-milo-jsonld="graph"]').textContent,
+    );
+    const orgs = graph.filter((n) => n['@type'] === 'Organization');
+    expect(orgs).to.have.length(1);
+    expect(orgs[0]['@id']).to.equal(ORG_ID);
+    // generated baseline wins over all producer sources
+    expect(orgs[0].name).to.equal('Adobe');
+    expect(orgs[0].logo).to.deep.equal(ADOBE_LOGO_OBJECT);
+    // producer-only field (sameAs) is preserved
+    expect(orgs[0].sameAs).to.equal('https://en.wikipedia.org/wiki/Adobe_Inc.');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Organization synthesis and domain selection
+// ---------------------------------------------------------------------------
+describe('Organization synthesis', () => {
+  it('synthesizes a default Organization when none is provided', () => {
+    document.head.appendChild(makeScript({ '@type': 'Article', headline: 'Hello' }));
+    const manager = trackedManager();
+    manager.init();
+
+    const { '@graph': graph } = JSON.parse(
+      document.head.querySelector('script[data-milo-jsonld="graph"]').textContent,
+    );
+    const org = graph.find((n) => n['@type'] === 'Organization');
+    expect(org).to.exist;
+    expect(org['@id']).to.equal(ORG_ID);
+    expect(org.name).to.equal('Adobe');
+    expect(org.url).to.equal('https://www.adobe.com/');
+    expect(org.logo).to.deep.equal(ADOBE_LOGO_OBJECT);
+  });
+
+  it('generated baseline fields win over producer-supplied values', () => {
+    document.head.appendChild(makeScript({ '@type': 'Organization', name: 'Acme', url: 'https://acme.com/', sameAs: 'https://example.com' }));
+    const manager = trackedManager();
+    manager.init();
+
+    const { '@graph': graph } = JSON.parse(
+      document.head.querySelector('script[data-milo-jsonld="graph"]').textContent,
+    );
+    const org = graph.find((n) => n['@type'] === 'Organization');
+    expect(org.name).to.equal('Adobe');
+    expect(org.url).to.equal('https://www.adobe.com/');
+    // producer-only field preserved
+    expect(org.sameAs).to.equal('https://example.com');
+  });
+
+  it('siteRoot() returns business URL for business/bacom hostnames', () => {
+    expect(siteRoot('business.adobe.com')).to.equal('https://business.adobe.com');
+    expect(siteRoot('bacom.adobe.com')).to.equal('https://business.adobe.com');
+    expect(siteRoot('www.adobe.com')).to.equal('https://www.adobe.com');
+    expect(siteRoot('localhost')).to.equal('https://www.adobe.com');
+  });
+
+  it('defaultOrg() returns correct values for business hostname', () => {
+    const org = defaultOrg('business.adobe.com');
+    expect(org.name).to.equal('Adobe for Business');
+    expect(org['@id']).to.equal('https://business.adobe.com/#organization');
+    expect(org.url).to.equal('https://business.adobe.com/');
+    expect(org.logo).to.deep.equal(ADOBE_LOGO_OBJECT);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// extractInlineEntities
+// ---------------------------------------------------------------------------
+describe('extractInlineEntities', () => {
+  it('hoists inline Organization to top-level and replaces with @id ref', () => {
+    const node = {
+      '@type': 'Article',
+      '@id': `${PAGE_URL}#article`,
+      publisher: { '@type': 'Organization', name: 'Adobe' },
+    };
+    const extracted = extractInlineEntities(node);
+    expect(extracted).to.have.length(1);
+    expect(extracted[0]['@type']).to.equal('Organization');
+    expect(extracted[0]['@id']).to.equal(ORG_ID);
+    expect(node.publisher).to.deep.equal({ '@id': ORG_ID });
+  });
+
+  it('hoists inline objects that already have @id and rewrites them as references', () => {
+    const node = {
+      '@type': 'Article',
+      publisher: { '@type': 'Organization', '@id': ORG_ID, name: 'Adobe' },
+    };
+    const extracted = extractInlineEntities(node);
+    expect(extracted).to.have.length(1);
+    expect(extracted[0]['@type']).to.equal('Organization');
+    expect(extracted[0]['@id']).to.equal(ORG_ID);
+    expect(node.publisher).to.deep.equal({ '@id': ORG_ID });
+  });
+
+  it('leaves inline objects with unknown @type untouched', () => {
+    const node = { '@type': 'Article', publisher: { '@type': 'UnknownThing', name: 'X' } };
+    const extracted = extractInlineEntities(node);
+    expect(extracted).to.have.length(0);
+  });
+
+  it('integrates hoisted entities into the graph via manager', () => {
+    document.head.appendChild(makeScript({
+      '@type': 'Article',
+      headline: 'Hello',
+      publisher: { '@type': 'Organization', name: 'Adobe' },
+    }));
+    const manager = trackedManager();
+    manager.init();
+
+    const { '@graph': graph } = JSON.parse(
+      document.head.querySelector('script[data-milo-jsonld="graph"]').textContent,
+    );
+    const article = graph.find((n) => n['@type'] === 'Article');
+    const org = graph.find((n) => n['@type'] === 'Organization');
+    expect(org).to.exist;
+    expect(article.publisher).to.deep.equal({ '@id': ORG_ID });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Type transform: Product → SoftwareApplication
+// ---------------------------------------------------------------------------
+describe('Product → SoftwareApplication transform', () => {
+  it('rewrites @type and assigns canonical SA @id', () => {
+    const out = normalizeNode({ '@type': 'Product', name: 'X', description: 'Y' });
+    expect(out['@type']).to.equal('SoftwareApplication');
+    expect(out['@id']).to.equal(`${PAGE_URL}#softwareapplication`);
+    expect(out.name).to.equal('X');
+    expect(out.description).to.equal('Y');
+  });
+
+  it('produces no Product nodes in the managed graph (review-block shape)', () => {
+    document.head.appendChild(makeScript({
+      '@context': 'http://schema.org',
+      '@type': 'Product',
+      name: 'Adobe Photoshop',
+      description: 'Photo editor',
+    }));
+    const manager = trackedManager();
+    manager.init();
+
+    const { '@graph': graph } = JSON.parse(
+      document.head.querySelector('script[data-milo-jsonld="graph"]').textContent,
+    );
+    expect(graph.some((n) => n['@type'] === 'Product')).to.be.false;
+    const sa = graph.find((n) => n['@type'] === 'SoftwareApplication');
+    expect(sa).to.exist;
+    expect(sa.name).to.equal('Adobe Photoshop');
+    expect(sa.description).to.equal('Photo editor');
+    expect(sa['@id']).to.equal(`${PAGE_URL}#softwareapplication`);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Inline Offer hoisting (extractInlineEntities array handling)
+// ---------------------------------------------------------------------------
+describe('inline Offer hoisting', () => {
+  it('hoists inline Offers from offers array and replaces with @id refs', () => {
+    const node = {
+      '@type': 'SoftwareApplication',
+      offers: [
+        { '@type': 'Offer', '@id': 'producer/path#offer', price: '19.99', priceCurrency: 'USD' },
+      ],
+    };
+    const extracted = extractInlineEntities(node);
+    expect(extracted).to.have.length(1);
+    expect(extracted[0]['@type']).to.equal('Offer');
+    expect(extracted[0]['@id']).to.equal(`${PAGE_URL}#offer`);
+    expect(extracted[0].price).to.equal('19.99');
+    expect(node.offers).to.deep.equal([{ '@id': `${PAGE_URL}#offer` }]);
+  });
+
+  it('preserves non-typed array entries (e.g., URL strings)', () => {
+    const node = {
+      '@type': 'BreadcrumbList',
+      itemListElement: ['https://example.com/a', 'https://example.com/b'],
+    };
+    const extracted = extractInlineEntities(node);
+    expect(extracted).to.have.length(0);
+    expect(node.itemListElement).to.deep.equal([
+      'https://example.com/a',
+      'https://example.com/b',
+    ]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Brand stays inline (not in RULES)
+// ---------------------------------------------------------------------------
+describe('inline Brand handling', () => {
+  it('does not hoist anonymous Brand', () => {
+    const node = {
+      '@type': 'SoftwareApplication',
+      brand: { '@type': 'Brand', name: 'Adobe' },
+    };
+    const extracted = extractInlineEntities(node);
+    expect(extracted).to.have.length(0);
+    expect(node.brand).to.deep.equal({ '@type': 'Brand', name: 'Adobe' });
+  });
+
+  it('does not hoist Brand even when producer assigns @id', () => {
+    const node = {
+      '@type': 'SoftwareApplication',
+      brand: { '@type': 'Brand', '@id': 'https://example.com/#brand', name: 'Adobe' },
+    };
+    const extracted = extractInlineEntities(node);
+    expect(extracted).to.have.length(0);
+    expect(node.brand['@type']).to.equal('Brand');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// canonicalizeOrgId — defensive #org → #organization rewrite
+// ---------------------------------------------------------------------------
+describe('canonicalizeOrgId', () => {
+  it('rewrites #org alias to #organization', () => {
+    expect(canonicalizeOrgId('https://www.adobe.com/#org'))
+      .to.equal('https://www.adobe.com/#organization');
+  });
+
+  it('rewrites #publisher and #adobe aliases', () => {
+    expect(canonicalizeOrgId('https://www.adobe.com/#publisher'))
+      .to.equal('https://www.adobe.com/#organization');
+    expect(canonicalizeOrgId('https://www.adobe.com/#adobe'))
+      .to.equal('https://www.adobe.com/#organization');
+  });
+
+  it('leaves canonical #organization unchanged', () => {
+    const id = 'https://www.adobe.com/#organization';
+    expect(canonicalizeOrgId(id)).to.equal(id);
+  });
+
+  it('leaves unrelated fragments unchanged', () => {
+    const id = 'https://www.adobe.com/page#article';
+    expect(canonicalizeOrgId(id)).to.equal(id);
+  });
+
+  it('handles ids with no fragment', () => {
+    const id = 'https://www.adobe.com/page';
+    expect(canonicalizeOrgId(id)).to.equal(id);
+  });
+
+  it('canonicalizes Org alias references end-to-end through manager', () => {
+    document.head.appendChild(makeScript({
+      '@type': 'Article',
+      headline: 'Test',
+      publisher: { '@id': 'https://www.adobe.com/#org' },
+    }));
+    const manager = trackedManager();
+    manager.init();
+
+    const { '@graph': graph } = JSON.parse(
+      document.head.querySelector('script[data-milo-jsonld="graph"]').textContent,
+    );
+    const article = graph.find((n) => n['@type'] === 'Article');
+    expect(article.publisher).to.deep.equal({ '@id': ORG_ID });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// BreadcrumbList "when applicable"
+// ---------------------------------------------------------------------------
+describe('graph without BreadcrumbList', () => {
+  it('produces a valid graph without breadcrumb property on WebPage', () => {
+    document.head.appendChild(makeScript({
+      '@type': 'Article',
+      headline: 'No breadcrumbs here',
+    }));
+    const manager = trackedManager();
+    manager.init();
+
+    const { '@graph': graph } = JSON.parse(
+      document.head.querySelector('script[data-milo-jsonld="graph"]').textContent,
+    );
+    expect(graph.some((n) => n['@type'] === 'BreadcrumbList')).to.be.false;
+    const webpage = graph.find((n) => n['@type'] === 'WebPage');
+    expect(webpage.breadcrumb).to.be.undefined;
+    // Article still links back to WebPage; Organization synthesized.
+    expect(graph.some((n) => n['@type'] === 'Organization')).to.be.true;
+    expect(graph.some((n) => n['@type'] === 'Article')).to.be.true;
+  });
+});
+
+// ---------------------------------------------------------------------------
+// End-to-end: merch-card-style Product transformation
+// ---------------------------------------------------------------------------
+describe('end-to-end: merch-card Product transformation', () => {
+  beforeEach(async () => {
+    resetManager();
+    setCanonical();
+    const html = await readFile({ path: './mocks/merch-card.html' });
+    const tpl = document.createElement('template');
+    tpl.innerHTML = html;
+    [...tpl.content.querySelectorAll('script[type="application/ld+json"]')].forEach((s) => {
+      document.head.appendChild(s);
+    });
+  });
+
+  it('converts Product → SoftwareApplication, hoists Offer, keeps Brand inline, canonicalizes seller', () => {
+    const manager = trackedManager();
+    manager.init();
+    const { '@graph': graph } = JSON.parse(
+      document.head.querySelector('script[data-milo-jsonld="graph"]').textContent,
+    );
+
+    expect(graph.some((n) => n['@type'] === 'Product')).to.be.false;
+
+    const sa = graph.find((n) => n['@type'] === 'SoftwareApplication');
+    expect(sa).to.exist;
+    expect(sa['@id']).to.equal(`${PAGE_URL}#softwareapplication`);
+    expect(sa.name).to.equal('Photoshop');
+    expect(sa.brand).to.deep.equal({ '@type': 'Brand', name: 'Adobe' });
+    expect(sa.image).to.have.length(2);
+    expect(sa.offers).to.deep.equal([{ '@id': `${PAGE_URL}#offer` }]);
+
+    const offer = graph.find((n) => n['@type'] === 'Offer');
+    expect(offer).to.exist;
+    expect(offer['@id']).to.equal(`${PAGE_URL}#offer`);
+    expect(offer.price).to.equal('662.9');
+    expect(offer.priceCurrency).to.equal('USD');
+    expect(offer.priceSpecification).to.exist;
+    // Seller alias #org canonicalized to #organization.
+    expect(offer.seller).to.deep.equal({ '@id': ORG_ID });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// SoftwareApplication subtype preservation (WebApplication, MobileApplication, VideoGame)
+// ---------------------------------------------------------------------------
+describe('SoftwareApplication subtype preservation', () => {
+  it('normalizeNode preserves WebApplication @type and assigns canonical SA @id', () => {
+    const node = normalizeNode({
+      '@type': 'WebApplication',
+      '@id': 'https://producer.example/some-id',
+      name: 'Compress PDF',
+      browserRequirements: 'Requires HTML5',
+    });
+    expect(node['@type']).to.equal('WebApplication');
+    expect(node['@id']).to.equal(`${PAGE_URL}#softwareapplication`);
+    expect(node.name).to.equal('Compress PDF');
+    expect(node.browserRequirements).to.equal('Requires HTML5');
+  });
+
+  it('normalizeNode preserves MobileApplication @type', () => {
+    const node = normalizeNode({ '@type': 'MobileApplication', name: 'Adobe Scan' });
+    expect(node['@type']).to.equal('MobileApplication');
+    expect(node['@id']).to.equal(`${PAGE_URL}#softwareapplication`);
+  });
+
+  it('mergeNodes promotes type to subtype when one input is plain SoftwareApplication', () => {
+    const sa = { '@type': 'SoftwareApplication', '@id': `${PAGE_URL}#softwareapplication`, name: 'Photoshop', aggregateRating: { ratingValue: '4.61' } };
+    const webapp = { '@type': 'WebApplication', '@id': `${PAGE_URL}#softwareapplication`, name: 'Compress PDF', browserRequirements: 'HTML5' };
+    // Even with bootDom (lower) for webapp and runtime (higher) for sa, subtype wins.
+    const merged = mergeNodes(sa, webapp, 'runtime', 'bootDom');
+    expect(merged['@type']).to.equal('WebApplication');
+    // Source priority still applies to scalars: runtime sa.name wins.
+    expect(merged.name).to.equal('Photoshop');
+    // Producer-only fields preserved on both sides.
+    expect(merged.browserRequirements).to.equal('HTML5');
+    expect(merged.aggregateRating).to.deep.equal({ ratingValue: '4.61' });
+  });
+
+  it('end-to-end: producer WebApplication + review-block Product merge into single WebApplication node', () => {
+    document.head.appendChild(makeScript({
+      '@type': 'WebApplication',
+      '@id': `${PAGE_URL}#webapplication`,
+      name: 'Compress PDF',
+      browserRequirements: 'HTML5',
+      applicationCategory: 'BusinessApplication',
+    }));
+    document.head.appendChild(makeScript({
+      '@type': 'Product',
+      name: 'Compress PDF',
+      aggregateRating: { '@type': 'AggregateRating', ratingValue: '4.61', ratingCount: '269519' },
+    }));
+    const manager = trackedManager();
+    manager.init();
+    const graph = JSON.parse(document.head.querySelector('script[data-milo-jsonld="graph"]').textContent)['@graph'];
+    // Exactly one node at #softwareapplication.
+    const apps = graph.filter((n) => n['@id'] === `${PAGE_URL}#softwareapplication`);
+    expect(apps).to.have.length(1);
+    const app = apps[0];
+    // Subtype preserved.
+    expect(app['@type']).to.equal('WebApplication');
+    // Producer-only fields preserved from both contributions.
+    expect(app.browserRequirements).to.equal('HTML5');
+    expect(app.applicationCategory).to.equal('BusinessApplication');
+    // AggregateRating hoisted to top-level node, referenced by @id.
+    expect(app.aggregateRating).to.deep.equal({ '@id': `${PAGE_URL}#aggregaterating` });
+    const rating = graph.find((n) => n['@type'] === 'AggregateRating');
+    expect(rating).to.exist;
+    expect(rating['@id']).to.equal(`${PAGE_URL}#aggregaterating`);
+    expect(rating.ratingValue).to.equal('4.61');
+    expect(rating.ratingCount).to.equal('269519');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// rewriteCrossPageRefs (policy C: cross-page WebPage references collapse to current canonical)
+// ---------------------------------------------------------------------------
+describe('rewriteCrossPageRefs', () => {
+  it('rewrites inline cross-page WebPage in isPartOf to canonical reference', () => {
+    const node = {
+      '@type': 'WebApplication',
+      isPartOf: {
+        '@type': 'WebPage',
+        '@id': 'https://www.adobe.com/acrobat/online.html#webpage',
+        name: 'Adobe Acrobat online tools',
+        url: 'https://www.adobe.com/acrobat/online.html',
+      },
+    };
+    rewriteCrossPageRefs(node);
+    expect(node.isPartOf).to.deep.equal({ '@id': `${PAGE_URL}#webpage` });
+  });
+
+  it('rewrites cross-page WebPage reference stub (no @type) to canonical', () => {
+    const node = {
+      '@type': 'Article',
+      isPartOf: { '@id': 'https://www.adobe.com/somewhere-else.html#webpage' },
+    };
+    rewriteCrossPageRefs(node);
+    expect(node.isPartOf).to.deep.equal({ '@id': `${PAGE_URL}#webpage` });
+  });
+
+  it('rewrites mainEntityOfPage the same way', () => {
+    const node = {
+      '@type': 'Article',
+      mainEntityOfPage: { '@type': 'WebPage', '@id': 'https://www.adobe.com/parent.html#webpage' },
+    };
+    rewriteCrossPageRefs(node);
+    expect(node.mainEntityOfPage).to.deep.equal({ '@id': `${PAGE_URL}#webpage` });
+  });
+
+  it('leaves non-WebPage isPartOf values alone', () => {
+    const node = {
+      '@type': 'Article',
+      isPartOf: { '@type': 'CreativeWorkSeries', '@id': 'https://example.com/series#1' },
+    };
+    rewriteCrossPageRefs(node);
+    expect(node.isPartOf).to.deep.equal({ '@type': 'CreativeWorkSeries', '@id': 'https://example.com/series#1' });
+  });
+
+  it('end-to-end: producer cross-page WebPage in isPartOf is rewritten in the managed graph', () => {
+    document.head.appendChild(makeScript({
+      '@type': 'WebApplication',
+      '@id': `${PAGE_URL}#webapplication`,
+      name: 'Compress PDF',
+      isPartOf: {
+        '@type': 'WebPage',
+        '@id': 'https://www.adobe.com/acrobat/online.html#webpage',
+        name: 'Adobe Acrobat online tools',
+        url: 'https://www.adobe.com/acrobat/online.html',
+      },
+    }));
+    const manager = trackedManager();
+    manager.init();
+    const graph = JSON.parse(document.head.querySelector('script[data-milo-jsonld="graph"]').textContent)['@graph'];
+    // Exactly one WebPage node — singleton enforced.
+    const webpages = graph.filter((n) => n['@type'] === 'WebPage');
+    expect(webpages).to.have.length(1);
+    expect(webpages[0]['@id']).to.equal(`${PAGE_URL}#webpage`);
+    // No phantom cross-page WebPage node leaked into the graph.
+    expect(graph.find((n) => n['@id'] === 'https://www.adobe.com/acrobat/online.html#webpage')).to.not.exist;
+    // The WebApplication's isPartOf points at the canonical current-page #webpage.
+    const app = graph.find((n) => n['@id'] === `${PAGE_URL}#softwareapplication`);
+    expect(app.isPartOf).to.deep.equal({ '@id': `${PAGE_URL}#webpage` });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// injectLinks: subtype-aware lookup for mainEntity and linksBack
+// ---------------------------------------------------------------------------
+describe('injectLinks subtype awareness', () => {
+  it('sets WebPage.mainEntity to a SoftwareApplication subtype (WebApplication) when no plain SA exists', () => {
+    document.head.appendChild(makeScript({
+      '@type': 'WebApplication',
+      '@id': `${PAGE_URL}#webapplication`,
+      name: 'Compress PDF',
+    }));
+    const manager = trackedManager();
+    manager.init();
+    const graph = JSON.parse(document.head.querySelector('script[data-milo-jsonld="graph"]').textContent)['@graph'];
+    const webpage = graph.find((n) => n['@type'] === 'WebPage');
+    expect(webpage.mainEntity).to.deep.equal({ '@id': `${PAGE_URL}#softwareapplication` });
+  });
+
+  it('auto-injects provider on a WebApplication via SoftwareApplication linksBack', () => {
+    document.head.appendChild(makeScript({
+      '@type': 'WebApplication',
+      '@id': `${PAGE_URL}#webapplication`,
+      name: 'Compress PDF',
+    }));
+    const manager = trackedManager();
+    manager.init();
+    const graph = JSON.parse(document.head.querySelector('script[data-milo-jsonld="graph"]').textContent)['@graph'];
+    const app = graph.find((n) => n['@id'] === `${PAGE_URL}#softwareapplication`);
+    expect(app['@type']).to.equal('WebApplication');
+    expect(app.provider).to.deep.equal({ '@id': ORG_ID });
+  });
+
+  it('sets WebPage.mainEntity to a NewsArticle node by @id when present', () => {
+    document.head.appendChild(makeScript({
+      '@type': 'NewsArticle',
+      '@id': `${PAGE_URL}#newsarticle`,
+      headline: 'Adobe announces…',
+    }));
+    const manager = trackedManager();
+    manager.init();
+    const graph = JSON.parse(document.head.querySelector('script[data-milo-jsonld="graph"]').textContent)['@graph'];
+    const webpage = graph.find((n) => n['@type'] === 'WebPage');
+    expect(webpage.mainEntity).to.deep.equal({ '@id': `${PAGE_URL}#newsarticle` });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// AggregateRating extraction (singleton, hoisted from inline values)
+// ---------------------------------------------------------------------------
+describe('AggregateRating singleton', () => {
+  it('extractInlineEntities hoists inline AggregateRating to top-level and references it by @id', () => {
+    const node = {
+      '@type': 'SoftwareApplication',
+      '@id': `${PAGE_URL}#softwareapplication`,
+      aggregateRating: { '@type': 'AggregateRating', ratingValue: '4.5', ratingCount: '100' },
+    };
+    const extracted = extractInlineEntities(node);
+    expect(extracted).to.have.length(1);
+    expect(extracted[0]['@type']).to.equal('AggregateRating');
+    expect(extracted[0]['@id']).to.equal(`${PAGE_URL}#aggregaterating`);
+    expect(extracted[0].ratingValue).to.equal('4.5');
+    expect(node.aggregateRating).to.deep.equal({ '@id': `${PAGE_URL}#aggregaterating` });
+  });
+
+  it('end-to-end: two producers contributing aggregateRating merge into one canonical node', () => {
+    // Enqueue first as bootDom (team hardcode), second as runtime (review block).
+    const bootScript = makeScript({
+      '@type': 'WebApplication',
+      '@id': `${PAGE_URL}#webapplication`,
+      name: 'Compress PDF',
+      aggregateRating: { '@type': 'AggregateRating', ratingValue: '4.6', ratingCount: '279157' },
+    });
+    const runtimeScript = makeScript({
+      '@type': 'Product',
+      name: 'Compress PDF',
+      aggregateRating: { '@type': 'AggregateRating', ratingValue: '4.61', ratingCount: '269519' },
+    });
+    document.head.appendChild(bootScript);
+    document.head.appendChild(runtimeScript);
+    const manager = trackedManager();
+    manager.enqueue(bootScript, 'bootDom');
+    manager.enqueue(runtimeScript, 'runtime');
+    manager.rebuild();
+
+    const graph = JSON.parse(document.head.querySelector('script[data-milo-jsonld="graph"]').textContent)['@graph'];
+    const ratings = graph.filter((n) => n['@type'] === 'AggregateRating');
+    expect(ratings).to.have.length(1);
+    const rating = ratings[0];
+    expect(rating['@id']).to.equal(`${PAGE_URL}#aggregaterating`);
+    // Runtime wins over bootDom on scalar conflicts (source-priority).
+    expect(rating.ratingValue).to.equal('4.61');
+    expect(rating.ratingCount).to.equal('269519');
+    // The SA reference points at the canonical aggregateRating @id.
+    const app = graph.find((n) => n['@id'] === `${PAGE_URL}#softwareapplication`);
+    expect(app.aggregateRating).to.deep.equal({ '@id': `${PAGE_URL}#aggregaterating` });
+  });
+});
diff --git a/test/features/jsonld-graph-manager/mocks/boot-vs-mutation.html b/test/features/jsonld-graph-manager/mocks/boot-vs-mutation.html
new file mode 100644
index 00000000000..0018684ebb8
--- /dev/null
+++ b/test/features/jsonld-graph-manager/mocks/boot-vs-mutation.html
@@ -0,0 +1,8 @@
+<!-- Script present at boot time -->
+<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "Article",
+  "headline": "Boot Article"
+}
+</script>
diff --git a/test/features/jsonld-graph-manager/mocks/editorial.html b/test/features/jsonld-graph-manager/mocks/editorial.html
new file mode 100644
index 00000000000..443f8591d75
--- /dev/null
+++ b/test/features/jsonld-graph-manager/mocks/editorial.html
@@ -0,0 +1,25 @@
+<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "Organization",
+  "name": "Adobe",
+  "url": "https://www.adobe.com/"
+}
+</script>
+<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "Article",
+  "headline": "How to Remove Objects",
+  "description": "Step-by-step guide."
+}
+</script>
+<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "BreadcrumbList",
+  "itemListElement": [
+    { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://www.adobe.com/" }
+  ]
+}
+</script>
diff --git a/test/features/jsonld-graph-manager/mocks/merch-card.html b/test/features/jsonld-graph-manager/mocks/merch-card.html
new file mode 100644
index 00000000000..3f9a59757e5
--- /dev/null
+++ b/test/features/jsonld-graph-manager/mocks/merch-card.html
@@ -0,0 +1,40 @@
+<!-- Merch-card-style Product producer payload (per json-ld.md Appendix A.3). -->
+<!-- The graph manager must transform this into a SoftwareApplication, hoist the Offer, -->
+<!-- keep the anonymous Brand inline, and canonicalize the seller alias #org → #organization. -->
+<script type="application/ld+json">
+{
+  "@context": "https://schema.org/",
+  "@type": "Product",
+  "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#product",
+  "name": "Photoshop",
+  "brand": {
+    "@type": "Brand",
+    "name": "Adobe"
+  },
+  "offers": [
+    {
+      "@type": "Offer",
+      "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#offer",
+      "url": "https://main--cc--adobecom.aem.page/drafts/axel/document5",
+      "priceCurrency": "USD",
+      "price": "662.9",
+      "availability": "https://schema.org/InStock",
+      "category": "Subscription",
+      "seller": { "@id": "https://www.adobe.com/#org" },
+      "itemOffered": { "@id": "https://main--cc--adobecom.aem.page/drafts/axel/document5#product" },
+      "priceSpecification": {
+        "@type": "UnitPriceSpecification",
+        "price": "662.9",
+        "priceCurrency": "USD",
+        "billingDuration": "P1Y",
+        "billingIncrement": 1,
+        "priceWithoutDiscount": "779.88"
+      }
+    }
+  ],
+  "image": [
+    "https://www.adobe.com/cc-shared/assets/img/product-icons/svg/creative-cloud.svg?format=png&width=800&height=800",
+    "https://www.adobe.com/cc-shared/assets/img/product-icons/svg/photoshop.svg?format=png&width=800&height=800"
+  ]
+}
+</script>
diff --git a/test/features/jsonld-graph-manager/mocks/multi-producer.html b/test/features/jsonld-graph-manager/mocks/multi-producer.html
new file mode 100644
index 00000000000..53c53c8e619
--- /dev/null
+++ b/test/features/jsonld-graph-manager/mocks/multi-producer.html
@@ -0,0 +1,26 @@
+<!-- Producer A (boot DOM): Organization with producer-only sameAs -->
+<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "Organization",
+  "name": "Adobe",
+  "url": "https://www.adobe.com/",
+  "sameAs": "https://en.wikipedia.org/wiki/Adobe_Inc."
+}
+</script>
+<!-- Producer B (runtime): Organization with conflicting name -->
+<script type="application/ld+json" data-producer="runtime">
+{
+  "@context": "https://schema.org",
+  "@type": "Organization",
+  "name": "Adobe Inc.",
+  "url": "https://www.adobe.com/"
+}
+</script>
+<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "Article",
+  "headline": "Test Article"
+}
+</script>
diff --git a/test/features/jsonld-graph-manager/mocks/product.html b/test/features/jsonld-graph-manager/mocks/product.html
new file mode 100644
index 00000000000..238c5852115
--- /dev/null
+++ b/test/features/jsonld-graph-manager/mocks/product.html
@@ -0,0 +1,25 @@
+<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "Organization",
+  "name": "Adobe",
+  "url": "https://www.adobe.com/"
+}
+</script>
+<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "SoftwareApplication",
+  "name": "Adobe Photoshop",
+  "applicationCategory": "DesignApplication"
+}
+</script>
+<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "BreadcrumbList",
+  "itemListElement": [
+    { "@type": "ListItem", "position": 1, "name": "Products", "item": "https://www.adobe.com/products/" }
+  ]
+}
+</script>