@storystick/preview 0.0.0-stage → 0.2.0-rc.0

package/dist/provenance/runtime-script.js

@@ -0,0 +1,2217 @@
+import { installPreviewWorkspaceShortcuts, previewWorkspaceCommandIds, } from '../runtime/workspace-shortcuts.js';
+import { decodePreviewReadCarrier, selectPreviewPrimaryPage } from './read-carrier.js';
+import { PREVIEW_PROVENANCE_ANCHOR_MAP_EVENT } from './local-events.js';
+// Utility consumers of the provenance entry point must not retain the injected
+// runtime. Constructing this string is pure; only its explicit consumer runs it.
+export const previewProvenanceRuntimeScript = /* @__PURE__ */ (() => String.raw `
+(() => {
+  const decodeReadCarrier = ${decodePreviewReadCarrier.toString()}
+  const selectPrimaryPage = ${selectPreviewPrimaryPage.toString()}
+  const LOCAL_ANCHOR_MAP_EVENT = ${JSON.stringify(PREVIEW_PROVENANCE_ANCHOR_MAP_EVENT)}
+  // This script is served by the SDK endpoint, including the framework basePath.
+  const runtimePath = document.currentScript?.src ? new URL(document.currentScript.src).pathname : ''
+  const runtimeBasePath = runtimePath.endsWith('/api/storystick/provenance-runtime')
+    ? runtimePath.slice(0, -'/api/storystick/provenance-runtime'.length) : ''
+  if (window.__ssPreviewProvenanceRuntimeInstalled) return
+  window.__ssPreviewProvenanceRuntimeInstalled = true
+  const installWorkspaceShortcuts = ${installPreviewWorkspaceShortcuts.toString()}
+  installWorkspaceShortcuts(window, () => {
+    const state = window.__storystick_preview_runtime__?.state
+    return state && !state.previewEnded ? state.identity : null
+  }, ${JSON.stringify(previewWorkspaceCommandIds)})
+  // Missing required anchors remain invalid. Poll slowly between real DOM
+  // invalidations, with a wall-clock deadline independent of display refresh.
+  const READY_DEADLINE_MS = 4000
+  const READY_RETRY_MS = 100
+  // Work counters belong to this Document, not to each provenance frame.
+  // The existing manual probe exposes totals; they never drive readiness.
+  const observationStats = { readCarrierScans: 0, anchorCollections: 0, codedTextScans: 0, readyPasses: 0, publications: 0 }
+  let readyFrame = null
+  let readyRetryTimer = null
+  let readyWork = null
+  let readyPassRunning = false
+  let documentActive = true
+  let cancelEpoch = 1
+  let iframeGeneration = 1
+  let currentRenderIdentity = { generation: 1, sourceOfTruth: 'iframe' }
+  let currentInteractionMode = 'edit'
+  let lastMomentaryNavigateKeyActive = null
+  let pendingNavigationEpoch = null
+  let lastPublisherRevision = 0
+  let activePublisherRoute = null
+  let nativeViewAnchor = null
+  let lastPublishedSnapshot = null
+  let lastRenderedContextKey = null
+  const publisherFramesById = new Map()
+  const readCarrierCache = new Map()
+  let readCarrierFrames = []
+  let primaryPageCandidates = []
+  let lastPrimaryPagesKey = null
+  let readCarrierSignature = ''
+  let readCarriersDirty = true
+  let publisherSnapshotDirty = false
+  const consumedPublisherElements = new WeakSet()
+  const pendingOccurrenceRemovals = new Map()
+  const PUBLISHER_CONSUMED_EVENT = 'storystick.preview.provenance-publisher-consumed'
+  const PUBLISHER_CONSUMED_REGISTRY = '__ssPreviewProvenanceConsumedPublishersV2'
+  const PAINT_ID_ATTRIBUTE = 'data-ss-preview-paint-id'
+  const PAINT_TARGET_REGISTRY = '__ssPreviewPaintTargetRegistryV1'
+  let nextPaintId = 1
+  const paintIdByElement = new WeakMap()
+  const paintTargetById = new Map()
+  let provenanceObserver = null
+  let viewportFrame = null
+  let hydrationSafeDomMaterializationEnabled = false
+  let hydrationSafeDomMaterializationScheduled = false
+  let hydrationTimer = null
+  let hydrationFrame = null
+  let hydrationLoadListener = null
+  const DOM_HYDRATION_GRACE_MS = 2000
+  const CODED_TEXT_START = encodeTagAscii('ss-p:')
+  const CODED_TEXT_SEPARATOR = encodeTagAscii('|')
+  const CODED_TEXT_END = encodeTagAscii('/ss-p')
+  const SYNTHETIC_OVERLAY_SELECTOR =
+    '[data-ss-preview-field-synthetic-overlay-root],[data-ss-preview-field-synthetic-overlay-box]'
+  const VISIBILITY_ATTRIBUTE_FILTER = [
+    'data-ss-p',
+    'data-ss-e',
+    'data-ss-provenance-frame',
+    'data-ss-provenance-publisher',
+    'data-ss-route-frame-hash',
+    'data-preview-message-session-id',
+    'hidden',
+    'style',
+    'class',
+    'aria-expanded',
+    'aria-hidden',
+    'data-state',
+    'open',
+    'popover',
+    'inert',
+  ]
+  const PROVENANCE_OBSERVER_OPTIONS = {
+    childList: true,
+    subtree: true,
+    characterData: true,
+    attributes: true,
+    attributeFilter: VISIBILITY_ATTRIBUTE_FILTER,
+  }
+
+  function encodeTagAscii(value) {
+    let encoded = ''
+    for (const char of value) {
+      const code = char.codePointAt(0)
+      if (code === undefined || code < 0x20 || code > 0x7e) return ''
+      encoded += String.fromCodePoint(0xe0000 + code)
+    }
+    return encoded
+  }
+
+  function decodeTagAscii(value) {
+    let decoded = ''
+    for (const char of value) {
+      const code = char.codePointAt(0)
+      if (code === undefined || code < 0xe0020 || code > 0xe007e) return ''
+      decoded += String.fromCodePoint(code - 0xe0000)
+    }
+    return decoded
+  }
+
+  function decodeCodedText(value) {
+    const segments = []
+    let text = ''
+    let cursor = 0
+    while (cursor < value.length) {
+      const markerStart = value.indexOf(CODED_TEXT_START, cursor)
+      if (markerStart < 0) {
+        text += value.slice(cursor)
+        break
+      }
+      text += value.slice(cursor, markerStart)
+      const encodedMarkerStart = markerStart + CODED_TEXT_START.length
+      const separator = value.indexOf(CODED_TEXT_SEPARATOR, encodedMarkerStart)
+      if (separator < 0) {
+        text += value.slice(markerStart)
+        break
+      }
+      const textStart = separator + CODED_TEXT_SEPARATOR.length
+      const textEnd = value.indexOf(CODED_TEXT_END, textStart)
+      if (textEnd < 0) {
+        text += value.slice(markerStart)
+        break
+      }
+      const carrierId = decodeTagAscii(value.slice(encodedMarkerStart, separator))
+      const markerId = normalizedCarrierMarkerId(carrierId)
+      const segmentText = value.slice(textStart, textEnd)
+      if (markerId.length > 0) {
+        segments.push({
+          markerId,
+          carrierId,
+          text: segmentText,
+          markerStart,
+          markerEnd: textEnd + CODED_TEXT_END.length,
+          textStart,
+          textEnd,
+        })
+      }
+      text += segmentText
+      cursor = textEnd + CODED_TEXT_END.length
+    }
+    return { text, segments }
+  }
+
+  function studioTargetOrigin() {
+    const runtime = window.__storystick_preview_runtime__
+    const identity = runtime && runtime.state && runtime.state.identity
+    const parentOrigin = identity && identity.parentOrigin
+    if (typeof parentOrigin === 'string' && parentOrigin.length > 0) {
+      try {
+        const parsed = new URL(parentOrigin)
+        if (parsed.origin === parentOrigin) return parentOrigin
+      } catch {}
+    }
+    // The provenance script can run before the identity handshake, and older
+    // SDK runtimes may not expose identity on the shared cell. The initial
+    // message must remain discoverable; inbound validation still locks source,
+    // origin, session, schema, and monotonic identity before accepting an echo.
+    return '*'
+  }
+
+  function isSyntheticOverlayNode(node) {
+    if (node instanceof Element) {
+      return node.closest(SYNTHETIC_OVERLAY_SELECTOR) !== null
+    }
+    const parent = node.parentNode
+    return parent instanceof Element &&
+      parent.closest(SYNTHETIC_OVERLAY_SELECTOR) !== null
+  }
+
+  function isSyntheticOverlayOnlyMutation(record) {
+    if (isSyntheticOverlayNode(record.target)) return true
+    if (record.type !== 'childList') return false
+    const changedNodes = [...record.addedNodes, ...record.removedNodes]
+    return changedNodes.length > 0 &&
+      changedNodes.every((node) => isSyntheticOverlayNode(node))
+  }
+
+  function normalizeRenderIdentity(identity) {
+    const generation = Number.isFinite(identity && identity.generation) && identity.generation > 0
+      ? identity.generation
+      : 1
+    const sourceOfTruth =
+      identity && (identity.sourceOfTruth === 'studio' || identity.sourceOfTruth === 'iframe' || identity.sourceOfTruth === 'system')
+        ? identity.sourceOfTruth
+        : 'system'
+    return {
+      generation,
+      sourceOfTruth,
+      ...(identity && typeof identity.commandId === 'string' && identity.commandId.length > 0
+        ? { commandId: identity.commandId }
+        : {}),
+    }
+  }
+
+  function parseSidecar(text) {
+    if (typeof text !== 'string' || text.trim().length === 0) return emptySidecar()
+    try {
+      const parsed = JSON.parse(text)
+      const dependencySet = normalizeDependencySet(parsed.dependencySet)
+      return {
+        type: 'storystick.preview.public-sidecar',
+        version: 1,
+        routeHash: typeof parsed.routeHash === 'string' ? parsed.routeHash : '',
+        ...(normalizeVariantId(parsed.variantId) !== null
+          ? { variantId: normalizeVariantId(parsed.variantId) }
+          : {}),
+        ...(normalizePreviewScope(parsed.previewScope) !== null
+          ? { previewScope: normalizePreviewScope(parsed.previewScope) }
+          : {}),
+        codeVersion: typeof parsed.codeVersion === 'string' ? parsed.codeVersion : '',
+        renderId: typeof parsed.renderId === 'string' ? parsed.renderId : '',
+        generation: typeof parsed.generation === 'number' ? parsed.generation : 0,
+        renderNonce: typeof parsed.renderNonce === 'string' ? parsed.renderNonce : '',
+        routeRenderNonce: typeof parsed.routeRenderNonce === 'string'
+          ? parsed.routeRenderNonce
+          : '',
+        emissionRevision: typeof parsed.emissionRevision === 'number'
+          ? parsed.emissionRevision
+          : 0,
+        ...(dependencySet ? { dependencySet } : {}),
+        markers: Array.isArray(parsed.markers)
+          ? parsed.markers.flatMap(normalizeMarker)
+          : [],
+      }
+    } catch {
+      return emptySidecar()
+    }
+  }
+
+  function normalizeMarker(marker) {
+    if (typeof marker !== 'object' || marker === null) return []
+    if (typeof marker.markerId !== 'string' || marker.markerId.length === 0) return []
+    const editLocator = normalizeEditLocator(marker.editLocator)
+    return [{
+      markerId: marker.markerId,
+      ...(editLocator ? { editLocator } : {}),
+      modality: typeof marker.modality === 'string' ? marker.modality : 'text',
+      anchorKind: typeof marker.anchorKind === 'string' ? marker.anchorKind : 'element',
+      anchorMultiplicity: marker.anchorMultiplicity === 'multi' ? 'multi' : undefined,
+      presence: marker.presence === 'optional' || marker.presence === 'expected'
+        ? marker.presence
+        : undefined,
+      renderedTextFingerprint: typeof marker.renderedTextFingerprint === 'string'
+        ? marker.renderedTextFingerprint
+        : undefined,
+    }]
+  }
+
+  function normalizeEditLocator(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) return null
+    if (value.version !== 1) return null
+    const sourceKinds = new Set(['stored', 'binding', 'model', 'computed', 'richtext', 'embed', 'emptyFallback', 'unknown'])
+    if (!sourceKinds.has(value.sourceKind)) return null
+    const bounded = (candidate, max, allowEmpty) => {
+      if (typeof candidate !== 'string' || candidate.length > max) return null
+      const normalized = candidate.trim()
+      return normalized.length > 0 || allowEmpty === true ? normalized : null
+    }
+    const sourceSetId = bounded(value.sourceSetId, 512, false)
+    const documentId = bounded(value.documentId, 256, false)
+    const canonicalPath = bounded(value.canonicalPath, 4096, false)
+    if (!sourceSetId || !documentId || !canonicalPath) return null
+    const pathAnchors = normalizeLocatorAnchors(value.pathAnchors)
+    if (pathAnchors === null) return null
+    const navigationAnchors = value.navigationAnchors === undefined
+      ? undefined
+      : normalizeLocatorAnchors(value.navigationAnchors)
+    if (navigationAnchors === null) return null
+    const navigationPath = value.navigationPath === undefined
+      ? undefined
+      : bounded(value.navigationPath, 4096, false)
+    if (value.navigationPath !== undefined && !navigationPath) return null
+    const variantId = normalizeVariantId(value.variantId)
+    if (value.variantId !== undefined && (typeof value.variantId !== 'string' || !variantId)) return null
+    const textNodeIndex = Number.isInteger(value.textNodeIndex) && value.textNodeIndex >= 0
+      ? value.textNodeIndex
+      : undefined
+    if (value.textNodeIndex !== undefined && textNodeIndex === undefined) return null
+    const readScope = value.readScope === undefined
+      ? undefined
+      : normalizePreviewScope(value.readScope)
+    if (value.readScope !== undefined && readScope === null) return null
+    return {
+      version: 1,
+      sourceSetId,
+      documentId,
+      ...(variantId ? { variantId } : {}),
+      canonicalPath,
+      pathAnchors,
+      ...(navigationPath !== undefined ? { navigationPath } : {}),
+      ...(navigationAnchors !== undefined ? { navigationAnchors } : {}),
+      ...(textNodeIndex !== undefined ? { textNodeIndex } : {}),
+      sourceKind: value.sourceKind,
+      ...(readScope !== undefined ? { readScope } : {}),
+    }
+  }
+
+  function normalizeLocatorAnchors(value) {
+    if (!Array.isArray(value) || value.length > 64) return null
+    const anchors = []
+    for (const entry of value) {
+      if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) return null
+      if (typeof entry.path !== 'string' || entry.path.length > 4096) return null
+      if (typeof entry.key !== 'string' || entry.key.trim().length === 0 || entry.key.length > 512) return null
+      anchors.push({ path: entry.path.trim(), key: entry.key.trim() })
+    }
+    return anchors
+  }
+
+  function normalizePreviewScope(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) return null
+    const boundedString = (candidate, max) =>
+      typeof candidate === 'string' && candidate.length > 0 && candidate.length <= max
+    const nullableString = (candidate, max) =>
+      candidate === null || boundedString(candidate, max)
+    const validStatus =
+      value.releaseScopeStatus === 'none' ||
+      value.releaseScopeStatus === 'active' ||
+      value.releaseScopeStatus === 'missing' ||
+      value.releaseScopeStatus === 'not-previewable' ||
+      value.releaseScopeStatus === 'unbound'
+    if (
+      !nullableString(value.requestedVariantId, 256) ||
+      !nullableString(value.requestedDocumentId, 256) ||
+      !(value.requestedLocale === undefined || nullableString(value.requestedLocale, 128)) ||
+      !(value.appliedLocale === undefined || nullableString(value.appliedLocale, 128)) ||
+      !(value.appliesToDocument === null || typeof value.appliesToDocument === 'boolean') ||
+      !nullableString(value.appliedVariantId, 256) ||
+      !nullableString(value.requestedReleaseId, 256) ||
+      !validStatus ||
+      !(value.releaseLifecycleStatus === undefined || boundedString(value.releaseLifecycleStatus, 64)) ||
+      !nullableString(value.appliedReleaseId, 256) ||
+      !(value.releaseMemberState === undefined || value.releaseMemberState === 'active' || value.releaseMemberState === 'archived' || value.releaseMemberState === 'missing' || value.releaseMemberState === 'locale-removed') ||
+      !(value.degradedReason === undefined || value.degradedReason === 'archived' || value.degradedReason === 'missing' || value.degradedReason === 'locale-removed')
+    ) return null
+    return {
+      requestedVariantId: value.requestedVariantId,
+      requestedDocumentId: value.requestedDocumentId,
+      ...(value.requestedLocale !== undefined
+        ? { requestedLocale: value.requestedLocale }
+        : {}),
+      ...(value.appliedLocale !== undefined
+        ? { appliedLocale: value.appliedLocale }
+        : {}),
+      appliesToDocument: value.appliesToDocument,
+      appliedVariantId: value.appliedVariantId,
+      requestedReleaseId: value.requestedReleaseId,
+      releaseScopeStatus: value.releaseScopeStatus,
+      ...(typeof value.releaseLifecycleStatus === 'string'
+        ? { releaseLifecycleStatus: value.releaseLifecycleStatus }
+        : {}),
+      appliedReleaseId: value.appliedReleaseId,
+      ...(typeof value.releaseMemberState === 'string'
+        ? { releaseMemberState: value.releaseMemberState }
+        : {}),
+      ...(typeof value.degradedReason === 'string'
+        ? { degradedReason: value.degradedReason }
+        : {}),
+    }
+  }
+
+  function normalizeReadContext(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) ||
+        Object.keys(value).sort().join(',') !== 'contextId,perspective,revision' ||
+        typeof value.contextId !== 'string' || !value.contextId || value.contextId.length > 512 ||
+        !Number.isSafeInteger(value.revision) || value.revision < 1) return null
+    const p = value.perspective
+    if (!p || typeof p !== 'object' || Array.isArray(p)) return null
+    const keys = Object.keys(p).sort().join(',')
+    if ((p.kind === 'living' || p.kind === 'published') && keys === 'kind') return value
+    const field = p.kind === 'variant' ? 'variantId' : p.kind === 'release' ? 'releaseId' : null
+    return field && keys === ['kind', field].sort().join(',') &&
+      typeof p[field] === 'string' && p[field].length > 0 && p[field].length <= 512 ? value : null
+  }
+
+  function authenticatedReadContext() {
+    const state = window.__storystick_preview_runtime__?.state
+    return state?.state === 'authenticated' && state?.session?.readContextStatus === 'active'
+      ? normalizeReadContext(state.session.readContext) : null
+  }
+
+  function matchesCurrentReadContext(dependencies) {
+    if (!dependencies?.readContext) return true
+    const current = authenticatedReadContext()
+    return current !== null && current.contextId === dependencies.readContext.contextId &&
+      current.revision === dependencies.readContext.revision
+  }
+
+  function normalizeDependencySet(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) return null
+    if (
+      value.type !== 'storystick.preview.frame-dependency-set' ||
+      value.version !== 1 ||
+      (!(typeof value.sessionId === 'string' && value.sessionId.length > 0) && !normalizeReadContext(value.readContext)) ||
+      typeof value.routeHash !== 'string' || value.routeHash.length === 0 ||
+      typeof value.codeVersion !== 'string' || value.codeVersion.length === 0 ||
+      typeof value.frameId !== 'string' || value.frameId.length === 0 ||
+      typeof value.renderId !== 'string' || value.renderId.length === 0 ||
+      !Number.isFinite(value.generation) || value.generation <= 0 ||
+      !Array.isArray(value.dependencies) || value.dependencies.length > 256 ||
+      (value.observationId !== undefined && typeof value.observationId !== 'string') ||
+      (value.renderWatermark !== undefined && !Number.isFinite(value.renderWatermark))
+    ) return null
+    if (JSON.stringify(value).length > 1_000_000) return null
+    const readContext = value.readContext === undefined ? undefined : normalizeReadContext(value.readContext)
+    if (readContext === null) return null
+    if (value.receiptIds !== undefined && (!Array.isArray(value.receiptIds) || value.receiptIds.length > 64 ||
+        !value.receiptIds.every((id) => typeof id === 'string' && /^pqr_[a-f0-9]{64}$/.test(id)))) return null
+    const dependencies = value.dependencies.flatMap(normalizeDependency)
+    if (dependencies.length !== value.dependencies.length) return null
+    const variantId = normalizeVariantId(value.variantId)
+    return {
+      type: 'storystick.preview.frame-dependency-set',
+      version: 1,
+      ...(value.sessionId ? { sessionId: value.sessionId } : {}),
+      ...(readContext ? { readContext } : {}),
+      ...(value.receiptIds ? { receiptIds: value.receiptIds } : {}),
+      routeHash: value.routeHash,
+      codeVersion: value.codeVersion,
+      ...(variantId ? { variantId } : {}),
+      frameId: value.frameId,
+      renderId: value.renderId,
+      generation: value.generation,
+      ...(value.observationId !== undefined
+        ? { observationId: value.observationId }
+        : {}),
+      ...(value.renderWatermark !== undefined
+        ? { renderWatermark: value.renderWatermark }
+        : {}),
+      dependencies,
+    }
+  }
+
+  function normalizeDependency(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) return []
+    const required = (candidate) =>
+      typeof candidate === 'string' && candidate.trim().length > 0
+        ? candidate.trim()
+        : null
+    switch (value.kind) {
+      case 'document': {
+        const documentId = required(value.documentId)
+        if (!documentId) return []
+        return [{
+          kind: 'document',
+          documentId,
+          ...(required(value.storyType) ? { storyType: required(value.storyType) } : {}),
+          ...(required(value.reason) ? { reason: required(value.reason) } : {}),
+        }]
+      }
+      case 'asset': {
+        const assetId = required(value.assetId)
+        return assetId ? [{ kind: 'asset', assetId }] : []
+      }
+      case 'route-lookup': {
+        const pathname = required(value.pathname)
+        if (!pathname) return []
+        const storyTypes = Array.isArray(value.storyTypes)
+          ? [...new Set(value.storyTypes.filter((entry) => required(entry)).map((entry) => required(entry)))]
+          : []
+        return [{ kind: 'route-lookup', pathname, ...(storyTypes.length > 0 ? { storyTypes } : {}) }]
+      }
+      case 'list': {
+        const storyType = required(value.storyType)
+        if (!storyType) return []
+        const orderBy = value.orderBy &&
+          required(value.orderBy.field) &&
+          (value.orderBy.direction === 'asc' || value.orderBy.direction === 'desc')
+          ? { field: required(value.orderBy.field), direction: value.orderBy.direction }
+          : undefined
+        return [{
+          kind: 'list',
+          storyType,
+          ...(value.where !== undefined ? { where: value.where } : {}),
+          ...(orderBy ? { orderBy } : {}),
+          ...(typeof value.limit === 'number' && Number.isFinite(value.limit)
+            ? { limit: value.limit }
+            : {}),
+        }]
+      }
+      case 'get-by-slug':
+      case 'get-by-pathname': {
+        const storyType = required(value.storyType)
+        const field = value.kind === 'get-by-slug' ? 'slug' : 'pathname'
+        const target = required(value[field])
+        return storyType && target
+          ? [{ kind: value.kind, storyType, [field]: target }]
+          : []
+      }
+      case 'batch-get': {
+        if (!Array.isArray(value.documentIds)) return []
+        const documentIds = [...new Set(value.documentIds
+          .filter((entry) => required(entry))
+          .map((entry) => required(entry)))]
+        return documentIds.length > 0 ? [{ kind: 'batch-get', documentIds }] : []
+      }
+      case 'template': {
+        const templateId = required(value.templateId)
+        return templateId ? [{ kind: 'template', templateId }] : []
+      }
+      case 'custom-read': {
+        const key = required(value.key)
+        return key ? [{ kind: 'custom-read', key }] : []
+      }
+      default:
+        return []
+    }
+  }
+
+  function emptySidecar() {
+    return {
+      type: 'storystick.preview.public-sidecar',
+      version: 1,
+      routeHash: '',
+      codeVersion: '',
+      renderId: '',
+      generation: 0,
+      renderNonce: '',
+      routeRenderNonce: '',
+      emissionRevision: 0,
+      markers: [],
+    }
+  }
+
+  function normalizeText(value) {
+    return value
+      .normalize('NFKD')
+      .replace(/\p{Diacritic}/gu, '')
+      .replace(/[\u201c\u201d]/g, '"')
+      .replace(/[\u2018\u2019]/g, "'")
+      .replace(/\s+/g, ' ')
+      .trim()
+      .toLowerCase()
+  }
+
+  function fingerprintRenderedText(value) {
+    const normalized = normalizeText(value)
+    let hash = 0x811c9dc5
+    for (let index = 0; index < normalized.length; index++) {
+      hash ^= normalized.charCodeAt(index)
+      hash = Math.imul(hash, 0x01000193) >>> 0
+    }
+    return 'txt:' + normalized.length + ':' + hash.toString(36)
+  }
+
+  function compareSnapshotOrder(left, right) {
+    if (left.generation !== right.generation) {
+      return left.generation < right.generation ? -1 : 1
+    }
+    if (left.emissionRevision === right.emissionRevision) return 0
+    return left.emissionRevision < right.emissionRevision ? -1 : 1
+  }
+
+  function validSnapshot(snapshot) {
+    if (!snapshot || typeof snapshot !== 'object') return false
+    if (
+      snapshot.type !== 'storystick.preview.provenance-sidecar-snapshot' ||
+      snapshot.version !== 2 ||
+      typeof snapshot.sessionId !== 'string' || snapshot.sessionId.length === 0 ||
+      typeof snapshot.routeHash !== 'string' ||
+      typeof snapshot.codeVersion !== 'string' ||
+      typeof snapshot.renderId !== 'string' ||
+      typeof snapshot.renderNonce !== 'string' || snapshot.renderNonce.length === 0 ||
+      !Number.isFinite(snapshot.generation) || snapshot.generation <= 0 ||
+      !Number.isFinite(snapshot.emissionRevision) || snapshot.emissionRevision <= 0 ||
+      (snapshot.operation !== 'replace' && snapshot.operation !== 'tombstone') ||
+      snapshot.complete !== true ||
+      !Array.isArray(snapshot.expectedFrameIds) ||
+      !Array.isArray(snapshot.frames)
+    ) return false
+    if (snapshot.operation === 'tombstone') {
+      return snapshot.expectedFrameIds.length === 0 && snapshot.frames.length === 0
+    }
+    const expected = new Set(snapshot.expectedFrameIds)
+    if (expected.size !== snapshot.expectedFrameIds.length || !expected.has('route')) return false
+    const received = new Set()
+    for (const frame of snapshot.frames) {
+      if (!frame || typeof frame !== 'object' || typeof frame.frameId !== 'string') return false
+      if (received.has(frame.frameId)) return false
+      const sidecar = frame.sidecar
+      if (
+        !sidecar || typeof sidecar !== 'object' ||
+        sidecar.type !== 'storystick.preview.public-sidecar' ||
+        sidecar.version !== 1 ||
+        sidecar.codeVersion !== snapshot.codeVersion ||
+        !Array.isArray(sidecar.markers) ||
+        typeof sidecar.renderNonce !== 'string' || sidecar.renderNonce.length === 0 ||
+        !Number.isFinite(sidecar.emissionRevision) || sidecar.emissionRevision <= 0 ||
+        (frame.frameId === 'route' && (
+          sidecar.routeHash !== snapshot.routeHash ||
+          sidecar.renderId !== snapshot.renderId ||
+          sidecar.renderNonce !== snapshot.renderNonce
+        ))
+      ) return false
+      received.add(frame.frameId)
+    }
+    return received.size === expected.size && [...expected].every((id) => received.has(id))
+  }
+
+  function installSidecarStore() {
+    const existing = window.__ssPreviewProvenanceSidecarStoreV2
+    if (existing && existing.version === 2) return existing
+    let active = null
+    let latestAccepted = null
+    const store = {
+      version: 2,
+      accept(snapshot) {
+        if (!validSnapshot(snapshot)) return false
+        if (latestAccepted !== null) {
+          const order = compareSnapshotOrder(snapshot, latestAccepted)
+          if (order < 0) return false
+          if (order === 0) {
+            if (snapshot.renderNonce !== latestAccepted.renderNonce) return false
+            if (snapshot.operation === 'tombstone') return true
+          }
+        }
+        latestAccepted = snapshot
+        active = snapshot.operation === 'tombstone' ? null : snapshot
+        return true
+      },
+      readSnapshot: () => active,
+      readFrames: () => active ? active.frames : [],
+    }
+    window.__ssPreviewProvenanceSidecarStoreV2 = store
+    return store
+  }
+
+  const sidecarStore = installSidecarStore()
+
+  function readCarrier(value) {
+    if (typeof value !== 'string' || !value.startsWith('ssr1.')) return null
+    if (readCarrierCache.has(value)) return readCarrierCache.get(value)
+    const decoded = decodeReadCarrier(value)
+    const sidecar = decoded ? parseSidecar(JSON.stringify(decoded.sidecar)) : null
+    const frame = sidecar?.dependencySet && sidecar.markers.length === 1 &&
+      (!sidecar.dependencySet.readContext || sidecar.dependencySet.receiptIds?.length > 0)
+      ? { frameId: decoded.frameId, sidecar, primaryPage: decoded.primaryPage } : null
+    if (readCarrierCache.size >= 2048) readCarrierCache.delete(readCarrierCache.keys().next().value)
+    readCarrierCache.set(value, frame)
+    return frame
+  }
+
+  function normalizedCarrierMarkerId(value) {
+    return readCarrier(value)?.sidecar.markers[0].markerId || value
+  }
+
+  // Only explicitly encoded text/attributes participate. These frames describe
+  // what is in the DOM now, so removed branches need no React unmount publisher.
+  function collectReadCarrierFrames() {
+    observationStats.readCarrierScans += 1
+    const carriers = new Set()
+    const root = document.body || document.documentElement
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT)
+    let node = walker.nextNode()
+    while (node) {
+      if (node instanceof Text && node.data.includes(CODED_TEXT_START) &&
+        !node.parentElement?.closest('script,style,template,noscript,textarea,title,option')) {
+        // The closing delimiter can be in another text node (e.g. an <em>
+        // inside a heading). The complete prefix alone carries read identity.
+        let cursor = 0
+        while (cursor < node.data.length) {
+          const start = node.data.indexOf(CODED_TEXT_START, cursor)
+          if (start < 0) break
+          const separator = node.data.indexOf(CODED_TEXT_SEPARATOR, start + CODED_TEXT_START.length)
+          if (separator < 0) break
+          const id = decodeTagAscii(node.data.slice(start + CODED_TEXT_START.length, separator))
+          if (id.startsWith('ssr1.')) carriers.add(id)
+          cursor = separator + CODED_TEXT_SEPARATOR.length
+        }
+      }
+      node = walker.nextNode()
+    }
+    for (const element of document.querySelectorAll('[data-ss-e],[data-ss-p]')) {
+      for (const name of ['data-ss-e', 'data-ss-p']) {
+        const value = element.getAttribute(name)
+        if (value?.startsWith('ssr1.')) carriers.add(value)
+      }
+    }
+    const signature = [...carriers].sort().join('|')
+    if (signature === readCarrierSignature) return false
+    readCarrierSignature = signature
+    const frames = new Map()
+    primaryPageCandidates = []
+    for (const value of carriers) {
+      const frame = readCarrier(value)
+      if (!frame) continue
+      if (frame.primaryPage) primaryPageCandidates.push({ primaryPage: frame.primaryPage, dependencySet: frame.sidecar.dependencySet })
+      const existing = frames.get(frame.frameId)
+      const sidecar = !existing || frame.sidecar.emissionRevision > existing.sidecar.emissionRevision
+        ? frame.sidecar : existing.sidecar
+      const markers = new Map((existing?.sidecar.markers || []).map(marker => [marker.markerId, marker]))
+      for (const marker of frame.sidecar.markers) markers.set(marker.markerId, marker)
+      frames.set(frame.frameId, { frameId: frame.frameId, sidecar: { ...sidecar, markers: [...markers.values()] } })
+    }
+    readCarrierFrames = [...frames.values()]
+    return true
+  }
+
+  function readFrames() {
+    const stored = sidecarStore.readFrames().filter((frame) => matchesCurrentReadContext(frame.sidecar.dependencySet))
+    if (stored.length > 0) return stored
+    const framesById = new Map()
+    for (const script of document.querySelectorAll('script[data-ss-provenance-frame]')) {
+      const frameId = script.getAttribute('data-ss-provenance-frame') || ''
+      if (frameId.length === 0) continue
+      framesById.set(frameId, {
+        frameId,
+        sidecar: parseSidecar(script.textContent),
+      })
+    }
+    return Array.from(framesById.values())
+  }
+
+  function routeFrameHash() {
+    const storedRoute = sidecarStore.readFrames().find((frame) => frame.frameId === 'route')
+    if (storedRoute) return storedRoute.sidecar.routeHash
+    const route = document.querySelector('[data-ss-route-frame-hash]')
+    return route && route.getAttribute('data-ss-route-frame-hash') || ''
+  }
+
+  function parsePublisher(element) {
+    const raw = element.content && typeof element.content.textContent === 'string'
+      ? element.content.textContent
+      : element.textContent
+    if (typeof raw !== 'string' || raw.trim().length === 0) return null
+    try {
+      const publisher = JSON.parse(raw)
+      if (
+        !publisher || typeof publisher !== 'object' ||
+        publisher.type !== 'storystick.preview.provenance-publisher' ||
+        publisher.version !== 2 ||
+        !publisher.frame || typeof publisher.frame !== 'object' ||
+        typeof publisher.frame.frameId !== 'string' || publisher.frame.frameId.length === 0
+      ) return null
+      const sidecar = parseSidecar(JSON.stringify(publisher.frame.sidecar))
+      if (
+        sidecar.routeHash.length === 0 ||
+        sidecar.codeVersion.length === 0 ||
+        sidecar.renderId.length === 0 ||
+        sidecar.renderNonce.length === 0 ||
+        sidecar.generation <= 0 ||
+        sidecar.emissionRevision <= 0
+      ) return null
+      const dependencySet = sidecar.dependencySet
+      const boundSession = sessionId()
+      if (dependencySet?.readContext) {
+        if (!authenticatedReadContext() || !boundSession ||
+            !dependencySet.receiptIds?.length) return null
+        sidecar.dependencySet = { ...dependencySet, sessionId: boundSession }
+      } else if (typeof publisher.sessionId !== 'string' || !publisher.sessionId) return null
+      return {
+        sessionId: dependencySet?.readContext ? boundSession : publisher.sessionId,
+        frame: { frameId: publisher.frame.frameId, sidecar },
+      }
+    } catch {
+      return null
+    }
+  }
+
+  function publisherConsumptionKey(frame) {
+    return JSON.stringify([frame.frameId, frame.sidecar.renderNonce])
+  }
+
+  function acknowledgePublisherConsumption(frame) {
+    const publisherKey = publisherConsumptionKey(frame)
+    const current = window[PUBLISHER_CONSUMED_REGISTRY]
+    const registry = current && typeof current === 'object' ? current : {}
+    registry[publisherKey] = true
+    const keys = Object.keys(registry)
+    for (let index = 0; index < keys.length - 128; index++) {
+      delete registry[keys[index]]
+    }
+    window[PUBLISHER_CONSUMED_REGISTRY] = registry
+    try {
+      window.dispatchEvent(new CustomEvent(PUBLISHER_CONSUMED_EVENT, {
+        detail: { publisherKey },
+      }))
+    } catch {
+      // The registry is the durable acknowledgement if CustomEvent is absent.
+    }
+  }
+
+  function publisherFrameIsNewer(next, current) {
+    if (!current) return true
+    if (next.sidecar.generation !== current.sidecar.generation) {
+      return next.sidecar.generation > current.sidecar.generation
+    }
+    if (next.sidecar.emissionRevision !== current.sidecar.emissionRevision) {
+      return next.sidecar.emissionRevision > current.sidecar.emissionRevision
+    }
+    return false
+  }
+
+  function publishRenderedContext(readContext) {
+    const detail = { sessionId: sessionId(), readContext }
+    const key = JSON.stringify(detail)
+    if (key === lastRenderedContextKey) return
+    lastRenderedContextKey = key
+    window.dispatchEvent(new CustomEvent('storystick.preview.rendered-context', { detail }))
+  }
+
+  // Read navigation metadata independently of overlay readiness/convergence.
+  function currentPrimaryPages() {
+    return authenticatedReadContext() ? primaryPageCandidates.filter(candidate =>
+      candidate.dependencySet?.readContext && matchesCurrentReadContext(candidate.dependencySet))
+      .map(candidate => candidate.primaryPage) : []
+  }
+
+  function publishPrimaryPages() {
+    const context = authenticatedReadContext()
+    const pages = currentPrimaryPages()
+    const detail = { sessionId: sessionId(), readContext: context,
+      pathname: window.location.pathname, pages }
+    const key = JSON.stringify(detail)
+    if (key === lastPrimaryPagesKey) return
+    lastPrimaryPagesKey = key
+    window.__ssPreviewPrimaryPages = detail
+    window.dispatchEvent(new CustomEvent('storystick.preview.primary-pages', { detail }))
+  }
+
+  // Capsules are acknowledged synchronously so their React owner can retire
+  // them. A repeated reconciliation can reuse the last carrier observation
+  // until the document changes; it never caches geometry across passes.
+  function consumeProvenancePublishers() {
+    let changed = false
+    for (const element of document.querySelectorAll('template[data-ss-provenance-publisher]')) {
+      if (consumedPublisherElements.has(element)) continue
+      const publisher = parsePublisher(element)
+      // An unbound server capsule waits for authenticated browser identity.
+      if (publisher === null) continue
+      consumedPublisherElements.add(element)
+      if (element.getAttribute('data-ss-provenance-react-owned') !== 'true') {
+        element.remove()
+      }
+      if (publisher === null) continue
+      const frame = publisher.frame
+      acknowledgePublisherConsumption(frame)
+      if (
+        frame.frameId.startsWith('slice_') &&
+        (
+          activePublisherRoute === null ||
+          publisher.sessionId !== activePublisherRoute.sessionId ||
+          frame.sidecar.routeHash !== activePublisherRoute.routeHash ||
+          frame.sidecar.generation !== activePublisherRoute.generation ||
+          frame.sidecar.codeVersion !== activePublisherRoute.codeVersion ||
+          frame.sidecar.routeRenderNonce !== activePublisherRoute.renderNonce
+        )
+      ) {
+        continue
+      }
+      const current = publisherFramesById.get(frame.frameId)
+      if (!publisherFrameIsNewer(frame, current)) continue
+      if (frame.frameId === 'route') {
+        const routeChanged = activePublisherRoute === null ||
+          activePublisherRoute.renderNonce !== frame.sidecar.renderNonce
+        if (routeChanged) {
+          const oldRouteHash = activePublisherRoute && activePublisherRoute.routeHash
+          if (oldRouteHash) {
+            for (const [frameId, registered] of publisherFramesById) {
+              if (registered.sidecar.routeHash === oldRouteHash) {
+                publisherFramesById.delete(frameId)
+              }
+            }
+          }
+          const activationGeneration = Math.max(
+            currentRenderIdentity.generation,
+            frame.sidecar.generation,
+          )
+          const activationRevision = Math.max(
+            lastPublisherRevision + 1,
+            frame.sidecar.emissionRevision,
+          )
+          sidecarStore.accept({
+            type: 'storystick.preview.provenance-sidecar-snapshot',
+            version: 2,
+            sessionId: publisher.sessionId,
+            routeHash: frame.sidecar.routeHash,
+            codeVersion: frame.sidecar.codeVersion,
+            variantId: normalizeVariantId(frame.sidecar.variantId),
+            renderId: frame.sidecar.renderId,
+            renderNonce: frame.sidecar.renderNonce,
+            generation: activationGeneration,
+            emissionRevision: activationRevision,
+            operation: 'tombstone',
+            complete: true,
+            expectedFrameIds: [],
+            frames: [],
+          })
+          lastPublisherRevision = activationRevision
+          activePublisherRoute = {
+            sessionId: publisher.sessionId,
+            routeHash: frame.sidecar.routeHash,
+            renderNonce: frame.sidecar.renderNonce,
+            generation: frame.sidecar.generation,
+            codeVersion: frame.sidecar.codeVersion,
+          }
+        }
+      }
+      publisherFramesById.set(frame.frameId, frame)
+      changed = true
+    }
+    if (changed) publisherSnapshotDirty = true
+  }
+
+  function reconcileProvenancePublishers() {
+    // A context/probe event may arrive before MutationObserver delivery.
+    // Consume its pending facts before deciding whether the carrier sample is
+    // still current. The caller already owns scheduling the observation pass.
+    const pendingMutations = provenanceObserver ? provenanceObserver.takeRecords() : []
+    if (pendingMutations.some(invalidatesReadCarriers)) {
+      readCarriersDirty = true
+    }
+    if (readCarriersDirty) {
+      readCarriersDirty = false
+      if (collectReadCarrierFrames()) publisherSnapshotDirty = true
+    }
+    consumeProvenancePublishers()
+    // Navigation metadata remains independent of anchor/overlay readiness.
+    publishPrimaryPages()
+    if (!publisherSnapshotDirty) return
+    publisherSnapshotDirty = false
+    // A refresh may stream the page before its persistent layouts. Keep the
+    // whole view read-only until every mounted read has the accepted context;
+    // filtering old occurrences individually would make a mixed view editable.
+    const mounted = [...publisherFramesById.values(), ...readCarrierFrames]
+    const pendingReadContext = mounted.some((frame) =>
+      frame.sidecar.dependencySet?.readContext && !matchesCurrentReadContext(frame.sidecar.dependencySet))
+    const occurrences = (pendingReadContext ? [] : mounted)
+      .filter((frame) => matchesCurrentReadContext(frame.sidecar.dependencySet))
+      .map((frame) => frame.sidecar.dependencySet?.readContext ? {
+        ...frame, sidecar: { ...frame.sidecar, dependencySet: {
+          ...frame.sidecar.dependencySet, sessionId: sessionId(),
+        } },
+      } : frame)
+    let routeFrame = occurrences.find((frame) => frame.frameId === 'route')
+    if (routeFrame?.sidecar.dependencySet?.readContext && activePublisherRoute) {
+      activePublisherRoute = { ...activePublisherRoute, sessionId: sessionId() }
+    }
+    if (!routeFrame && occurrences.length > 0) {
+      // Native pages need no CMS document. This empty view anchor supplies
+      // navigation identity; read/edit authority stays with mounted occurrences.
+      const currentContext = authenticatedReadContext()
+      const candidates = occurrences.filter((frame) => frame.sidecar.dependencySet?.readContext
+        ? matchesCurrentReadContext(frame.sidecar.dependencySet)
+        : frame.sidecar.dependencySet?.sessionId === sessionId())
+      const first = candidates[0]
+      if (first && currentContext && sessionId()) {
+        const key = JSON.stringify([window.location.pathname, window.location.search,
+          sessionId(), currentContext.contextId, currentContext.revision, first.sidecar.codeVersion])
+        if (nativeViewAnchor?.key !== key) {
+          const bytes = crypto.getRandomValues(new Uint8Array(16))
+          const nonce = Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('')
+          nativeViewAnchor = { key, nonce: 'view:' + nonce, revision: Date.now() * 1000 }
+        }
+        const routeHash = 'view:' + window.location.pathname
+        const renderId = nativeViewAnchor.nonce
+        const generation = Math.max(1, currentRenderIdentity.generation)
+        const receiptIds = [...new Set(candidates.flatMap((frame) => frame.sidecar.dependencySet.receiptIds || []))]
+        routeFrame = { frameId: 'route', sidecar: {
+          type: 'storystick.preview.public-sidecar', version: 1,
+          routeHash, codeVersion: first.sidecar.codeVersion, renderId,
+          renderNonce: nativeViewAnchor.nonce, generation, emissionRevision: nativeViewAnchor.revision,
+          ...(currentContext.perspective.kind === 'variant' ? { variantId: currentContext.perspective.variantId } : {}),
+          ...(first.sidecar.previewScope ? { previewScope: first.sidecar.previewScope } : {}),
+          markers: [],
+          dependencySet: { type: 'storystick.preview.frame-dependency-set', version: 1,
+            sessionId: sessionId(), readContext: currentContext, receiptIds,
+            routeHash, codeVersion: first.sidecar.codeVersion, frameId: 'route', renderId, generation,
+            ...(candidates.every((frame) => Number.isFinite(frame.sidecar.dependencySet.renderWatermark))
+              ? { renderWatermark: Math.min(...candidates.map((frame) => frame.sidecar.dependencySet.renderWatermark)) } : {}),
+            ...(currentContext.perspective.kind === 'variant' ? { variantId: currentContext.perspective.variantId } : {}),
+            dependencies: [],
+          },
+        } }
+        activePublisherRoute = { sessionId: sessionId(), routeHash,
+          renderNonce: nativeViewAnchor.nonce, generation, codeVersion: first.sidecar.codeVersion }
+      }
+    }
+    if (!routeFrame || !activePublisherRoute || routeFrame.sidecar.renderNonce !== activePublisherRoute.renderNonce) {
+      publishRenderedContext(null)
+      const previous = lastPublishedSnapshot ?? sidecarStore.readSnapshot()
+      if (previous) {
+        const tombstone = { ...previous, operation: 'tombstone', expectedFrameIds: [], frames: [],
+          generation: Math.max(previous.generation, currentRenderIdentity.generation),
+          emissionRevision: Math.max(lastPublisherRevision + 1, previous.emissionRevision + 1) }
+        lastPublishedSnapshot = tombstone
+        lastPublisherRevision = tombstone.emissionRevision
+        sidecarStore.accept(tombstone)
+        if (window.parent && window.parent !== window) window.parent.postMessage(tombstone, studioTargetOrigin())
+      }
+      return
+    }
+    const frames = [routeFrame, ...occurrences.filter((frame) => frame.frameId !== 'route')]
+      .filter((frame) =>
+        frame.sidecar.codeVersion === routeFrame.sidecar.codeVersion &&
+        (!frame.frameId.startsWith('slice_') ||
+          (frame.sidecar.routeHash === routeFrame.sidecar.routeHash &&
+            frame.sidecar.generation === routeFrame.sidecar.generation &&
+            frame.sidecar.routeRenderNonce === routeFrame.sidecar.renderNonce))
+      )
+      .sort((left, right) => left.frameId.localeCompare(right.frameId))
+    const emissionRevision = Math.max(
+      lastPublisherRevision + 1,
+      ...frames.map((frame) => frame.sidecar.emissionRevision),
+    )
+    lastPublisherRevision = emissionRevision
+    const snapshot = {
+      type: 'storystick.preview.provenance-sidecar-snapshot',
+      version: 2,
+      sessionId: activePublisherRoute.sessionId,
+      routeHash: routeFrame.sidecar.routeHash,
+      codeVersion: routeFrame.sidecar.codeVersion,
+      variantId: normalizeVariantId(routeFrame.sidecar.variantId),
+      renderId: routeFrame.sidecar.renderId,
+      renderNonce: routeFrame.sidecar.renderNonce,
+      generation: Math.max(currentRenderIdentity.generation, routeFrame.sidecar.generation),
+      emissionRevision,
+      operation: 'replace',
+      complete: true,
+      expectedFrameIds: frames.map((frame) => frame.frameId),
+      frames,
+    }
+    if (!validSnapshot(snapshot)) return
+    lastPublishedSnapshot = snapshot
+    publishRenderedContext(authenticatedReadContext())
+    // In Studio, the parent validates and echoes this snapshot before the
+    // reporter consumes it. A top-level preview has no parent relay, so the
+    // same validated server-backed snapshot must enter the same local store
+    // directly. The anchor-map builder then reads one authority in both hosts.
+    if (!window.parent || window.parent === window) {
+      sidecarStore.accept(snapshot)
+      return
+    }
+    window.parent.postMessage(snapshot, studioTargetOrigin())
+  }
+
+  function sessionId() {
+    const state = window.__storystick_preview_runtime__?.state
+    if (state) {
+      if (state.previewEnded) return ''
+      return typeof state.identity?.sessionId === 'string' ? state.identity.sessionId : ''
+    }
+    return (document.body && document.body.getAttribute('data-preview-message-session-id')) ||
+      document.documentElement.getAttribute('data-preview-message-session-id') ||
+      (document.querySelector('[data-preview-message-session-id]') &&
+        document.querySelector('[data-preview-message-session-id]').getAttribute('data-preview-message-session-id')) ||
+      (activePublisherRoute && activePublisherRoute.sessionId) ||
+      ''
+  }
+
+  function normalizeVariantId(value) {
+    if (typeof value !== 'string') return null
+    const trimmed = value.trim()
+    return trimmed.length > 0 ? trimmed : null
+  }
+
+  function previewScopeFromRuntimeStore() {
+    const store = window.__storystick_preview_runtime__
+    if (!store || typeof store !== 'object') return null
+    const state = store.state
+    if (!state || typeof state !== 'object') return null
+    const variantId = normalizeVariantId(state.variantId)
+    const releaseId = normalizeVariantId(state.releaseId)
+    if (variantId && !releaseId) return { kind: 'variant', id: variantId }
+    if (releaseId && !variantId) return { kind: 'release', id: releaseId }
+    return null
+  }
+
+  function activePreviewScope() {
+    return previewScopeFromRuntimeStore()
+  }
+
+  function activeVariantId() {
+    const scope = activePreviewScope()
+    return scope && scope.kind === 'variant' ? scope.id : null
+  }
+
+  function isMomentaryNavigateKeyDown(event) {
+    if (event.key !== 'Alt') return false
+    if (!event.altKey) return false
+    if (event.ctrlKey || event.metaKey) return false
+    if (typeof event.getModifierState === 'function' && event.getModifierState('AltGraph')) return false
+    return true
+  }
+
+  function emitMomentaryNavigateKey(active) {
+    if (lastMomentaryNavigateKeyActive === active) return
+    lastMomentaryNavigateKeyActive = active
+    window.parent.postMessage({
+      type: 'storystick.preview.momentary-navigate-key',
+      key: 'Alt',
+      active,
+    }, studioTargetOrigin())
+  }
+
+  function normalizeMomentaryNavigateLinkClick(event, target) {
+    if (!shouldNormalizeMomentaryNavigateLinkClick(event, target)) return false
+    event.preventDefault()
+    event.stopImmediatePropagation()
+    target.click()
+    return true
+  }
+
+  function shouldNormalizeMomentaryNavigateLinkClick(event, target) {
+    if (event.defaultPrevented) return false
+    if (event.button !== 0) return false
+    if (!event.altKey) return false
+    if (event.ctrlKey || event.metaKey || event.shiftKey) return false
+    if (target.hasAttribute('download')) return false
+    try {
+      return new URL(target.href, window.location.href).origin === window.location.origin
+    } catch {
+      return false
+    }
+  }
+
+  function topLevelRouteHash(frames, domRouteHash) {
+    return domRouteHash ||
+      (frames.find((frame) => frame.frameId === 'route') || { sidecar: emptySidecar() }).sidecar.routeHash ||
+      ''
+  }
+
+  function topLevelCodeVersion(frames) {
+    const routeFrame = frames.find((frame) => frame.frameId === 'route')
+    if (routeFrame && routeFrame.sidecar.codeVersion.length > 0) return routeFrame.sidecar.codeVersion
+    const frameWithCodeVersion = frames.find((frame) => frame.sidecar.codeVersion.length > 0)
+    return frameWithCodeVersion ? frameWithCodeVersion.sidecar.codeVersion : ''
+  }
+
+  function collectAnchors(frames = readFrames()) {
+    observationStats.anchorCollections += 1
+    prunePaintTargets()
+    if (hydrationSafeDomMaterializationEnabled) {
+      materializeCodedTextAttributeCarriers(frames)
+    }
+    const codedTextAnchors = collectCodedTextAnchors(frames)
+    const attributeElements = [...document.querySelectorAll('[data-ss-e],[data-ss-p]')]
+    return {
+      anchors: [...codedTextAnchors, ...collectAttributeAnchors(attributeElements)],
+      markerCount: codedTextAnchors.length + attributeElements.length,
+    }
+  }
+
+  function scheduleHydrationSafeDomMaterialization() {
+    if (!documentActive || hydrationSafeDomMaterializationEnabled || hydrationSafeDomMaterializationScheduled) return
+    hydrationSafeDomMaterializationScheduled = true
+    const enableAfterHydrationTurn = () => {
+      hydrationLoadListener = null
+      hydrationTimer = setTimeout(() => {
+        hydrationTimer = null
+        if (!documentActive) return
+        hydrationFrame = requestAnimationFrame(() => {
+          hydrationFrame = null
+          if (!documentActive) return
+          hydrationFrame = requestAnimationFrame(() => {
+            hydrationFrame = null
+            if (!documentActive) return
+            hydrationTimer = setTimeout(() => {
+              hydrationTimer = null
+              if (!documentActive) return
+              hydrationSafeDomMaterializationEnabled = true
+              scheduleReady('hydration-safe-dom:' + window.location.pathname)
+            }, 0)
+          })
+        })
+      }, domHydrationGraceMs())
+    }
+    if (document.readyState !== 'complete') {
+      hydrationLoadListener = enableAfterHydrationTurn
+      window.addEventListener('load', enableAfterHydrationTurn, { once: true })
+    } else {
+      enableAfterHydrationTurn()
+    }
+  }
+
+  function domHydrationGraceMs() {
+    const value = window.__ssPreviewProvenanceHydrationGraceMs
+    return Number.isFinite(value) && value >= 0
+      ? value
+      : DOM_HYDRATION_GRACE_MS
+  }
+
+  // DOM-native provenance materialization: coded text is the identity carrier,
+  // but overlays paint only real [data-ss-p] elements. Promote only when a
+  // single sidecar-backed element marker owns the element's text surface.
+  function materializeCodedTextAttributeCarriers(frames) {
+    const root = document.body || document.documentElement
+    if (!root) return false
+    const eligibleMarkerIds = elementMarkerIdsBySidecar(frames)
+    if (eligibleMarkerIds.size === 0) return false
+    let materialized = false
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT)
+    let node = walker.nextNode()
+    while (node) {
+      if (node instanceof Text && node.data.includes(CODED_TEXT_START)) {
+        materialized =
+          materializeCodedTextNodeAttributeCarrier(node, eligibleMarkerIds) ||
+          materialized
+      }
+      node = walker.nextNode()
+    }
+    return materialized
+  }
+
+  function elementMarkerIdsBySidecar(frames) {
+    const markerIds = new Set()
+    for (const frame of frames) {
+      for (const marker of frame.sidecar.markers) {
+        if (marker.anchorKind === 'element') markerIds.add(marker.markerId)
+      }
+    }
+    return markerIds
+  }
+
+  function materializeCodedTextNodeAttributeCarrier(node, eligibleMarkerIds) {
+    let element = node.parentElement
+    while (element) {
+      if (element.closest('script,style,template,noscript,textarea,title,option')) return false
+      if (element === document.body || element === document.documentElement) return false
+      const decoded = decodeCodedText(element.textContent || '')
+      const markerId = singleEligibleDecodedMarkerId(decoded, eligibleMarkerIds)
+      if (markerId !== null) {
+        return writeCodedTextAttributeCarrier(element, markerId)
+      }
+      if (decoded.segments.length > 0) return false
+      element = element.parentElement
+    }
+    return false
+  }
+
+  function singleEligibleDecodedMarkerId(decoded, eligibleMarkerIds) {
+    if (decoded.segments.length !== 1) return null
+    const markerId = decoded.segments[0] && decoded.segments[0].markerId || ''
+    return eligibleMarkerIds.has(markerId) ? markerId : null
+  }
+
+  function writeCodedTextAttributeCarrier(element, markerId) {
+    // Autonomous values use the memory paint registry. React owns this ordinary
+    // element; leaving synthetic attrs behind would outlive the coded text.
+    if (decodeCodedText(element.textContent || '').segments.some(segment => segment.carrierId.startsWith('ssr1.'))) return false
+    if (element.hasAttribute('data-ss-e') || element.querySelector('[data-ss-e]') !== null) return false
+    const existing = normalizedCarrierMarkerId(element.getAttribute('data-ss-p'))
+    if (existing === markerId) return false
+    if (element.querySelector('[data-ss-p]') !== null) return false
+    if (existing !== null && !isStaleCodedTextAttributeCarrier(element, markerId)) return false
+    element.setAttribute('data-ss-p', markerId)
+    return true
+  }
+
+  function isStaleCodedTextAttributeCarrier(element, markerId) {
+    const decoded = decodeCodedText(element.textContent || '')
+    return decoded.segments.length === 1 &&
+      ((decoded.segments[0] && decoded.segments[0].markerId) || '') === markerId
+  }
+
+  function collectAttributeAnchors(elements) {
+    return elements.flatMap((element) => {
+      const rect = element.getBoundingClientRect()
+      const elementMarkerId = element.getAttribute('data-ss-e')
+      const markerId = normalizedCarrierMarkerId(elementMarkerId !== null
+        ? elementMarkerId
+        : element.getAttribute('data-ss-p') || '')
+      if (elementMarkerId === null && isSupersededCodedTextAttributeCarrier(element, markerId)) {
+        return []
+      }
+      return [{
+        markerId,
+        paintId: ensurePaintId(element, markerId),
+        tagName: element.tagName,
+        text: elementMarkerId !== null
+          ? ''
+          : decodeCodedText(element.textContent || '').text,
+        connected: element.isConnected,
+        carrier: 'attribute',
+        documentRect: {
+          x: rect.left + window.scrollX,
+          y: rect.top + window.scrollY,
+          width: rect.width,
+          height: rect.height,
+        },
+      }]
+    })
+  }
+
+  function isSupersededCodedTextAttributeCarrier(element, markerId) {
+    const decoded = decodeCodedText(element.textContent || '')
+    if (decoded.segments.length !== 1) return false
+    const decodedMarkerId = (decoded.segments[0] && decoded.segments[0].markerId) || ''
+    return decodedMarkerId.length > 0 && decodedMarkerId !== markerId
+  }
+
+  function canStampPaintId(element) {
+    return hydrationSafeDomMaterializationEnabled &&
+      (element.hasAttribute('data-ss-e') || element.hasAttribute('data-ss-p'))
+  }
+
+  function ensurePaintId(element, markerId) {
+    if (typeof markerId !== 'string' || markerId.length === 0) return undefined
+    const knownPaintId = paintIdByElement.get(element)
+    if (typeof knownPaintId === 'string') {
+      registerPaintTarget(knownPaintId, markerId, element)
+      if (
+        canStampPaintId(element) &&
+        element.getAttribute(PAINT_ID_ATTRIBUTE) !== knownPaintId
+      ) {
+        element.setAttribute(PAINT_ID_ATTRIBUTE, knownPaintId)
+      }
+      return knownPaintId
+    }
+    const paintId = 'paint:' + nextPaintId
+    nextPaintId += 1
+    paintIdByElement.set(element, paintId)
+    registerPaintTarget(paintId, markerId, element)
+    if (canStampPaintId(element)) {
+      element.setAttribute(PAINT_ID_ATTRIBUTE, paintId)
+    }
+    return paintId
+  }
+
+  function registerPaintTarget(paintId, markerId, element) {
+    paintTargetById.set(paintId, {
+      markerId,
+      elementRef: typeof WeakRef === 'function' ? new WeakRef(element) : element,
+    })
+  }
+
+  function prunePaintTargets() {
+    for (const [paintId, entry] of paintTargetById) {
+      const element = entry.elementRef && typeof entry.elementRef.deref === 'function'
+        ? entry.elementRef.deref()
+        : entry.elementRef
+      if (!(element instanceof Element) || !element.isConnected) {
+        paintTargetById.delete(paintId)
+      }
+    }
+  }
+
+  function resolvePaintTarget(paintId) {
+    const entry = paintTargetById.get(paintId)
+    if (!entry) return null
+    const element = entry.elementRef && typeof entry.elementRef.deref === 'function'
+      ? entry.elementRef.deref()
+      : entry.elementRef
+    if (!(element instanceof Element) || !element.isConnected) {
+      paintTargetById.delete(paintId)
+      return null
+    }
+    return { element, markerId: entry.markerId }
+  }
+
+  function teardownPaintIdentityStamps() {
+    documentActive = false
+    cancelEpoch += 1
+    pendingNavigationEpoch = null
+    cancelReadyObservation()
+    if (viewportFrame !== null) cancelAnimationFrame(viewportFrame)
+    viewportFrame = null
+    if (hydrationFrame !== null) cancelAnimationFrame(hydrationFrame)
+    hydrationFrame = null
+    if (hydrationTimer !== null) clearTimeout(hydrationTimer)
+    hydrationTimer = null
+    if (hydrationLoadListener !== null) window.removeEventListener('load', hydrationLoadListener)
+    hydrationLoadListener = null
+    hydrationSafeDomMaterializationScheduled = false
+    if (provenanceObserver) provenanceObserver.disconnect()
+    for (const element of document.querySelectorAll('[' + PAINT_ID_ATTRIBUTE + ']')) {
+      element.removeAttribute(PAINT_ID_ATTRIBUTE)
+    }
+  }
+
+  function restorePaintIdentityStampsFromBackForwardCache(event) {
+    if (!event.persisted || !provenanceObserver) return
+    documentActive = true
+    readCarriersDirty = true
+    publisherSnapshotDirty = true
+    provenanceObserver.observe(document.documentElement, PROVENANCE_OBSERVER_OPTIONS)
+    scheduleHydrationSafeDomMaterialization()
+    scheduleReady('pageshow:' + window.location.pathname)
+  }
+
+  function collectCodedTextAnchors(frames = readFrames()) {
+    observationStats.codedTextScans += 1
+    const root = document.body || document.documentElement
+    if (!root) return []
+    const anchors = []
+    const seenElements = new WeakMap()
+    const eligibleMarkerIds = elementMarkerIdsBySidecar(frames)
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT)
+    let node = walker.nextNode()
+    while (node) {
+      if (node instanceof Text && node.data.includes(CODED_TEXT_START)) {
+        const directAnchors = anchorsForCodedTextNode(node, eligibleMarkerIds)
+        if (directAnchors.length > 0) {
+          for (const anchor of directAnchors) {
+            const seen = seenElements.get(anchor.element) || new Set()
+            if (seen.has(anchor.markerId)) continue
+            seen.add(anchor.markerId)
+            seenElements.set(anchor.element, seen)
+            const { element, ...publicAnchor } = anchor
+            anchors.push(publicAnchor)
+          }
+        } else {
+          for (const anchor of anchorsForSpanningCodedTextNode(node, eligibleMarkerIds)) {
+            const seen = seenElements.get(anchor.element) || new Set()
+            if (seen.has(anchor.markerId)) continue
+            seen.add(anchor.markerId)
+            seenElements.set(anchor.element, seen)
+            const { element, ...publicAnchor } = anchor
+            anchors.push(publicAnchor)
+          }
+        }
+      }
+      node = walker.nextNode()
+    }
+    return anchors
+  }
+
+  function currentDocumentViewport() {
+    return {
+      x: window.scrollX,
+      y: window.scrollY,
+      width: window.innerWidth,
+      height: window.innerHeight,
+    }
+  }
+
+  function anchorsForCodedTextNode(node, eligibleMarkerIds) {
+    const parent = node.parentElement
+    if (!parent || parent.closest('script,style,template,noscript,textarea,title,option')) return []
+    const decoded = decodeCodedText(node.data)
+    const paintId = codedTextPaintId(parent, decoded, eligibleMarkerIds)
+    const anchors = decoded.segments.map((segment) => {
+      // A paintId already identifies this exact, unambiguous element. Publish
+      // the same box the painter measures; invisible metadata can distort
+      // browser Range geometry even when the element renders correctly.
+      const rect = paintId
+        ? parent.getBoundingClientRect()
+        : rectForTextRange(node, segment.textStart, segment.textEnd) || parent.getBoundingClientRect()
+      return {
+        markerId: segment.markerId,
+        element: parent,
+        ...(decoded.segments.length === 1 && paintId ? { paintId } : {}),
+        tagName: parent.tagName,
+        text: segment.text,
+        connected: node.isConnected && parent.isConnected,
+        carrier: 'coded-text',
+        documentRect: {
+          x: rect.left + window.scrollX,
+          y: rect.top + window.scrollY,
+          width: rect.width,
+          height: rect.height,
+        },
+      }
+    })
+    return anchors.filter((anchor) =>
+      !hasMatchingAttributeCarrier(parent, anchor.markerId)
+    )
+  }
+
+  function anchorsForSpanningCodedTextNode(node, eligibleMarkerIds) {
+    let element = node.parentElement
+    while (element) {
+      if (element.closest('script,style,template,noscript,textarea,title,option')) return []
+      const decoded = decodeCodedText(element.textContent || '')
+      if (decoded.segments.length > 0) {
+        const segments = decoded.segments.filter((segment) =>
+          !hasMatchingAttributeCarrier(element, segment.markerId)
+        )
+        if (segments.length === 0) return []
+        const rect = element.getBoundingClientRect()
+        const paintId = codedTextPaintId(element, decoded, eligibleMarkerIds)
+        return segments.map((segment) => ({
+          markerId: segment.markerId,
+          element,
+          ...(segments.length === 1 && paintId ? { paintId } : {}),
+          tagName: element.tagName,
+          text: segment.text,
+          connected: node.isConnected && element.isConnected,
+          carrier: 'coded-text',
+          documentRect: {
+            x: rect.left + window.scrollX,
+            y: rect.top + window.scrollY,
+            width: rect.width,
+            height: rect.height,
+          },
+        }))
+      }
+      element = element.parentElement
+    }
+    return []
+  }
+
+  function hasMatchingAttributeCarrier(element, markerId) {
+    return normalizedCarrierMarkerId(element.getAttribute('data-ss-p')) === markerId
+  }
+
+  function codedTextPaintId(element, decoded, eligibleMarkerIds) {
+    if (decoded.segments.length !== 1) return undefined
+    const markerId = (decoded.segments[0] && decoded.segments[0].markerId) || ''
+    if (!eligibleMarkerIds.has(markerId)) return undefined
+    // A text node is not an element boundary. Inline rich text can put
+    // independently owned nodes on both sides of a link in the same <p>.
+    // Painting that parent for both would reuse its paint ID, overwrite the
+    // registry owner and prevent the entire overlay map from being confirmed.
+    // Keep their text provenance, but only promote an unambiguous element.
+    if (decodeCodedText(element.textContent || '').segments.some((segment) =>
+      segment.markerId !== markerId
+    )) return undefined
+    if (element.hasAttribute('data-ss-e') || element.querySelector('[data-ss-e]') !== null) {
+      return undefined
+    }
+    if (element.querySelector('[data-ss-p]') !== null) return undefined
+    const existing = normalizedCarrierMarkerId(element.getAttribute('data-ss-p'))
+    if (
+      existing !== null &&
+      existing !== markerId &&
+      !isStaleCodedTextAttributeCarrier(element, markerId)
+    ) {
+      return undefined
+    }
+    return ensurePaintId(element, markerId)
+  }
+
+  function rectForTextRange(node, start, end) {
+    if (start >= end || typeof document.createRange !== 'function') return null
+    const range = document.createRange()
+    try {
+      range.setStart(node, start)
+      range.setEnd(node, end)
+      return typeof range.getBoundingClientRect === 'function'
+        ? range.getBoundingClientRect()
+        : null
+    } catch {
+      return null
+    } finally {
+      range.detach()
+    }
+  }
+
+  function buildMap(pathname, domRouteHash, frame, anchors, invalidMarkerIds, duplicateSidecarMarkerIds, phase, pending, lifecycle) {
+    const sidecarMarkers = new Map(frame.sidecar.markers.map((marker) => [marker.markerId, marker]))
+    const sidecarMarkerIds = new Set(sidecarMarkers.keys())
+    const rawAnchors = anchors.filter((anchor) => anchor.markerId.length > 0)
+    const counts = new Map()
+    for (const anchor of rawAnchors) counts.set(anchor.markerId, (counts.get(anchor.markerId) || 0) + 1)
+
+    const observedMarkerIds = new Set(rawAnchors.map((anchor) => anchor.markerId))
+    const localInvalidMarkerIds = rawAnchors
+      .filter((anchor) => !sidecarMarkerIds.has(anchor.markerId))
+      .map((anchor) => anchor.markerId)
+    const unpaintedMarkerIds = [...sidecarMarkerIds].filter((markerId) =>
+      !observedMarkerIds.has(markerId)
+    )
+    const missingMarkerIds = [...sidecarMarkerIds].filter((markerId) =>
+      !observedMarkerIds.has(markerId) && isRequiredMarker(markerId, sidecarMarkers)
+    )
+    const ambiguousMarkerIds = [...counts.entries()]
+      .filter(([markerId, count]) => count > 1 && !allowsMultipleAnchors(markerId, sidecarMarkers))
+      .map(([markerId]) => markerId)
+    const contentMismatchMarkerIds = rawAnchors
+      .filter((anchor) => {
+        const marker = sidecarMarkers.get(anchor.markerId)
+        const renderedTextFingerprint = fingerprintRenderedText(anchor.text)
+        return marker &&
+          marker.renderedTextFingerprint !== undefined &&
+          marker.renderedTextFingerprint !== renderedTextFingerprint
+      })
+      .map((anchor) => anchor.markerId)
+    const contentMismatchMarkerIdSet = new Set(contentMismatchMarkerIds)
+    const fatalContentMismatchMarkerIds = [...contentMismatchMarkerIdSet]
+      .filter((markerId) => isRequiredMarker(markerId, sidecarMarkers))
+    const mergedInvalidMarkerIds = [...new Set([...localInvalidMarkerIds, ...invalidMarkerIds])]
+    const routeReady = frame.frameId !== 'route' || domRouteHash === frame.sidecar.routeHash
+    const sidecarVariantId = normalizeVariantId(frame.sidecar.variantId)
+
+    const resolvedAnchors = rawAnchors.filter((anchor) =>
+      anchor.connected &&
+      sidecarMarkerIds.has(anchor.markerId) &&
+      ((counts.get(anchor.markerId) || 0) === 1 || allowsMultipleAnchors(anchor.markerId, sidecarMarkers)) &&
+      !contentMismatchMarkerIdSet.has(anchor.markerId)
+    )
+    const codedTextMarkerIds = new Set(
+      resolvedAnchors
+        .filter((anchor) => anchor.carrier === 'coded-text')
+        .map((anchor) => anchor.markerId)
+    )
+    const domMarkerIds = new Set(
+      resolvedAnchors
+        .filter((anchor) => typeof anchor.paintId === 'string' && anchor.paintId.length > 0)
+        .map((anchor) => anchor.markerId)
+    )
+    const dependencySet = frame.sidecar.dependencySet
+    const dependencySetMatches = !dependencySet || (
+      matchesCurrentReadContext(dependencySet) &&
+      dependencySet.sessionId === lifecycle.sessionId &&
+      dependencySet.routeHash === frame.sidecar.routeHash &&
+      dependencySet.codeVersion === frame.sidecar.codeVersion &&
+      dependencySet.frameId === frame.frameId &&
+      dependencySet.renderId === frame.sidecar.renderId &&
+      dependencySet.generation === frame.sidecar.generation &&
+      normalizeVariantId(dependencySet.variantId) === sidecarVariantId
+    )
+
+    return {
+      sessionId: lifecycle.sessionId,
+      generation: lifecycle.generation,
+      sourceOfTruth: lifecycle.sourceOfTruth,
+      ...(lifecycle.commandId ? { commandId: lifecycle.commandId } : {}),
+      pathname,
+      routeHash: frame.sidecar.routeHash,
+      variantId: sidecarVariantId,
+      ...(frame.sidecar.previewScope ? { previewScope: frame.sidecar.previewScope } : {}),
+      codeVersion: frame.sidecar.codeVersion,
+      renderId: frame.sidecar.renderId,
+      ...(frame.sidecar.renderNonce ? { renderNonce: frame.sidecar.renderNonce } : {}),
+      ...(frame.sidecar.emissionRevision > 0
+        ? { emissionRevision: frame.sidecar.emissionRevision }
+        : {}),
+      ...(dependencySet && dependencySetMatches ? { dependencySet } : {}),
+      frameId: frame.frameId,
+      phase,
+      pending,
+      anchors: resolvedAnchors,
+      editLocators: frame.sidecar.markers.flatMap((marker) =>
+        marker.editLocator
+          ? [{
+              markerId: marker.markerId,
+              locator: marker.editLocator,
+              modality: marker.modality,
+              ...(marker.presence ? { presence: marker.presence } : {}),
+            }]
+          : []
+      ),
+      sidecarMarkerIds: [...sidecarMarkerIds],
+      invalidMarkerIds: mergedInvalidMarkerIds,
+      unpaintedMarkerIds,
+      missingMarkerIds,
+      ambiguousMarkerIds,
+      contentMismatchMarkerIds: [...contentMismatchMarkerIdSet],
+      fatalContentMismatchMarkerIds,
+      paintDiagnostics: {
+        codedTextOnlyNotPaintable: [...sidecarMarkerIds].filter((markerId) =>
+          codedTextMarkerIds.has(markerId) && !domMarkerIds.has(markerId)
+        ),
+        domTargetPainted: [...sidecarMarkerIds].filter((markerId) =>
+          domMarkerIds.has(markerId)
+        ),
+      },
+      valid:
+        !pending &&
+        lifecycle.sessionId.length > 0 &&
+        Number.isFinite(lifecycle.generation) &&
+        lifecycle.generation > 0 &&
+        lifecycle.codeVersion.length > 0 &&
+        frame.sidecar.codeVersion === lifecycle.codeVersion &&
+        (frame.frameId !== 'route' || sidecarVariantId === lifecycle.variantId) &&
+        routeReady &&
+        frame.sidecar.routeHash.length > 0 &&
+        frame.sidecar.codeVersion.length > 0 &&
+        frame.sidecar.renderId.length > 0 &&
+        dependencySetMatches &&
+        mergedInvalidMarkerIds.length === 0 &&
+        missingMarkerIds.length === 0 &&
+        fatalContentMismatchMarkerIds.length === 0 &&
+        duplicateSidecarMarkerIds.length === 0,
+    }
+  }
+
+  function collectObservation() {
+    reconcileProvenancePublishers()
+    const frames = readFrames()
+    return {
+      frames,
+      ...collectAnchors(frames),
+      pathname: window.location.pathname,
+      domRouteHash: routeFrameHash(),
+      viewport: currentDocumentViewport(),
+    }
+  }
+
+  function buildMultiFrameMaps(phase, pending, identity, observation) {
+    const { frames, anchors, pathname, domRouteHash, viewport } = observation
+    const lifecycle = {
+      sessionId: sessionId(),
+      generation: identity.generation,
+      sourceOfTruth: identity.sourceOfTruth,
+      commandId: identity.commandId,
+      routeHash: topLevelRouteHash(frames, domRouteHash),
+      variantId: activeVariantId(),
+      codeVersion: topLevelCodeVersion(frames),
+    }
+    const ownerByMarkerId = new Map()
+    const duplicateSidecarMarkerIds = new Set()
+    for (const frame of frames) {
+      for (const marker of frame.sidecar.markers) {
+        const existing = ownerByMarkerId.get(marker.markerId)
+        if (existing !== undefined && existing !== frame.frameId) duplicateSidecarMarkerIds.add(marker.markerId)
+        ownerByMarkerId.set(marker.markerId, frame.frameId)
+      }
+    }
+
+    const invalidMarkerIds = [...new Set(
+      anchors
+        .filter((anchor) => anchor.markerId.length > 0 && !ownerByMarkerId.has(anchor.markerId))
+        .map((anchor) => anchor.markerId)
+    )]
+    const invalidMarkerIdSet = new Set(invalidMarkerIds)
+    const anchorsByFrame = new Map(frames.map((frame) => [frame.frameId, []]))
+    for (const anchor of anchors) {
+      if (invalidMarkerIdSet.has(anchor.markerId)) {
+        // Unknown anchors must still invalidate every frame. Preserve their
+        // original relative order in diagnostics without rescanning all anchors.
+        for (const frameAnchors of anchorsByFrame.values()) frameAnchors.push(anchor)
+      } else {
+        anchorsByFrame.get(ownerByMarkerId.get(anchor.markerId))?.push(anchor)
+      }
+    }
+    const duplicateIds = [...duplicateSidecarMarkerIds]
+    const maps = frames.map((frame) => buildMap(
+      pathname,
+      domRouteHash,
+      frame,
+      anchorsByFrame.get(frame.frameId),
+      invalidMarkerIds,
+      duplicateIds,
+      phase,
+      pending === true,
+      lifecycle,
+    ))
+    const routeMap = maps.find((map) => map.frameId === 'route')
+    const lifecycleValid =
+      pending !== true &&
+      lifecycle.sessionId.length > 0 &&
+      Number.isFinite(lifecycle.generation) &&
+      lifecycle.generation > 0 &&
+      lifecycle.routeHash.length > 0 &&
+      lifecycle.codeVersion.length > 0 &&
+      routeMap !== undefined &&
+      routeMap.routeHash === lifecycle.routeHash &&
+      routeMap.variantId === lifecycle.variantId &&
+      maps.every((map) => map.codeVersion === lifecycle.codeVersion)
+
+    return {
+      type: 'storystick.preview.multi-frame-anchor-maps',
+      version: 1,
+      sessionId: lifecycle.sessionId,
+      generation: lifecycle.generation,
+      sourceOfTruth: lifecycle.sourceOfTruth,
+      ...(lifecycle.commandId ? { commandId: lifecycle.commandId } : {}),
+      phase,
+      pending: pending === true,
+      pathname,
+      routeHash: lifecycle.routeHash,
+      variantId: lifecycle.variantId,
+      ...(routeMap && routeMap.previewScope ? { previewScope: routeMap.previewScope } : {}),
+      primaryPage: selectPrimaryPage(currentPrimaryPages(), pathname, runtimeBasePath),
+      codeVersion: lifecycle.codeVersion,
+      viewport,
+      maps,
+      invalidMarkerIds,
+      duplicateSidecarMarkerIds: duplicateIds,
+      valid: lifecycleValid && duplicateIds.length === 0 && invalidMarkerIds.length === 0 && maps.length > 0 && maps.every((map) => map.valid),
+    }
+  }
+
+  function logEvent(name) {
+    window.__ssPreviewProvenanceEventLog = [...(window.__ssPreviewProvenanceEventLog || []), name].slice(-40)
+  }
+
+  function logLifecycle(result, observation) {
+    window.__ssPreviewProvenanceLifecycleLog = [...(window.__ssPreviewProvenanceLifecycleLog || []), {
+      phase: result.phase,
+      pending: result.pending,
+      valid: result.valid,
+      sessionId: result.sessionId,
+      generation: result.generation,
+      sourceOfTruth: result.sourceOfTruth,
+      commandId: result.commandId || null,
+      pathname: result.pathname,
+      routeHash: result.routeHash,
+      variantId: result.variantId,
+      previewScope: result.previewScope || null,
+      codeVersion: result.codeVersion,
+      domRouteHash: observation.domRouteHash,
+      routeMapRouteHash: (result.maps.find((map) => map.frameId === 'route') || {}).routeHash || '',
+      routeMapValid: (result.maps.find((map) => map.frameId === 'route') || {}).valid === true,
+      anyFrameValid: result.maps.some((map) => map.valid === true),
+      markerCount: observation.markerCount,
+      sidecarMarkerCount: totalSidecarMarkers(observation.frames),
+    }].slice(-80)
+  }
+
+  function publish(phase, pending, identity = currentRenderIdentity, observation = null, epoch = cancelEpoch) {
+    if (!documentActive || epoch !== cancelEpoch) return
+    observation = observation || collectObservation()
+    if (!documentActive || epoch !== cancelEpoch) return
+    observationStats.publications += 1
+    logEvent(phase)
+    const result = buildMultiFrameMaps(phase, pending, identity, observation)
+    logLifecycle(result, observation)
+    window.__ssMultiFrameAnchorMaps = result
+    window.__ssAnchorMap = result.maps.find((map) => map.frameId === 'route') || result.maps[0]
+    window.dispatchEvent(new CustomEvent(LOCAL_ANCHOR_MAP_EVENT, { detail: result }))
+    if (documentActive && epoch === cancelEpoch) publishToStudio(result)
+    return result
+  }
+
+  function publishToStudio(anchorMap) {
+    if (!window.parent || window.parent === window) return
+    if (typeof window.parent.postMessage !== 'function') return
+    window.parent.postMessage({
+      type: 'storystick.preview.provenance-anchor-map',
+      timestamp: Date.now(),
+      anchorMap,
+    }, studioTargetOrigin())
+  }
+
+  function publishViewportAfterScroll() {
+    if (!documentActive || document.visibilityState === 'hidden' || viewportFrame !== null) return
+    viewportFrame = requestAnimationFrame(() => {
+      viewportFrame = null
+      if (!documentActive || document.visibilityState === 'hidden') return
+      const current = window.__ssMultiFrameAnchorMaps
+      if (!current || typeof current !== 'object') return
+      const next = {
+        ...current,
+        viewport: currentDocumentViewport(),
+      }
+      window.__ssMultiFrameAnchorMaps = next
+      const routeFrame = current.maps.find((map) => map.frameId === 'route')
+      if (!routeFrame) return
+      const message = {
+        type: 'storystick.preview.provenance-viewport',
+        timestamp: Date.now(),
+        sessionId: current.sessionId,
+        generation: current.generation,
+        sourceOfTruth: current.sourceOfTruth,
+        ...(current.commandId ? { commandId: current.commandId } : {}),
+        pathname: current.pathname,
+        routeHash: current.routeHash,
+        variantId: current.variantId || null,
+        codeVersion: current.codeVersion,
+        renderId: routeFrame.renderId,
+        viewport: next.viewport,
+      }
+      const previousStats = window.__ssPreviewProvenanceViewportStats || {
+        publications: 0,
+        maxPayloadBytes: 0,
+      }
+      const payloadBytes = JSON.stringify(message).length
+      window.__ssPreviewProvenanceViewportStats = {
+        publications: previousStats.publications + 1,
+        lastPayloadBytes: payloadBytes,
+        maxPayloadBytes: Math.max(previousStats.maxPayloadBytes, payloadBytes),
+      }
+      if (!window.parent || window.parent === window) return
+      if (typeof window.parent.postMessage !== 'function') return
+      window.parent.postMessage(message, studioTargetOrigin())
+    })
+  }
+
+  function totalSidecarMarkers(frames) {
+    return frames.reduce((sum, frame) => sum + frame.sidecar.markers.length, 0)
+  }
+
+  function allSidecarMarkersRendered(frames, anchors) {
+    const renderedMarkerIds = new Set(anchors.map((anchor) => anchor.markerId))
+    return frames.every((frame) =>
+      frame.sidecar.markers.every((marker) =>
+        marker.presence === 'optional' ||
+        marker.presence === 'expected' ||
+        renderedMarkerIds.has(marker.markerId)
+      )
+    )
+  }
+
+  function allowsMultipleAnchors(markerId, sidecarMarkers) {
+    const marker = sidecarMarkers.get(markerId)
+    return marker && marker.anchorMultiplicity === 'multi'
+  }
+
+  function isRequiredMarker(markerId, sidecarMarkers) {
+    const marker = sidecarMarkers.get(markerId)
+    return marker && marker.presence !== 'optional' && marker.presence !== 'expected'
+  }
+
+  function cancelReadyObservation() {
+    if (readyFrame !== null) cancelAnimationFrame(readyFrame)
+    if (readyRetryTimer !== null) clearTimeout(readyRetryTimer)
+    readyFrame = null
+    readyRetryTimer = null
+    readyWork = null
+  }
+
+  function queueReadyFrame() {
+    if (!documentActive || document.visibilityState === 'hidden' || readyFrame !== null || readyRetryTimer !== null || readyPassRunning || readyWork === null) return
+    readyFrame = requestAnimationFrame(runReadyPass)
+  }
+
+  function runReadyPass() {
+    readyFrame = null
+    const work = readyWork
+    if (!documentActive || document.visibilityState === 'hidden' || work === null || work.epoch !== cancelEpoch) return
+    // Preserve the initial two-paint boundary; retries remain in this chain.
+    if (!work.afterPaint) {
+      work.afterPaint = true
+      queueReadyFrame()
+      return
+    }
+    readyPassRunning = true
+    const revision = work.revision
+    const phase = work.phase
+    const identity = work.identity
+    try {
+      observationStats.readyPasses += 1
+      const observation = collectObservation()
+      if (!documentActive || work !== readyWork || work.epoch !== cancelEpoch || revision !== work.revision) return
+      const routeFrame = observation.frames.find((frame) => frame.frameId === 'route')
+      const routeReady = !routeFrame || observation.domRouteHash === routeFrame.sidecar.routeHash
+      const anchorsReady = allSidecarMarkersRendered(observation.frames, observation.anchors)
+      const remainingMs = work.deadline - performance.now()
+      if ((!routeReady || !anchorsReady) && remainingMs > 0) {
+        readyRetryTimer = setTimeout(() => {
+          readyRetryTimer = null
+          queueReadyFrame()
+        }, Math.min(READY_RETRY_MS, remainingMs))
+        return
+      }
+      publish(phase, false, identity, observation, work.epoch)
+      if (!documentActive || work !== readyWork || work.epoch !== cancelEpoch) return
+      if (work.epoch === pendingNavigationEpoch) pendingNavigationEpoch = null
+      if (revision === work.revision) readyWork = null
+    } catch (error) {
+      // An unexpected collector failure must not become a perpetual rAF loop.
+      if (readyWork === work) readyWork = null
+      throw error
+    } finally {
+      readyPassRunning = false
+      queueReadyFrame()
+    }
+  }
+
+  function scheduleReady(phase, identity = currentRenderIdentity, epoch = cancelEpoch) {
+    if (!documentActive || epoch !== cancelEpoch) return
+    if (readyWork === null || readyWork.epoch !== epoch) {
+      readyWork = { phase, identity, epoch, deadline: performance.now() + READY_DEADLINE_MS, afterPaint: false, revision: 0 }
+    } else {
+      readyWork.phase = phase
+      readyWork.identity = identity
+      readyWork.revision += 1
+    }
+    // Actual invalidations can run promptly but never restart the deadline.
+    if (readyRetryTimer !== null) clearTimeout(readyRetryTimer)
+    readyRetryTimer = null
+    queueReadyFrame()
+  }
+
+  function beginNavigation(pathname) {
+    if (!documentActive) return
+    cancelReadyObservation()
+    cancelEpoch += 1
+    iframeGeneration = Math.max(iframeGeneration + 1, currentRenderIdentity.generation + 1)
+    const iframeIdentity = { generation: iframeGeneration, sourceOfTruth: 'iframe' }
+    currentRenderIdentity = iframeIdentity
+    pendingNavigationEpoch = cancelEpoch
+    publish('pending/navigation-start', true, iframeIdentity)
+    scheduleReady('navigation:' + pathname, iframeIdentity, cancelEpoch)
+  }
+
+  function ensureNavigationGeneration(pathname) {
+    if (pendingNavigationEpoch !== null) {
+      scheduleReady('navigation:' + pathname, currentRenderIdentity, pendingNavigationEpoch)
+      return
+    }
+    beginNavigation(pathname)
+  }
+
+    function applyRenderIdentity(identity) {
+      const nextIdentity = identity === null || identity === undefined
+        ? { generation: currentRenderIdentity.generation, sourceOfTruth: 'system' }
+        : normalizeRenderIdentity(identity)
+      if (identity !== null && identity !== undefined) {
+        if (nextIdentity.generation < currentRenderIdentity.generation) return
+        if (
+          pendingNavigationEpoch !== null &&
+          currentRenderIdentity.sourceOfTruth === 'iframe' &&
+          nextIdentity.sourceOfTruth !== 'iframe' &&
+          nextIdentity.generation <= currentRenderIdentity.generation
+        ) {
+          return
+        }
+      }
+      if (
+        nextIdentity.generation === currentRenderIdentity.generation &&
+        nextIdentity.sourceOfTruth === currentRenderIdentity.sourceOfTruth &&
+        nextIdentity.commandId === currentRenderIdentity.commandId
+      ) return
+      cancelReadyObservation()
+      cancelEpoch += 1
+      pendingNavigationEpoch = null
+      currentRenderIdentity = nextIdentity
+      iframeGeneration = Math.max(iframeGeneration, currentRenderIdentity.generation)
+    }
+
+  function isPreviewLifecycleSourceOfTruth(value) {
+    return value === 'studio' || value === 'iframe' || value === 'system'
+  }
+
+  function renderIdentityFromMessage(message) {
+    if (!message || typeof message !== 'object') return null
+    if (message.type !== 'render-mode') return null
+    const lifecycle = message.previewLifecycle
+    if (
+      lifecycle &&
+      typeof lifecycle === 'object' &&
+      Number.isFinite(lifecycle.generation) &&
+      isPreviewLifecycleSourceOfTruth(lifecycle.sourceOfTruth)
+    ) {
+      return normalizeRenderIdentity({
+        generation: lifecycle.generation,
+        sourceOfTruth: lifecycle.sourceOfTruth,
+        ...(typeof lifecycle.commandId === 'string' && lifecycle.commandId.length > 0
+          ? { commandId: lifecycle.commandId }
+          : {}),
+      })
+    }
+    if (Number.isFinite(message.epoch)) {
+      return normalizeRenderIdentity({
+        generation: message.epoch,
+        sourceOfTruth: 'studio',
+      })
+    }
+    return null
+  }
+
+  function interactionModeFromMessage(message) {
+    if (!message || typeof message !== 'object') return null
+    if (message.type !== 'storystick.preview.interaction-mode') return null
+    const payload = message.payload
+    if (!payload || typeof payload !== 'object') return null
+    return payload.mode === 'edit' || payload.mode === 'browse'
+      ? payload.mode
+      : null
+  }
+
+  window.__ssPreviewProvenanceSetRenderIdentity = function setRenderIdentity(identity) {
+    if (!documentActive) return
+    applyRenderIdentity(identity)
+  }
+
+  window.addEventListener('message', (event) => {
+    if (!documentActive) return
+    if (event.source !== window.parent) return
+    if (validSnapshot(event.data)) {
+      if (event.data.sessionId !== sessionId()) return
+      if (sidecarStore.accept(event.data)) {
+        scheduleReady('provenance-sidecar:' + window.location.pathname)
+      }
+      return
+    }
+    const interactionMode = interactionModeFromMessage(event.data)
+    if (interactionMode !== null) {
+      currentInteractionMode = interactionMode
+      return
+    }
+    const identity = renderIdentityFromMessage(event.data)
+    if (identity === null) return
+    applyRenderIdentity(identity)
+    scheduleReady('render-mode:' + window.location.pathname)
+  })
+
+  document.addEventListener('click', (event) => {
+    const target = event.target instanceof Element ? event.target.closest('a[href][data-ss-e], a[href][data-ss-p], [data-ss-e] a[href], [data-ss-p] a[href]') : null
+    if (!(target instanceof HTMLAnchorElement)) return
+    if (target.origin !== window.location.origin) return
+    if (currentInteractionMode === 'edit') return
+    if (normalizeMomentaryNavigateLinkClick(event, target)) return
+    beginNavigation(new URL(target.href).pathname)
+  }, { capture: true })
+
+  document.addEventListener('keydown', (event) => {
+    if (!isMomentaryNavigateKeyDown(event)) return
+    emitMomentaryNavigateKey(true)
+  }, { capture: true })
+
+  document.addEventListener('keyup', (event) => {
+    if (event.key === 'Alt' || !event.altKey) emitMomentaryNavigateKey(false)
+  }, { capture: true })
+
+  window.addEventListener('pagehide', () => emitMomentaryNavigateKey(false))
+  window.addEventListener('pagehide', teardownPaintIdentityStamps)
+  window.addEventListener('pageshow', restorePaintIdentityStampsFromBackForwardCache)
+  document.addEventListener('visibilitychange', () => {
+    emitMomentaryNavigateKey(false)
+    if (!documentActive) return
+    if (document.visibilityState === 'hidden') {
+      if (readyFrame !== null) cancelAnimationFrame(readyFrame)
+      if (readyRetryTimer !== null) clearTimeout(readyRetryTimer)
+      if (viewportFrame !== null) cancelAnimationFrame(viewportFrame)
+      readyFrame = null
+      readyRetryTimer = null
+      viewportFrame = null
+    } else {
+      scheduleReady('visible:' + window.location.pathname)
+    }
+  })
+
+  // Framework adapters report committed locations through the existing router API.
+  // Never patch customer history methods or rewrite authored hrefs.
+  window.addEventListener('storystick.preview.location-committed', () => {
+    if (!documentActive || !sessionId()) return
+    readCarriersDirty = true
+    publisherSnapshotDirty = true
+    ensureNavigationGeneration(window.location.pathname)
+    reconcileProvenancePublishers()
+  })
+
+  window.addEventListener('popstate', () => beginNavigation(window.location.pathname))
+  window.addEventListener('scroll', publishViewportAfterScroll, { passive: true })
+
+  window.addEventListener('storystick.preview.read-context-changed', () => {
+    if (!documentActive) return
+    publisherSnapshotDirty = true
+    reconcileProvenancePublishers()
+    scheduleReady('read-context:' + window.location.pathname)
+  })
+  window.addEventListener('storystick.preview.provenance-occurrence', (event) => {
+    if (!documentActive) return
+    const occurrence = event.detail
+    if (!occurrence || typeof occurrence.frameId !== 'string' || typeof occurrence.renderNonce !== 'string') return
+    const key = JSON.stringify([occurrence.frameId, occurrence.renderNonce])
+    if (occurrence.operation === 'mount') {
+      pendingOccurrenceRemovals.delete(key)
+      readCarriersDirty = true
+      reconcileProvenancePublishers()
+      scheduleReady('mount:' + window.location.pathname)
+    } else if (occurrence.operation === 'unmount') {
+      pendingOccurrenceRemovals.set(key, occurrence)
+      queueMicrotask(() => {
+        if (!pendingOccurrenceRemovals.delete(key)) return
+        const frame = publisherFramesById.get(occurrence.frameId)
+        if (frame?.sidecar.renderNonce !== occurrence.renderNonce) return
+        publisherFramesById.delete(occurrence.frameId)
+        publisherSnapshotDirty = true
+        readCarriersDirty = true
+        if (!documentActive) return
+        reconcileProvenancePublishers()
+        scheduleReady('unmount:' + window.location.pathname)
+      })
+    }
+  })
+
+  function invalidatesReadCarriers(record) {
+    if (isSyntheticOverlayOnlyMutation(record)) return false
+    return record.type !== 'attributes' || (
+      record.attributeName !== 'style' &&
+      record.attributeName !== 'class' &&
+      record.attributeName !== 'hidden' &&
+      record.attributeName !== 'aria-expanded' &&
+      record.attributeName !== 'aria-hidden' &&
+      record.attributeName !== 'data-state' &&
+      record.attributeName !== 'popover' &&
+      record.attributeName !== 'inert' &&
+      record.attributeName !== 'open'
+    )
+  }
+
+  provenanceObserver = new MutationObserver((records) => {
+    if (!documentActive || records.every(isSyntheticOverlayOnlyMutation)) return
+    if (records.some(invalidatesReadCarriers)) readCarriersDirty = true
+    reconcileProvenancePublishers()
+    scheduleReady('mutation:' + window.location.pathname)
+  })
+  provenanceObserver.observe(document.documentElement, PROVENANCE_OBSERVER_OPTIONS)
+
+  window.__ssPreviewProvenanceProbe = {
+    rebuild: (phase = 'probe') => publish(phase, false, currentRenderIdentity),
+    observationStats: () => ({ ...observationStats }),
+    eventLog: () => [...(window.__ssPreviewProvenanceEventLog || [])],
+    lifecycleLog: () => [...(window.__ssPreviewProvenanceLifecycleLog || [])],
+  }
+
+  window[PAINT_TARGET_REGISTRY] = {
+    resolve: resolvePaintTarget,
+    isDomMutationSafe: () => hydrationSafeDomMaterializationEnabled,
+  }
+
+  scheduleHydrationSafeDomMaterialization()
+  // Preserve synchronous authority publication, including initial publisher
+  // ACKs. The scheduled pass reuses its carrier sample if the DOM is unchanged.
+  reconcileProvenancePublishers()
+  scheduleReady('initial:' + window.location.pathname)
+  // This script can load after the snapshot reporter's handshake. Ask Studio
+  // to replay its current contract only after our message listener is installed;
+  // a previously posted render-mode cannot establish this reporter's identity.
+  if (window.parent !== window) window.parent.postMessage({ type: 'ready' }, studioTargetOrigin())
+})()
+`)();