@contentful/experiences-sdk-core 0.13.0 → 0.13.1

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.13.1 (2026-10-22)
+
+### 🚀 Features
+
+- ⚠️  **web:** add interceptors and diagnostic streams [NT-4155] ([#251](https://github.com/contentful/experiences/pull/251))
+
+### ⚠️  Breaking Changes
+
+- **web:** add interceptors and diagnostic streams [NT-4155]  ([#251](https://github.com/contentful/experiences/pull/251))
+
 ## 0.13.0 (2026-10-22)
 
 ### 🚀 Features

package/dist/index.cjs

@@ -0,0 +1,542 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/attribution.ts
+var SUPPORTED_VERSION = 1;
+var DEFINING_LAYER_KIND = {
+  Experience: "ExperienceTemplate",
+  ExperienceFragment: "Component"
+};
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function asIndex(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function rowAt(rows, ref) {
+  const index = asIndex(ref);
+  return index === void 0 ? void 0 : asRecord(rows[index]);
+}
+function isPath(value) {
+  return Array.isArray(value) && value.every((s) => typeof s === "string" || Number.isInteger(s));
+}
+function parseLayer(value) {
+  const record = asRecord(value);
+  if (record === void 0) return void 0;
+  return { record, kind: asString(record.kind), id: asString(record.id) };
+}
+function scopeKind(layer) {
+  if (layer.kind === "Experience") return "Experience";
+  if (layer.kind === "ExperienceFragment") return "ExperienceFragment";
+  return void 0;
+}
+function createContext(sourceMap, log) {
+  const map = asRecord(sourceMap);
+  if (_optionalChain([map, 'optionalAccess', _ => _.version]) !== SUPPORTED_VERSION) {
+    log.log(`ignoring source map: unsupported version ${String(_optionalChain([map, 'optionalAccess', _2 => _2.version]))}`);
+    return void 0;
+  }
+  const nodes = asRecord(map.nodes);
+  if (!Array.isArray(map.layers) || !Array.isArray(map.variants) || nodes === void 0) {
+    log.log("ignoring source map: missing layers, variants or nodes");
+    return void 0;
+  }
+  return {
+    nodes,
+    layers: map.layers.map(parseLayer),
+    variants: map.variants,
+    entries: Array.isArray(map.entries) ? map.entries : [],
+    dataAssemblies: Array.isArray(map.dataAssemblies) ? map.dataAssemblies : [],
+    log,
+    scopes: {},
+    scopeEntries: /* @__PURE__ */ new Map(),
+    bindingEntries: /* @__PURE__ */ new Map()
+  };
+}
+function reportableScopes(ctx, chain) {
+  const outerFirst = [...chain].reverse();
+  const scopes = [];
+  for (const [position, row] of outerFirst.entries()) {
+    const layer = ctx.layers[row];
+    const kind = layer === void 0 ? void 0 : scopeKind(layer);
+    if (_optionalChain([layer, 'optionalAccess', _3 => _3.id]) === void 0 || kind === void 0) continue;
+    if (scopes.some((scope) => scope.row === row)) continue;
+    const innerRow = outerFirst[position + 1];
+    const innerLayer = innerRow === void 0 ? void 0 : ctx.layers[innerRow];
+    const definesThisScope = _optionalChain([innerLayer, 'optionalAccess', _4 => _4.kind]) === DEFINING_LAYER_KIND[kind];
+    scopes.push({
+      row,
+      layer,
+      entityId: layer.id,
+      kind,
+      entityKindId: definesThisScope ? _optionalChain([innerLayer, 'optionalAccess', _5 => _5.id]) : void 0
+    });
+  }
+  return scopes;
+}
+function occurrenceKey(row, listPath, runStart) {
+  return `s${row}@${listPath}#${runStart}`;
+}
+function readVariant(ctx, scope) {
+  const refs = scope.layer.record.variants;
+  if (!Array.isArray(refs) || refs.length === 0) return { variantId: "default" };
+  if (refs.length > 1) {
+    ctx.log.log(`layer "${scope.entityId}" lists ${refs.length} variants; using the first`);
+  }
+  const variant = rowAt(ctx.variants, refs[0]);
+  const optimizationId = asString(_optionalChain([variant, 'optionalAccess', _6 => _6.optimizationId]));
+  const variantId = _nullishCoalesce(asString(_optionalChain([variant, 'optionalAccess', _7 => _7.variantId])), () => ( "default"));
+  const variantIndex = _optionalChain([variant, 'optionalAccess', _8 => _8.variantIndex]);
+  const fields = { variantId };
+  if (optimizationId !== void 0) fields.optimizationId = optimizationId;
+  if (typeof variantIndex === "number") fields.variantIndex = variantIndex;
+  return fields;
+}
+function buildScope(ctx, scope, key, parentExperience) {
+  const attribution = {
+    key,
+    entityId: scope.entityId,
+    entityKind: scope.kind,
+    ...readVariant(ctx, scope)
+  };
+  if (scope.entityKindId !== void 0) {
+    attribution.entityKindId = scope.entityKindId;
+  }
+  if (scope.kind === "ExperienceFragment" && parentExperience !== void 0) {
+    attribution.parentExperienceId = parentExperience.entityId;
+    if (parentExperience.variantId !== void 0) {
+      attribution.parentVariantId = parentExperience.variantId;
+    }
+  }
+  return attribution;
+}
+function entriesBoundAt(ctx, assemblyRow, path) {
+  const cacheKey = `${assemblyRow}|${JSON.stringify(path)}`;
+  const cached = ctx.bindingEntries.get(cacheKey);
+  if (cached !== void 0) return cached;
+  const found = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const followAssembly = (row, path2) => {
+    const visitKey = `${row}|${JSON.stringify(path2)}`;
+    const assembly = asRecord(ctx.dataAssemblies[row]);
+    if (assembly === void 0 || visited.has(visitKey)) return;
+    visited.add(visitKey);
+    walk(assembly.return, path2);
+  };
+  const walkLeaf = (leaf, path2) => {
+    if (leaf.type === "entry") {
+      const entryId = asString(_optionalChain([rowAt, 'call', _9 => _9(ctx.entries, leaf.entry), 'optionalAccess', _10 => _10.id]));
+      if (entryId !== void 0) found.add(entryId);
+    } else if (leaf.type === "dataAssembly") {
+      const row = asIndex(leaf.dataAssembly);
+      const leafPath = isPath(leaf.path) ? leaf.path : [];
+      if (row !== void 0) followAssembly(row, [...leafPath, ...path2]);
+    }
+  };
+  const walk = (value, path2) => {
+    const [head, ...rest] = path2;
+    if (Array.isArray(value)) {
+      if (head === void 0) value.forEach((child) => walk(child, []));
+      else if (typeof head === "number") walk(value[head], rest);
+      return;
+    }
+    const record = asRecord(value);
+    if (record === void 0) return;
+    if (typeof record.type === "string") walkLeaf(record, path2);
+    else if (head === void 0) Object.values(record).forEach((child) => walk(child, []));
+    else walk(record[String(head)], rest);
+  };
+  followAssembly(assemblyRow, path);
+  const ids = [...found];
+  ctx.bindingEntries.set(cacheKey, ids);
+  return ids;
+}
+function readNodeEntries(ctx, entry) {
+  const properties = Array.isArray(entry.contentProperties) ? entry.contentProperties : [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const property of properties) {
+    const item = asRecord(property);
+    const assemblyRow = asIndex(_optionalChain([item, 'optionalAccess', _11 => _11.dataAssembly]));
+    const bindings = asRecord(_optionalChain([item, 'optionalAccess', _12 => _12.bindings]));
+    if (_optionalChain([item, 'optionalAccess', _13 => _13.type]) !== "dataAssembly" || assemblyRow === void 0 || bindings === void 0) {
+      continue;
+    }
+    for (const path of Object.values(bindings).filter(isPath)) {
+      for (const id of entriesBoundAt(ctx, assemblyRow, path)) ids.add(id);
+    }
+  }
+  return [...ids];
+}
+function addScopeEntries(ctx, scope, entryIds) {
+  const owned = _nullishCoalesce(ctx.scopeEntries.get(scope), () => ( /* @__PURE__ */ new Set()));
+  for (const id of entryIds) owned.add(id);
+  ctx.scopeEntries.set(scope, owned);
+}
+function readChain(entry) {
+  const { layers } = entry;
+  return Array.isArray(layers) && layers.every(Number.isInteger) ? layers : [];
+}
+function attributeNode(ctx, node, parentKeys, previousKeys, listPath, index) {
+  const entry = node.nodeId === void 0 ? void 0 : asRecord(ctx.nodes[node.nodeId]);
+  if (entry === void 0) return void 0;
+  const scopes = reportableScopes(ctx, readChain(entry));
+  if (scopes.length === 0) return void 0;
+  const keys = /* @__PURE__ */ new Map();
+  const attribution = { scopes: [], roots: [] };
+  let parentExperience;
+  let nearest;
+  const previousScopes = previousKeys.entries();
+  let sameOccurrencePrefix = true;
+  for (const scope of scopes) {
+    const previous = previousScopes.next().value;
+    sameOccurrencePrefix &&= _optionalChain([previous, 'optionalAccess', _14 => _14[0]]) === scope.row;
+    const isRoot = !parentKeys.has(scope.row);
+    const key = _nullishCoalesce(_nullishCoalesce(parentKeys.get(scope.row), () => ( (sameOccurrencePrefix ? _optionalChain([previous, 'optionalAccess', _15 => _15[1]]) : void 0))), () => ( occurrenceKey(scope.row, listPath, index)));
+    sameOccurrencePrefix &&= _optionalChain([previous, 'optionalAccess', _16 => _16[1]]) === key;
+    keys.set(scope.row, key);
+    nearest = ctx.scopes[key] ??= buildScope(ctx, scope, key, parentExperience);
+    attribution.scopes.push(nearest);
+    if (isRoot) attribution.roots.push(nearest);
+    if (scope.kind === "Experience" && parentExperience === void 0) parentExperience = nearest;
+  }
+  const entryIds = readNodeEntries(ctx, entry);
+  if (entryIds.length > 0 && nearest !== void 0) {
+    attribution.entryIds = entryIds;
+    addScopeEntries(ctx, nearest, entryIds);
+  }
+  node.attribution = attribution;
+  return keys;
+}
+function assignSiblings(ctx, siblings, parentKeys, listPath = "") {
+  let previousKeys = /* @__PURE__ */ new Map();
+  for (const [index, node] of siblings.entries()) {
+    const ownKeys = attributeNode(ctx, node, parentKeys, previousKeys, listPath, index);
+    previousKeys = _nullishCoalesce(ownKeys, () => ( /* @__PURE__ */ new Map()));
+    for (const [slotName, children] of Object.entries(node.slots)) {
+      assignSiblings(ctx, children, _nullishCoalesce(ownKeys, () => ( parentKeys)), `${listPath}/${index}.${slotName}`);
+    }
+  }
+}
+function resolveAttribution(sourceMap, nodes, log) {
+  if (sourceMap === void 0) return void 0;
+  const ctx = createContext(sourceMap, log);
+  if (ctx === void 0) return void 0;
+  assignSiblings(ctx, nodes, /* @__PURE__ */ new Map());
+  for (const [scope, ids] of ctx.scopeEntries) scope.entryIds = [...ids];
+  const scopes = Object.values(ctx.scopes);
+  for (const scope of scopes) Object.freeze(scope);
+  return scopes.length > 0 ? { scopes: ctx.scopes } : void 0;
+}
+
+// src/debug-logger.ts
+var PREFIX = "[experiences:debug]";
+function now() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  if (typeof Date !== "undefined" && typeof Date.now === "function") return Date.now();
+  return 0;
+}
+var NOOP_LOGGER = {
+  log() {
+  },
+  lazy() {
+  },
+  time: (_label, fn) => fn(),
+  enabled: false
+};
+function createDebugLogger(debug, scope) {
+  if (!debug || typeof console === "undefined") return NOOP_LOGGER;
+  const tag = `${PREFIX}[${scope}]`;
+  return {
+    enabled: true,
+    log(message, data) {
+      if (data === void 0) console.log(`${tag} ${message}`);
+      else console.log(`${tag} ${message}`, data);
+    },
+    lazy(message, getData) {
+      console.log(`${tag} ${message}`, getData());
+    },
+    async time(label, fn) {
+      const start = now();
+      try {
+        const result = await fn();
+        console.log(`${tag} \u23F1 ${label} \u2014 ${(now() - start).toFixed(1)}ms`);
+        return result;
+      } catch (err) {
+        console.log(`${tag} \u23F1 ${label} \u2014 failed after ${(now() - start).toFixed(1)}ms`, err);
+        throw err;
+      }
+    }
+  };
+}
+
+// src/design-properties.ts
+function resolveDesignProperties(designProperties) {
+  const out = {};
+  if (!designProperties) return out;
+  for (const [key, prop] of Object.entries(designProperties)) {
+    out[key] = prop.type === "ManualDesignValue" ? prop.value : prop;
+  }
+  return out;
+}
+function applyTokenResolver(props, resolveToken) {
+  const out = {};
+  const unresolved = [];
+  for (const [key, value] of Object.entries(props)) {
+    if (typeof value === "object" && value !== null && value.type === "DesignToken") {
+      const resolved = _optionalChain([resolveToken, 'optionalCall', _17 => _17(value)]);
+      if (resolved === void 0) {
+        out[key] = value;
+        unresolved.push(value.value);
+        continue;
+      }
+      out[key] = resolved;
+      continue;
+    }
+    out[key] = value;
+  }
+  return { props: out, unresolved };
+}
+
+// src/resolve-experience.ts
+function getResolver(entry) {
+  if (typeof entry !== "object" || entry === null) return void 0;
+  const candidate = entry.resolveData;
+  return typeof candidate === "function" ? candidate : void 0;
+}
+var DEFAULT_EXPERIENCE = {
+  debug: false,
+  metadata: {}
+};
+function lookupEntry(config, registration) {
+  return registration.kind === "experienceTemplate" ? _optionalChain([config, 'access', _18 => _18.experienceTemplates, 'optionalAccess', _19 => _19[registration.id]]) : config.components[registration.id];
+}
+function extractIdFromUrn(urn) {
+  const segments = urn.split("/").filter((s) => s.length > 0);
+  return _nullishCoalesce(segments[segments.length - 1], () => ( urn));
+}
+function readNodeRef(node) {
+  const isExperienceTemplate = "experienceTemplate" in node;
+  const ref = isExperienceTemplate ? node.experienceTemplate : "component" in node ? node.component : void 0;
+  const urn = _optionalChain([ref, 'optionalAccess', _20 => _20.sys, 'optionalAccess', _21 => _21.urn]);
+  if (typeof urn !== "string" || urn.length === 0) return null;
+  return { kind: isExperienceTemplate ? "experienceTemplate" : "component", urn };
+}
+function ensureArray(value, field, log, diagnostics) {
+  if (Array.isArray(value)) return value;
+  const message = `Experience payload's "${field}" is not an array (got ${value === null ? "null" : typeof value}); treating it as empty instead of throwing. This usually means a malformed or partial payload \u2014 check what produced it.`;
+  if (typeof console !== "undefined") {
+    console.warn(`[@contentful/experiences] ${message}`);
+  }
+  log.log(message);
+  diagnostics.push(new Error(message));
+  return [];
+}
+function countPayloadNodes(node) {
+  const slots = node.slots;
+  let total = 1;
+  if (slots && typeof slots === "object") {
+    for (const children of Object.values(slots)) {
+      if (!Array.isArray(children)) continue;
+      for (const child of children) total += countPayloadNodes(child);
+    }
+  }
+  return total;
+}
+function warnUnrenderableNode(node, log, diagnostics) {
+  const id = node.id;
+  const label = typeof id === "string" ? ` "${id}"` : "";
+  const keys = Object.keys(node);
+  const descendants = countPayloadNodes(node) - 1;
+  const message = `Skipping unidentifiable node${label}: expected a \`component\` or \`experienceTemplate\` ResourceLink carrying a urn, got keys [${keys.join(", ")}]. Dropping it and ${descendants} descendant node(s). A payload node kind this SDK does not know is usually a version skew \u2014 upgrading @contentful/experiences-sdk-core may be all that is needed.`;
+  if (typeof console !== "undefined") {
+    console.warn(`[@contentful/experiences] ${message}`);
+  }
+  log.log(message);
+  diagnostics.push(new Error(message));
+}
+function buildNodes(nodes, config, nodeRefs, log, diagnostics) {
+  const built = [];
+  for (const node of nodes) {
+    const one = buildNode(node, config, nodeRefs, log, diagnostics);
+    if (one !== null) built.push(one);
+  }
+  return built;
+}
+function buildNode(node, config, nodeRefs, log, diagnostics) {
+  const ref = readNodeRef(node);
+  if (ref === null) {
+    warnUnrenderableNode(node, log, diagnostics);
+    return null;
+  }
+  const registration = {
+    kind: ref.kind,
+    id: extractIdFromUrn(ref.urn)
+  };
+  const nodeId = typeof node.id === "string" ? node.id : void 0;
+  const slots = {};
+  if (node.slots) {
+    for (const [slotName, children] of Object.entries(node.slots)) {
+      if (!Array.isArray(children)) {
+        const message = `Slot "${slotName}" on ${registration.kind} "${registration.id}"${nodeId ? ` (node "${nodeId}")` : ""} is not an array of nodes (got ${children === null ? "null" : typeof children}); treating it as empty instead of failing the whole experience. A hand-built payload with the wrong slot shape is the usual cause.`;
+        if (typeof console !== "undefined") {
+          console.warn(`[@contentful/experiences] ${message}`);
+        }
+        log.log(message);
+        diagnostics.push(new Error(message));
+        slots[slotName] = [];
+        continue;
+      }
+      slots[slotName] = buildNodes(children, config, nodeRefs, log, diagnostics);
+    }
+  }
+  const built = {
+    registration,
+    props: {
+      content: { ..._nullishCoalesce(node.contentProperties, () => ( {})) },
+      // Resolved design values are written by the pre-resolution pass below.
+      design: {},
+      designRaw: { ..._nullishCoalesce(node.designProperties, () => ( {})) }
+    },
+    slots
+  };
+  if (node.id) built.nodeId = node.id;
+  if (getResolver(lookupEntry(config, registration))) {
+    nodeRefs.push(built);
+  }
+  return built;
+}
+function preResolveDesignProperties(design, resolveToken) {
+  return applyTokenResolver(resolveDesignProperties(design), resolveToken);
+}
+function warnUnresolvedTokens(label, unresolved, log, diagnostics) {
+  if (!unresolved.length) return;
+  const message = `resolveToken returned undefined for token id(s) on "${label}": ${unresolved.join(", ")}. Resolved design (getDesignValues()) will carry the raw, unresolved DesignToken for those keys.`;
+  if (typeof console !== "undefined") {
+    console.warn(`[@contentful/experiences] ${message}`);
+  }
+  log.log(`unresolved token id(s) on "${label}": ${unresolved.join(", ")}`);
+  for (const tokenId of unresolved) {
+    diagnostics.push(
+      new Error(
+        `Design token "${tokenId}" on ${label} has no \`resolveToken\` mapping; the raw token reaches the component unresolved.`
+      )
+    );
+  }
+}
+function preResolveNodeTree(node, resolveToken, log, diagnostics) {
+  const { props, unresolved } = preResolveDesignProperties(node.props.designRaw, resolveToken);
+  node.props.design = props;
+  warnUnresolvedTokens(
+    `${node.registration.kind}:${node.registration.id}`,
+    unresolved,
+    log,
+    diagnostics
+  );
+  for (const children of Object.values(node.slots)) {
+    for (const child of children) {
+      preResolveNodeTree(child, resolveToken, log, diagnostics);
+    }
+  }
+}
+async function resolveExperience(payload, config, options = {}) {
+  const log = createDebugLogger(options.debug, "core");
+  log.lazy("resolveExperience called with payload", () => payload);
+  const diagnostics = [];
+  const isPlainPayload = payload !== null && typeof payload === "object";
+  if (!isPlainPayload) {
+    const message = `Experience payload is ${payload === null ? "null" : typeof payload}, not an object; treating it as an empty experience (no nodes) instead of throwing. This usually means the fetch or transform pipeline handed resolveExperience a missing or malformed payload \u2014 check what produced it.`;
+    if (typeof console !== "undefined") {
+      console.warn(`[@contentful/experiences] ${message}`);
+    }
+    log.log(message);
+    diagnostics.push(new Error(message));
+  }
+  const payloadNodes = isPlainPayload ? ensureArray(payload.nodes, "nodes", log, diagnostics) : [];
+  const nodeRefs = [];
+  const nodes = buildNodes(payloadNodes, config, nodeRefs, log, diagnostics);
+  log.log(`built ${nodes.length} top-level node(s); ${nodeRefs.length} declare resolveData`);
+  const experience = {
+    debug: _nullishCoalesce(options.debug, () => ( DEFAULT_EXPERIENCE.debug)),
+    metadata: {
+      ...DEFAULT_EXPERIENCE.metadata,
+      ..._nullishCoalesce(options.metadata, () => ( {}))
+    }
+  };
+  const tasks = [];
+  for (const node of nodeRefs) {
+    const resolver = getResolver(lookupEntry(config, node.registration));
+    if (!resolver) continue;
+    const ctx = {
+      content: node.props.content,
+      design: node.props.designRaw,
+      experience
+    };
+    tasks.push(
+      // Deferred via `.then(() => resolver(ctx))` rather than
+      // `Promise.resolve(resolver(ctx))`: the latter calls `resolver(ctx)`
+      // eagerly as an argument, so a resolver that throws *synchronously*
+      // escapes immediately instead of becoming a rejection. The `onFailure`
+      // handler below never rethrows, so one broken resolver can't fail the
+      // `Promise.all` for every other node.
+      Promise.resolve().then(() => resolver(ctx)).then(
+        (resolved) => {
+          node.props.resolved = resolved;
+        },
+        (err) => {
+          const label = `${node.registration.kind}:${node.registration.id}`;
+          const reason = err instanceof Error ? err.message : String(err);
+          const message = `resolveData for ${label}${node.nodeId ? ` (node "${node.nodeId}")` : ""} threw or rejected: ${reason}. Rendering the node without resolved data instead of failing the whole experience.`;
+          if (typeof console !== "undefined") {
+            console.warn(`[@contentful/experiences] ${message}`);
+          }
+          log.log(message);
+          diagnostics.push(new Error(message, { cause: err instanceof Error ? err : void 0 }));
+        }
+      )
+    );
+  }
+  if (tasks.length > 0) {
+    await log.time(`${tasks.length} resolveData hook(s)`, () => Promise.all(tasks));
+  }
+  for (const node of nodes) {
+    preResolveNodeTree(node, config.resolveToken, log, diagnostics);
+  }
+  log.log("resolved design properties");
+  const plan = {
+    nodes,
+    diagnostics,
+    metadata: experience.metadata,
+    debug: experience.debug
+  };
+  const sourceMap = _nullishCoalesce(options.sourceMap, () => ( (isPlainPayload ? _optionalChain([payload, 'access', _22 => _22.extensions, 'optionalAccess', _23 => _23.sourceMap]) : void 0)));
+  if (sourceMap) {
+    plan.sourceMap = sourceMap;
+    const attribution = resolveAttribution(sourceMap, nodes, log);
+    if (attribution) plan.attribution = attribution;
+  }
+  const profileId = isPlainPayload && _optionalChain([payload, 'access', _24 => _24.extensions, 'optionalAccess', _25 => _25.personalization, 'optionalAccess', _26 => _26.profile, 'optionalAccess', _27 => _27.id]);
+  if (profileId) {
+    plan.personalization = { profileId };
+  }
+  return plan;
+}
+
+// src/tracking-attributes.ts
+var TRACKING_SCOPES_ATTRIBUTE = "data-ctfl-scopes";
+var TRACKING_CLICKABLE_ATTRIBUTE = "data-ctfl-clickable";
+function getTrackingAttributes(attribution) {
+  const keys = _nullishCoalesce(_optionalChain([attribution, 'optionalAccess', _28 => _28.roots, 'access', _29 => _29.map, 'call', _30 => _30((scope) => scope.key)]), () => ( []));
+  return keys.length > 0 ? { [TRACKING_SCOPES_ATTRIBUTE]: keys.join(" ") } : {};
+}
+
+
+
+
+
+
+
+
+exports.TRACKING_CLICKABLE_ATTRIBUTE = TRACKING_CLICKABLE_ATTRIBUTE; exports.TRACKING_SCOPES_ATTRIBUTE = TRACKING_SCOPES_ATTRIBUTE; exports.applyTokenResolver = applyTokenResolver; exports.createDebugLogger = createDebugLogger; exports.getTrackingAttributes = getTrackingAttributes; exports.resolveDesignProperties = resolveDesignProperties; exports.resolveExperience = resolveExperience;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/experiences/experiences/packages/core/dist/index.cjs","../src/attribution.ts","../src/debug-logger.ts","../src/design-properties.ts","../src/resolve-experience.ts","../src/tracking-attributes.ts"],"names":["path"],"mappings":"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","file":"/home/runner/work/experiences/experiences/packages/core/dist/index.cjs","sourcesContent":[null,"import type { DebugLogger } from './debug-logger.js';\nimport type {\n  ExperienceSourceMap,\n  NodeAttribution,\n  PlanAttribution,\n  PortableRenderNode,\n  ScopeAttribution,\n} from './types.js';\n\nconst SUPPORTED_VERSION = 1;\n\ntype EntityKind = ScopeAttribution['entityKind'];\ntype VariantFields = Pick<ScopeAttribution, 'optimizationId' | 'variantId' | 'variantIndex'>;\ntype Rec = Record<string, unknown>;\ntype PathSegment = string | number;\n\nconst DEFINING_LAYER_KIND: Record<EntityKind, string> = {\n  Experience: 'ExperienceTemplate',\n  ExperienceFragment: 'Component',\n};\n\nfunction asRecord(value: unknown): Rec | undefined {\n  return typeof value === 'object' && value !== null ? (value as Rec) : undefined;\n}\n\nfunction asIndex(value: unknown): number | undefined {\n  return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;\n}\n\nfunction asString(value: unknown): string | undefined {\n  return typeof value === 'string' && value.length > 0 ? value : undefined;\n}\n\nfunction rowAt(rows: unknown[], ref: unknown): Rec | undefined {\n  const index = asIndex(ref);\n  return index === undefined ? undefined : asRecord(rows[index]);\n}\n\nfunction isPath(value: unknown): value is PathSegment[] {\n  return Array.isArray(value) && value.every((s) => typeof s === 'string' || Number.isInteger(s));\n}\n\ninterface Layer {\n  record: Rec;\n  kind: string | undefined;\n  id: string | undefined;\n}\n\nfunction parseLayer(value: unknown): Layer | undefined {\n  const record = asRecord(value);\n  if (record === undefined) return undefined;\n  return { record, kind: asString(record.kind), id: asString(record.id) };\n}\n\nfunction scopeKind(layer: Layer): EntityKind | undefined {\n  if (layer.kind === 'Experience') return 'Experience';\n  if (layer.kind === 'ExperienceFragment') return 'ExperienceFragment';\n  return undefined;\n}\n\ninterface Context {\n  nodes: Rec;\n  layers: (Layer | undefined)[];\n  variants: unknown[];\n  entries: unknown[];\n  dataAssemblies: unknown[];\n  log: DebugLogger;\n  scopes: Record<string, ScopeAttribution>;\n  scopeEntries: Map<ScopeAttribution, Set<string>>;\n  bindingEntries: Map<string, readonly string[]>;\n}\n\nfunction createContext(sourceMap: ExperienceSourceMap, log: DebugLogger): Context | undefined {\n  const map = asRecord(sourceMap);\n  if (map?.version !== SUPPORTED_VERSION) {\n    log.log(`ignoring source map: unsupported version ${String(map?.version)}`);\n    return undefined;\n  }\n  const nodes = asRecord(map.nodes);\n  if (!Array.isArray(map.layers) || !Array.isArray(map.variants) || nodes === undefined) {\n    log.log('ignoring source map: missing layers, variants or nodes');\n    return undefined;\n  }\n  return {\n    nodes,\n    layers: map.layers.map(parseLayer),\n    variants: map.variants,\n    entries: Array.isArray(map.entries) ? map.entries : [],\n    dataAssemblies: Array.isArray(map.dataAssemblies) ? map.dataAssemblies : [],\n    log,\n    scopes: {},\n    scopeEntries: new Map(),\n    bindingEntries: new Map(),\n  };\n}\n\ninterface ChainScope {\n  row: number;\n  layer: Layer;\n  entityId: string;\n  kind: EntityKind;\n  entityKindId: string | undefined;\n}\n\nfunction reportableScopes(ctx: Context, chain: number[]): ChainScope[] {\n  const outerFirst = [...chain].reverse();\n  const scopes: ChainScope[] = [];\n\n  for (const [position, row] of outerFirst.entries()) {\n    const layer = ctx.layers[row];\n    const kind = layer === undefined ? undefined : scopeKind(layer);\n    if (layer?.id === undefined || kind === undefined) continue;\n    if (scopes.some((scope) => scope.row === row)) continue;\n\n    const innerRow = outerFirst[position + 1];\n    const innerLayer = innerRow === undefined ? undefined : ctx.layers[innerRow];\n    const definesThisScope = innerLayer?.kind === DEFINING_LAYER_KIND[kind];\n\n    scopes.push({\n      row,\n      layer,\n      entityId: layer.id,\n      kind,\n      entityKindId: definesThisScope ? innerLayer?.id : undefined,\n    });\n  }\n  return scopes;\n}\n\nfunction occurrenceKey(row: number, listPath: string, runStart: number): string {\n  return `s${row}@${listPath}#${runStart}`;\n}\n\nfunction readVariant(ctx: Context, scope: ChainScope): VariantFields {\n  const refs = scope.layer.record.variants;\n  if (!Array.isArray(refs) || refs.length === 0) return { variantId: 'default' };\n  if (refs.length > 1) {\n    ctx.log.log(`layer \"${scope.entityId}\" lists ${refs.length} variants; using the first`);\n  }\n\n  const variant = rowAt(ctx.variants, refs[0]);\n  const optimizationId = asString(variant?.optimizationId);\n  const variantId = asString(variant?.variantId) ?? 'default';\n  const variantIndex = variant?.variantIndex;\n\n  const fields: VariantFields = { variantId };\n  if (optimizationId !== undefined) fields.optimizationId = optimizationId;\n  if (typeof variantIndex === 'number') fields.variantIndex = variantIndex;\n  return fields;\n}\n\nfunction buildScope(\n  ctx: Context,\n  scope: ChainScope,\n  key: string,\n  parentExperience: ScopeAttribution | undefined\n): ScopeAttribution {\n  const attribution: ScopeAttribution = {\n    key,\n    entityId: scope.entityId,\n    entityKind: scope.kind,\n    ...readVariant(ctx, scope),\n  };\n  if (scope.entityKindId !== undefined) {\n    attribution.entityKindId = scope.entityKindId;\n  }\n  if (scope.kind === 'ExperienceFragment' && parentExperience !== undefined) {\n    attribution.parentExperienceId = parentExperience.entityId;\n    if (parentExperience.variantId !== undefined) {\n      attribution.parentVariantId = parentExperience.variantId;\n    }\n  }\n  return attribution;\n}\n\nfunction entriesBoundAt(ctx: Context, assemblyRow: number, path: PathSegment[]): readonly string[] {\n  const cacheKey = `${assemblyRow}|${JSON.stringify(path)}`;\n  const cached = ctx.bindingEntries.get(cacheKey);\n  if (cached !== undefined) return cached;\n\n  const found = new Set<string>();\n  const visited = new Set<string>();\n\n  const followAssembly = (row: number, path: PathSegment[]): void => {\n    const visitKey = `${row}|${JSON.stringify(path)}`;\n    const assembly = asRecord(ctx.dataAssemblies[row]);\n    if (assembly === undefined || visited.has(visitKey)) return;\n    visited.add(visitKey);\n    walk(assembly.return, path);\n  };\n\n  const walkLeaf = (leaf: Rec, path: PathSegment[]): void => {\n    if (leaf.type === 'entry') {\n      const entryId = asString(rowAt(ctx.entries, leaf.entry)?.id);\n      if (entryId !== undefined) found.add(entryId);\n    } else if (leaf.type === 'dataAssembly') {\n      const row = asIndex(leaf.dataAssembly);\n      const leafPath = isPath(leaf.path) ? leaf.path : [];\n      if (row !== undefined) followAssembly(row, [...leafPath, ...path]);\n    }\n  };\n\n  const walk = (value: unknown, path: PathSegment[]): void => {\n    const [head, ...rest] = path;\n\n    if (Array.isArray(value)) {\n      if (head === undefined) value.forEach((child) => walk(child, []));\n      else if (typeof head === 'number') walk(value[head], rest);\n      return;\n    }\n\n    const record = asRecord(value);\n    if (record === undefined) return;\n    if (typeof record.type === 'string') walkLeaf(record, path);\n    else if (head === undefined) Object.values(record).forEach((child) => walk(child, []));\n    else walk(record[String(head)], rest);\n  };\n\n  followAssembly(assemblyRow, path);\n  const ids = [...found];\n  ctx.bindingEntries.set(cacheKey, ids);\n  return ids;\n}\n\nfunction readNodeEntries(ctx: Context, entry: Rec): string[] {\n  const properties: unknown[] = Array.isArray(entry.contentProperties)\n    ? entry.contentProperties\n    : [];\n  const ids = new Set<string>();\n\n  for (const property of properties) {\n    const item = asRecord(property);\n    const assemblyRow = asIndex(item?.dataAssembly);\n    const bindings = asRecord(item?.bindings);\n    if (item?.type !== 'dataAssembly' || assemblyRow === undefined || bindings === undefined) {\n      continue;\n    }\n    for (const path of Object.values(bindings).filter(isPath)) {\n      for (const id of entriesBoundAt(ctx, assemblyRow, path)) ids.add(id);\n    }\n  }\n  return [...ids];\n}\n\nfunction addScopeEntries(ctx: Context, scope: ScopeAttribution, entryIds: string[]): void {\n  const owned = ctx.scopeEntries.get(scope) ?? new Set<string>();\n  for (const id of entryIds) owned.add(id);\n  ctx.scopeEntries.set(scope, owned);\n}\n\nfunction readChain(entry: Rec): number[] {\n  const { layers } = entry;\n  return Array.isArray(layers) && layers.every(Number.isInteger) ? (layers as number[]) : [];\n}\n\nfunction attributeNode(\n  ctx: Context,\n  node: PortableRenderNode,\n  parentKeys: Map<number, string>,\n  previousKeys: Map<number, string>,\n  listPath: string,\n  index: number\n): Map<number, string> | undefined {\n  const entry = node.nodeId === undefined ? undefined : asRecord(ctx.nodes[node.nodeId]);\n  if (entry === undefined) return undefined;\n  const scopes = reportableScopes(ctx, readChain(entry));\n  if (scopes.length === 0) return undefined;\n\n  const keys = new Map<number, string>();\n  const attribution: NodeAttribution = { scopes: [], roots: [] };\n  let parentExperience: ScopeAttribution | undefined;\n  let nearest: ScopeAttribution | undefined;\n\n  // A sibling's key is only reusable while every enclosing scope matches as well.\n  const previousScopes = previousKeys.entries();\n  let sameOccurrencePrefix = true;\n\n  for (const scope of scopes) {\n    const previous = previousScopes.next().value;\n    sameOccurrencePrefix &&= previous?.[0] === scope.row;\n\n    const isRoot = !parentKeys.has(scope.row);\n    const key: string =\n      parentKeys.get(scope.row) ??\n      (sameOccurrencePrefix ? previous?.[1] : undefined) ??\n      occurrenceKey(scope.row, listPath, index);\n    sameOccurrencePrefix &&= previous?.[1] === key;\n    keys.set(scope.row, key);\n\n    nearest = ctx.scopes[key] ??= buildScope(ctx, scope, key, parentExperience);\n    attribution.scopes.push(nearest);\n    if (isRoot) attribution.roots.push(nearest);\n    if (scope.kind === 'Experience' && parentExperience === undefined) parentExperience = nearest;\n  }\n\n  const entryIds = readNodeEntries(ctx, entry);\n  if (entryIds.length > 0 && nearest !== undefined) {\n    attribution.entryIds = entryIds;\n    addScopeEntries(ctx, nearest, entryIds);\n  }\n  node.attribution = attribution;\n  return keys;\n}\n\nfunction assignSiblings(\n  ctx: Context,\n  siblings: PortableRenderNode[],\n  parentKeys: Map<number, string>,\n  listPath = ''\n): void {\n  let previousKeys = new Map<number, string>();\n  for (const [index, node] of siblings.entries()) {\n    const ownKeys = attributeNode(ctx, node, parentKeys, previousKeys, listPath, index);\n    previousKeys = ownKeys ?? new Map();\n\n    for (const [slotName, children] of Object.entries(node.slots)) {\n      assignSiblings(ctx, children, ownKeys ?? parentKeys, `${listPath}/${index}.${slotName}`);\n    }\n  }\n}\n\nexport function resolveAttribution(\n  sourceMap: ExperienceSourceMap | undefined,\n  nodes: PortableRenderNode[],\n  log: DebugLogger\n): PlanAttribution | undefined {\n  if (sourceMap === undefined) return undefined;\n  const ctx = createContext(sourceMap, log);\n  if (ctx === undefined) return undefined;\n\n  assignSiblings(ctx, nodes, new Map());\n  for (const [scope, ids] of ctx.scopeEntries) scope.entryIds = [...ids];\n\n  const scopes = Object.values(ctx.scopes);\n  for (const scope of scopes) Object.freeze(scope);\n  return scopes.length > 0 ? { scopes: ctx.scopes } : undefined;\n}\n","/*\n * Debug logging for the SDK. The whole surface is gated on a single `debug`\n * boolean that threads through `fetchExperience` / `resolveExperience` and the\n * renderers (see `ExperienceContext.debug`). When `debug` is off, every call\n * here is a cheap no-op — nothing is logged, no strings are built (callers pass\n * thunks for anything expensive to serialize).\n *\n * This is intentionally console-based, not a pluggable logger. v1 goal is\n * \"turn it on, see what the SDK is doing\"; a customer-supplied sink can land\n * later without changing call sites (the `debug` boolean would widen to\n * `boolean | DebugSink`).\n */\n\n/** Prefix on every debug line so customers can filter their console. */\nconst PREFIX = '[experiences:debug]';\n\n/**\n * Monotonic-ish clock for span timings. Prefers `performance.now()` (present\n * in modern Node and every browser); falls back to `Date.now()`. Returns 0\n * when neither is available so timing degrades to \"no duration\" rather than\n * throwing.\n */\nfunction now(): number {\n  if (typeof performance !== 'undefined' && typeof performance.now === 'function') {\n    return performance.now();\n  }\n  if (typeof Date !== 'undefined' && typeof Date.now === 'function') return Date.now();\n  return 0;\n}\n\n/**\n * A scoped debug logger. `scope` names the emitting subsystem (e.g. `core`,\n * `client`, `react`) so interleaved logs stay legible.\n */\nexport interface DebugLogger {\n  /** Log a message with optional structured data. */\n  log(message: string, data?: unknown): void;\n  /**\n   * Log a message whose payload is expensive to build. The thunk only runs\n   * when debug is enabled — keep large payload serialization out of the hot\n   * path when debug is off.\n   */\n  lazy(message: string, getData: () => unknown): void;\n  /** Time an async span and log its duration when it settles. */\n  time<T>(label: string, fn: () => Promise<T>): Promise<T>;\n  /** True when this logger is actually emitting. */\n  readonly enabled: boolean;\n}\n\nconst NOOP_LOGGER: DebugLogger = {\n  log() {},\n  lazy() {},\n  time: (_label, fn) => fn(),\n  enabled: false,\n};\n\n/**\n * Build a debug logger. Returns a shared no-op when `debug` is falsy so\n * callers can hold onto the result unconditionally and pay nothing when off.\n */\nexport function createDebugLogger(debug: boolean | undefined, scope: string): DebugLogger {\n  if (!debug || typeof console === 'undefined') return NOOP_LOGGER;\n\n  const tag = `${PREFIX}[${scope}]`;\n  return {\n    enabled: true,\n    log(message, data) {\n      if (data === undefined) console.log(`${tag} ${message}`);\n      else console.log(`${tag} ${message}`, data);\n    },\n    lazy(message, getData) {\n      console.log(`${tag} ${message}`, getData());\n    },\n    async time(label, fn) {\n      const start = now();\n      try {\n        const result = await fn();\n        console.log(`${tag} ⏱ ${label} — ${(now() - start).toFixed(1)}ms`);\n        return result;\n      } catch (err) {\n        console.log(`${tag} ⏱ ${label} — failed after ${(now() - start).toFixed(1)}ms`, err);\n        throw err;\n      }\n    },\n  };\n}\n","/* Design-property and token resolution for the core render-plan builder. */\n\nimport type { DesignPropValue, DesignToken, ResolveToken } from './types.js';\n\n/**\n * Resolve every design property on a node into a record keyed by name.\n */\nexport function resolveDesignProperties(\n  designProperties: Record<string, DesignPropValue> | undefined\n): Record<string, string | number | boolean | DesignToken> {\n  const out: Record<string, string | number | boolean | DesignToken> = {};\n  if (!designProperties) return out;\n  for (const [key, prop] of Object.entries(designProperties)) {\n    out[key] = prop.type === 'ManualDesignValue' ? prop.value : prop;\n  }\n  return out;\n}\n\n/**\n * Resolve `DesignToken` values via `resolveToken`; scalars pass through.\n * Keys that don't resolve — no `resolveToken` configured, or the resolver\n * returns `undefined` for that particular token — pass through as the raw\n * `DesignToken` and their id is collected in `unresolved` for the caller to\n * warn/diagnose (see `warnUnresolvedTokens` in `resolve-experience.ts`, which\n * already dedupes per `resolveExperience()` call, so this function carries\n * no warn-once state of its own).\n */\nexport function applyTokenResolver(\n  props: Record<string, string | number | boolean | DesignToken>,\n  resolveToken?: ResolveToken\n): { props: Record<string, unknown>; unresolved: string[] } {\n  const out: Record<string, unknown> = {};\n  const unresolved: string[] = [];\n  for (const [key, value] of Object.entries(props)) {\n    if (typeof value === 'object' && value !== null && value.type === 'DesignToken') {\n      const resolved = resolveToken?.(value);\n      if (resolved === undefined) {\n        out[key] = value;\n        unresolved.push(value.value);\n        continue;\n      }\n      out[key] = resolved;\n      continue;\n    }\n    out[key] = value;\n  }\n  return { props: out, unresolved };\n}\n","/*\n * Turns an XDA Experience payload into a runtime-neutral PortableRenderPlan.\n * Walks nodes recursively, splits content + design props, runs any registered\n * `resolveData` hooks in parallel, and resolves design values for the renderer.\n */\n\nimport { resolveAttribution } from './attribution.js';\nimport { createDebugLogger, type DebugLogger } from './debug-logger.js';\nimport type {\n  DesignPropValue,\n  ExperienceContext,\n  ExperienceSourceMap,\n  ExperienceNode,\n  ExperiencePayload,\n  PortableRegistration,\n  PortableRenderNode,\n  PortableRenderPlan,\n  ResolveContext,\n  ResolveToken,\n} from './types.js';\nimport { applyTokenResolver, resolveDesignProperties } from './design-properties.js';\n\n/**\n * Structural type the resolver walker depends on. Matches the React /\n * Svelte adapter `Config` shape but doesn't require importing them —\n * render-core stays decoupled from any framework.\n *\n * Registry values are typed as `unknown` because each adapter accepts\n * either a bare framework component (function / Svelte class / etc.) OR\n * a config-object shape with `{ component, defaults?, resolveData? }`.\n * The resolver only cares about `resolveData`; it duck-types each entry\n * at runtime and ignores anything without it.\n */\nexport interface ResolverConfig {\n  components: Record<string, unknown>;\n  experienceTemplates?: Record<string, unknown>;\n  /**\n   * Resolves `DesignToken` design properties to runtime values. Mirrors the\n   * adapter `Config.resolveToken`, so server and client agree without the\n   * caller re-supplying it. Used during server-side pre-resolution.\n   */\n  resolveToken?: ResolveToken;\n}\n\nfunction getResolver(\n  entry: unknown\n):\n  | ((ctx: ResolveContext) => Record<string, unknown> | Promise<Record<string, unknown>>)\n  | undefined {\n  if (typeof entry !== 'object' || entry === null) return undefined;\n  const candidate = (entry as { resolveData?: unknown }).resolveData;\n  return typeof candidate === 'function'\n    ? (candidate as (\n        ctx: ResolveContext\n      ) => Record<string, unknown> | Promise<Record<string, unknown>>)\n    : undefined;\n}\n\nexport interface ResolveExperienceOptions {\n  /**\n   * Arbitrary per-render metadata exposed to every resolver as\n   * `ctx.experience.metadata`. Defaults to `{}`.\n   */\n  metadata?: Record<string, unknown>;\n  /**\n   * Observability switch. When on, `resolveExperience` logs the resolution\n   * steps and per-node `resolveData` fan-out timings. Threads through to the\n   * resolver context as `ctx.experience.debug`. Defaults to `false`.\n   */\n  debug?: boolean;\n  /**\n   * Source map carried onto the plan. An explicit map wins over\n   * `payload.extensions.sourceMap`. Omit to use the payload's map, if it\n   * carries one.\n   */\n  sourceMap?: ExperienceSourceMap;\n}\n\nconst DEFAULT_EXPERIENCE: ExperienceContext = {\n  debug: false,\n  metadata: {},\n};\n\n/**\n * Registry lookup for a built node. A node's `kind` decides which half of the\n * customer Config owns its implementation — components and Experience\n * Templates are otherwise interchangeable at every other step.\n */\nfunction lookupEntry(config: ResolverConfig, registration: PortableRegistration): unknown {\n  return registration.kind === 'experienceTemplate'\n    ? config.experienceTemplates?.[registration.id]\n    : config.components[registration.id];\n}\n\n/**\n * Extract the id (component or experienceTemplate) from its\n * `ResourceLink` URN. Real URN shapes:\n *   crn:contentful:::experience:spaces/$self/environments/$self/components/<id>\n *   crn:contentful:::experience:spaces/$self/environments/$self/experienceTemplates/<id>\n *\n * The id is the final path segment. We split on `/` and take the last\n * non-empty piece so this also tolerates trailing slashes or alternative\n * prefix shapes.\n */\nfunction extractIdFromUrn(urn: string): string {\n  const segments = urn.split('/').filter((s) => s.length > 0);\n  return segments[segments.length - 1] ?? urn;\n}\n\n/**\n * Read the ResourceLink a node points at. Which key is present is the only\n * difference between the two node variants: `experienceTemplate` means the\n * implementation lives in the customer's `experienceTemplates` registry,\n * `component` in `components`. Both carry ids in the same URN shape, the same\n * props shape, and the same slots — so everything downstream is kind-agnostic.\n *\n * `ExperienceNode` is a closed union, so a typed caller cannot produce anything\n * else. Payloads, however, are untrusted JSON at runtime, and the realistic way\n * a third shape arrives is a node kind *newer than this SDK*. Returns `null`\n * for anything unidentifiable rather than letting the ref access throw — see\n * `buildNode`.\n */\nfunction readNodeRef(\n  node: ExperienceNode\n): { kind: PortableRegistration['kind']; urn: string } | null {\n  const isExperienceTemplate = 'experienceTemplate' in node;\n  const ref = isExperienceTemplate\n    ? node.experienceTemplate\n    : 'component' in node\n      ? node.component\n      : undefined;\n  // Cast because the runtime value may violate the declared type: a node can\n  // carry `component: {}`, which satisfies `'component' in node` but has no urn.\n  const urn = (ref as { sys?: { urn?: unknown } } | undefined)?.sys?.urn;\n  if (typeof urn !== 'string' || urn.length === 0) return null;\n  return { kind: isExperienceTemplate ? 'experienceTemplate' : 'component', urn };\n}\n\n/**\n * Guards a top-level payload field that must be an array. A malformed or\n * partial payload (bad JSON, a hand-authored payload with the wrong shape)\n * should degrade to an empty experience rather than throwing and failing the\n * whole render — same \"dropping beats throwing\" rationale as\n * `warnUnrenderableNode` below, just one level up the tree.\n */\nfunction ensureArray<T>(\n  value: unknown,\n  field: string,\n  log: DebugLogger,\n  diagnostics: Error[]\n): T[] {\n  if (Array.isArray(value)) return value as T[];\n  const message =\n    `Experience payload's \"${field}\" is not an array (got ${value === null ? 'null' : typeof value}); ` +\n    `treating it as empty instead of throwing. This usually means a malformed or partial payload — ` +\n    `check what produced it.`;\n  if (typeof console !== 'undefined') {\n    console.warn(`[@contentful/experiences] ${message}`);\n  }\n  log.log(message);\n  diagnostics.push(new Error(message));\n  return [];\n}\n\n/** Total node count in a payload subtree, the node itself included. */\nfunction countPayloadNodes(node: ExperienceNode): number {\n  const slots = (node as { slots?: Record<string, unknown> }).slots;\n  let total = 1;\n  if (slots && typeof slots === 'object') {\n    for (const children of Object.values(slots)) {\n      if (!Array.isArray(children)) continue;\n      for (const child of children) total += countPayloadNodes(child as ExperienceNode);\n    }\n  }\n  return total;\n}\n\n/**\n * The one case where a node is dropped. AIS-413 was the opposite failure —\n * a node kind the SDK recognized and could have rendered, skipped behind a\n * vague warning, taking its whole subtree with it — so the bar here is that\n * nothing vanishes without a diagnostic naming what was lost.\n *\n * Dropping beats throwing: a `resolveExperience` rejection fails the entire\n * experience, so one unrecognized node in a sidebar would take down every page\n * containing it, for a payload the customer does not control and cannot fix.\n */\nfunction warnUnrenderableNode(node: ExperienceNode, log: DebugLogger, diagnostics: Error[]): void {\n  const id = (node as { id?: unknown }).id;\n  const label = typeof id === 'string' ? ` \"${id}\"` : '';\n  const keys = Object.keys(node);\n  const descendants = countPayloadNodes(node) - 1;\n  const message =\n    `Skipping unidentifiable node${label}: expected a \\`component\\` or \\`experienceTemplate\\` ` +\n    `ResourceLink carrying a urn, got keys [${keys.join(', ')}]. Dropping it and ${descendants} ` +\n    `descendant node(s). A payload node kind this SDK does not know is usually a version skew — ` +\n    `upgrading @contentful/experiences-sdk-core may be all that is needed.`;\n  if (typeof console !== 'undefined') {\n    console.warn(`[@contentful/experiences] ${message}`);\n  }\n  log.log(message);\n  diagnostics.push(new Error(message));\n}\n\n/**\n * Walk a sibling list into IR nodes, dropping any node `buildNode` cannot\n * identify. Used for both the top-level list and every slot.\n */\nfunction buildNodes(\n  nodes: ExperienceNode[],\n  config: ResolverConfig,\n  nodeRefs: PortableRenderNode[],\n  log: DebugLogger,\n  diagnostics: Error[]\n): PortableRenderNode[] {\n  const built: PortableRenderNode[] = [];\n  for (const node of nodes) {\n    const one = buildNode(node, config, nodeRefs, log, diagnostics);\n    if (one !== null) built.push(one);\n  }\n  return built;\n}\n\n/**\n * Recursively turn a payload node into an IR node. The collected `nodeRefs`\n * array is for the resolver pass — every built node with a registered\n * resolver gets a reference appended so we can run them in parallel without\n * walking the tree twice.\n *\n * Returns `null` only for a node whose ResourceLink cannot be read, which\n * `warnUnrenderableNode` has already reported. Callers go through `buildNodes`.\n */\nfunction buildNode(\n  node: ExperienceNode,\n  config: ResolverConfig,\n  nodeRefs: PortableRenderNode[],\n  log: DebugLogger,\n  diagnostics: Error[]\n): PortableRenderNode | null {\n  const ref = readNodeRef(node);\n  if (ref === null) {\n    warnUnrenderableNode(node, log, diagnostics);\n    return null;\n  }\n  const registration: PortableRegistration = {\n    kind: ref.kind,\n    id: extractIdFromUrn(ref.urn),\n  };\n  const nodeId = typeof node.id === 'string' ? node.id : undefined;\n\n  const slots: Record<string, PortableRenderNode[]> = {};\n  if (node.slots) {\n    for (const [slotName, children] of Object.entries(node.slots)) {\n      if (!Array.isArray(children)) {\n        const message =\n          `Slot \"${slotName}\" on ${registration.kind} \"${registration.id}\"` +\n          `${nodeId ? ` (node \"${nodeId}\")` : ''} is not an array of nodes (got ` +\n          `${children === null ? 'null' : typeof children}); treating it as empty instead of ` +\n          `failing the whole experience. A hand-built payload with the wrong slot shape is the ` +\n          `usual cause.`;\n        if (typeof console !== 'undefined') {\n          console.warn(`[@contentful/experiences] ${message}`);\n        }\n        log.log(message);\n        diagnostics.push(new Error(message));\n        slots[slotName] = [];\n        continue;\n      }\n      slots[slotName] = buildNodes(children, config, nodeRefs, log, diagnostics);\n    }\n  }\n\n  const built: PortableRenderNode = {\n    registration,\n    props: {\n      content: { ...(node.contentProperties ?? {}) },\n      // Resolved design values are written by the pre-resolution pass below.\n      design: {},\n      designRaw: { ...(node.designProperties ?? {}) } as Record<string, DesignPropValue>,\n    },\n    slots,\n  };\n  if (node.id) built.nodeId = node.id;\n  if (getResolver(lookupEntry(config, registration))) {\n    nodeRefs.push(built);\n  }\n  return built;\n}\n\n// Resolve a node's raw design values and tokens.\nfunction preResolveDesignProperties(\n  design: Record<string, DesignPropValue>,\n  resolveToken: ResolveToken | undefined\n): { props: Record<string, unknown>; unresolved: string[] } {\n  return applyTokenResolver(resolveDesignProperties(design), resolveToken);\n}\n\n// Warn when resolveToken left tokens unresolved, so pass-through keys are diagnosable.\nfunction warnUnresolvedTokens(\n  label: string,\n  unresolved: string[],\n  log: DebugLogger,\n  diagnostics: Error[]\n): void {\n  if (!unresolved.length) return;\n  const message = `resolveToken returned undefined for token id(s) on \"${label}\": ${unresolved.join(', ')}. Resolved design (getDesignValues()) will carry the raw, unresolved DesignToken for those keys.`;\n  if (typeof console !== 'undefined') {\n    console.warn(`[@contentful/experiences] ${message}`);\n  }\n  log.log(`unresolved token id(s) on \"${label}\": ${unresolved.join(', ')}`);\n  for (const tokenId of unresolved) {\n    diagnostics.push(\n      new Error(\n        `Design token \"${tokenId}\" on ${label} has no \\`resolveToken\\` mapping; the raw token reaches the component unresolved.`\n      )\n    );\n  }\n}\n\n// Depth-first token resolution for a node and its slot children.\nfunction preResolveNodeTree(\n  node: PortableRenderNode,\n  resolveToken: ResolveToken | undefined,\n  log: DebugLogger,\n  diagnostics: Error[]\n): void {\n  const { props, unresolved } = preResolveDesignProperties(node.props.designRaw, resolveToken);\n  node.props.design = props;\n  warnUnresolvedTokens(\n    `${node.registration.kind}:${node.registration.id}`,\n    unresolved,\n    log,\n    diagnostics\n  );\n  for (const children of Object.values(node.slots)) {\n    for (const child of children) {\n      preResolveNodeTree(child, resolveToken, log, diagnostics);\n    }\n  }\n}\n\n/**\n * Turns an Experience payload (XDA response shape) into a PortableRenderPlan\n * ready to hand to a renderer. Walks the tree, classifies props, captures\n * slots, and runs any component-declared `resolveData` hooks (sync or async)\n * in parallel.\n *\n * Implementation note: the function is always async — even when no component\n * declares a resolver, the cost is one microtask. Customers get a single\n * uniform call site.\n */\nexport async function resolveExperience(\n  payload: ExperiencePayload,\n  config: ResolverConfig,\n  options: ResolveExperienceOptions = {}\n): Promise<PortableRenderPlan> {\n  const log = createDebugLogger(options.debug, 'core');\n  log.lazy('resolveExperience called with payload', () => payload);\n\n  const diagnostics: Error[] = [];\n\n  // A payload that isn't an object at all (missing fetch result, a raw\n  // `null`/`undefined` handed in by a broken transform step) can't be\n  // guarded field-by-field via `ensureArray` below — that only guards once\n  // we're already inside a `payload.nodes` access. Guard the whole payload\n  // first so we degrade to an empty experience instead of throwing a raw\n  // TypeError, and report exactly one diagnostic rather than double-counting\n  // once we also run `nodes` through `ensureArray`.\n  const isPlainPayload = payload !== null && typeof payload === 'object';\n  if (!isPlainPayload) {\n    const message =\n      `Experience payload is ${payload === null ? 'null' : typeof payload}, not an object; ` +\n      `treating it as an empty experience (no nodes) instead of throwing. This ` +\n      `usually means the fetch or transform pipeline handed resolveExperience a missing or ` +\n      `malformed payload — check what produced it.`;\n    if (typeof console !== 'undefined') {\n      console.warn(`[@contentful/experiences] ${message}`);\n    }\n    log.log(message);\n    diagnostics.push(new Error(message));\n  }\n  const payloadNodes = isPlainPayload\n    ? ensureArray<ExperienceNode>(payload.nodes, 'nodes', log, diagnostics)\n    : [];\n  // Pass 1: walk the payload into the IR. Collect refs to nodes that need\n  // resolveData so pass 2 can run them in parallel without re-walking.\n  const nodeRefs: PortableRenderNode[] = [];\n  const nodes: PortableRenderNode[] = buildNodes(payloadNodes, config, nodeRefs, log, diagnostics);\n  log.log(`built ${nodes.length} top-level node(s); ${nodeRefs.length} declare resolveData`);\n\n  // Pass 2: run every node's resolveData hook in parallel.\n  const experience: ExperienceContext = {\n    debug: options.debug ?? DEFAULT_EXPERIENCE.debug,\n    metadata: {\n      ...DEFAULT_EXPERIENCE.metadata,\n      ...(options.metadata ?? {}),\n    },\n  };\n\n  const tasks: Array<Promise<void>> = [];\n\n  for (const node of nodeRefs) {\n    const resolver = getResolver(lookupEntry(config, node.registration));\n    if (!resolver) continue;\n    const ctx: ResolveContext = {\n      content: node.props.content,\n      design: node.props.designRaw,\n      experience,\n    };\n    tasks.push(\n      // Deferred via `.then(() => resolver(ctx))` rather than\n      // `Promise.resolve(resolver(ctx))`: the latter calls `resolver(ctx)`\n      // eagerly as an argument, so a resolver that throws *synchronously*\n      // escapes immediately instead of becoming a rejection. The `onFailure`\n      // handler below never rethrows, so one broken resolver can't fail the\n      // `Promise.all` for every other node.\n      Promise.resolve()\n        .then(() => resolver(ctx))\n        .then(\n          (resolved) => {\n            node.props.resolved = resolved;\n          },\n          (err: unknown) => {\n            const label = `${node.registration.kind}:${node.registration.id}`;\n            const reason = err instanceof Error ? err.message : String(err);\n            const message =\n              `resolveData for ${label}${node.nodeId ? ` (node \"${node.nodeId}\")` : ''} threw or ` +\n              `rejected: ${reason}. Rendering the node without resolved data instead of failing ` +\n              `the whole experience.`;\n            if (typeof console !== 'undefined') {\n              console.warn(`[@contentful/experiences] ${message}`);\n            }\n            log.log(message);\n            diagnostics.push(new Error(message, { cause: err instanceof Error ? err : undefined }));\n          }\n        )\n    );\n  }\n\n  // Time the fan-out as a whole rather than per-resolver — one aggregate line\n  // keeps the timing signal without a line per node (which gets noisy fast).\n  if (tasks.length > 0) {\n    await log.time(`${tasks.length} resolveData hook(s)`, () => Promise.all(tasks));\n  }\n\n  for (const node of nodes) {\n    preResolveNodeTree(node, config.resolveToken, log, diagnostics);\n  }\n  log.log('resolved design properties');\n\n  // Reuse `experience.metadata` rather than re-merging, so resolvers and the\n  // renderer read the same object.\n  const plan: PortableRenderPlan = {\n    nodes,\n    diagnostics,\n    metadata: experience.metadata,\n    debug: experience.debug,\n  };\n  const sourceMap =\n    options.sourceMap ?? (isPlainPayload ? payload.extensions?.sourceMap : undefined);\n  if (sourceMap) {\n    plan.sourceMap = sourceMap;\n    const attribution = resolveAttribution(sourceMap, nodes, log);\n    if (attribution) plan.attribution = attribution;\n  }\n  const profileId = isPlainPayload && payload.extensions?.personalization?.profile?.id;\n  if (profileId) {\n    plan.personalization = { profileId };\n  }\n  return plan;\n}\n","/**\n * Lists the occurrence keys of the scopes an element roots, space-separated.\n * Put it on the outermost element a node renders. The keys are opaque: they\n * resolve through `plan.attribution.scopes`, so no attribution lives in the DOM.\n */\nexport const TRACKING_SCOPES_ATTRIBUTE = 'data-ctfl-scopes';\n\n/**\n * Opts an element into click tracking when it is not otherwise interactive.\n * Links, buttons, form controls, `[role=\"button\"]`, `[role=\"link\"]`, and\n * elements with an `onclick` handler count already. Set it to `\"true\"`.\n */\nexport const TRACKING_CLICKABLE_ATTRIBUTE = 'data-ctfl-clickable';\n\nexport interface TrackingAttributes {\n  [TRACKING_SCOPES_ATTRIBUTE]?: string;\n}\n\n/**\n * Attributes to spread onto a tracked node's outermost element, built from the\n * `attribution` a component context accessor returns. Returns `{}` when the\n * node roots no scope: nothing is rendered for it, so a node in the middle of a\n * scope, or one without attribution, is left alone.\n *\n * @example\n * ```tsx\n * const contentful = useContentfulComponent();\n * <section {...getTrackingAttributes(contentful?.attribution)}>…</section>\n * ```\n */\nexport function getTrackingAttributes(\n  attribution: { roots: ReadonlyArray<{ key: string }> } | undefined\n): TrackingAttributes {\n  const keys = attribution?.roots.map((scope) => scope.key) ?? [];\n  return keys.length > 0 ? { [TRACKING_SCOPES_ATTRIBUTE]: keys.join(' ') } : {};\n}\n"]}