fg-devkit 1.17.3 → 1.19.2

package/scripts/piwik-dimensions.mjs

@@ -0,0 +1,785 @@
+/**
+ * Local custom-dimension maps and the diff against Piwik PRO.
+ *
+ * Session and event slots are assigned by Piwik as the next free number in that
+ * scope. The number is not reusable after deactivation, and the API does not
+ * accept a chosen slot. Product slots can be chosen in the 1–20 range.
+ */
+
+export const SCOPES = ['event', 'session', 'product']
+
+export const SLOT_LIMITS = {
+  event: 200,
+  session: 200,
+  product: 20,
+}
+
+/** @typedef {'event' | 'session' | 'product'} DimensionScope */
+
+/**
+ * @typedef {object} LocalDimension
+ * @property {string} key
+ * @property {string} name Desired Piwik name.
+ * @property {number} slot
+ * @property {DimensionScope} scope
+ * @property {string} file
+ * @property {string} exportName
+ */
+
+/**
+ * @typedef {object} RemoteDimension
+ * @property {string} id
+ * @property {string} name
+ * @property {number} slot
+ * @property {number} trackingId
+ * @property {DimensionScope} scope
+ * @property {boolean} active
+ * @property {boolean} caseSensitive
+ * @property {string} description
+ * @property {string} [websiteId]
+ */
+
+export class PiwikDimensionError extends Error {
+  /**
+   * @param {string} message
+   */
+  constructor(message) {
+    super(message)
+    this.name = 'PiwikDimensionError'
+  }
+}
+
+/**
+ * @param {string} exportName
+ * @returns {DimensionScope | null}
+ */
+export function scopeForExportName(exportName) {
+  const lower = exportName.toLowerCase()
+  if (lower.includes('session')) return 'session'
+  if (lower.includes('product')) return 'product'
+  if (lower.includes('event') || lower.includes('custom')) return 'event'
+  return null
+}
+
+/**
+ * @param {string} source
+ * @param {number} openIndex Index of the opening brace.
+ */
+function readBrace(source, openIndex) {
+  let depth = 0
+  for (let i = openIndex; i < source.length; i += 1) {
+    const char = source[i]
+    if (char === '{') depth += 1
+    else if (char === '}') {
+      depth -= 1
+      if (depth === 0) return source.slice(openIndex + 1, i)
+    }
+  }
+  throw new PiwikDimensionError('Unclosed brace while reading a dimension export.')
+}
+
+/**
+ * @param {string} source
+ */
+function stripComments(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:'"])\/\/.*$/gm, '$1')
+}
+
+/**
+ * @param {string} body
+ * @param {{ exportName: string, scope: DimensionScope, file: string }} meta
+ * @returns {LocalDimension[]}
+ */
+function parseEntries(body, meta) {
+  /** @type {LocalDimension[]} */
+  const dimensions = []
+  const seenKeys = new Set()
+  const seenSlots = new Set()
+  const entryRe = /([A-Za-z_][A-Za-z0-9_]*)\s*[:=]\s*(\d+)/g
+  let match = entryRe.exec(body)
+  while (match) {
+    const key = match[1]
+    const slot = Number(match[2])
+    if (seenKeys.has(key)) {
+      throw new PiwikDimensionError(`Duplicate dimension key "${key}" in ${meta.exportName} (${meta.file}).`)
+    }
+    if (seenSlots.has(slot)) {
+      throw new PiwikDimensionError(
+        `Duplicate ${meta.scope} slot ${slot} in ${meta.exportName} (${meta.file}).`,
+      )
+    }
+    if (!Number.isInteger(slot) || slot < 1) {
+      throw new PiwikDimensionError(`Slot for "${key}" must be an integer >= 1.`)
+    }
+    if (slot > SLOT_LIMITS[meta.scope]) {
+      throw new PiwikDimensionError(
+        `${meta.scope} slot ${slot} for "${key}" is above the Piwik limit of ${SLOT_LIMITS[meta.scope]}.`,
+      )
+    }
+    seenKeys.add(key)
+    seenSlots.add(slot)
+    dimensions.push({
+      key,
+      name: key,
+      slot,
+      scope: meta.scope,
+      file: meta.file,
+      exportName: meta.exportName,
+    })
+    match = entryRe.exec(body)
+  }
+  return dimensions
+}
+
+/**
+ * Parse a dimensions module (const map or enum).
+ * `customDimensions` / `CustomDimensions` are event scope.
+ * Names containing "session" or "product" select those scopes.
+ *
+ * @param {string} source
+ * @param {string} [file]
+ * @returns {LocalDimension[]}
+ */
+export function parseDimensionSource(source, file = 'dimensions.ts') {
+  const stripped = stripComments(source)
+  /** @type {LocalDimension[]} */
+  const dimensions = []
+  const exportRe = /export\s+(?:const|enum)\s+([A-Za-z0-9_]+)/g
+  let match = exportRe.exec(stripped)
+  while (match) {
+    const exportName = match[1]
+    const scope = scopeForExportName(exportName)
+    const braceAt = stripped.indexOf('{', match.index)
+    if (scope && braceAt >= 0) {
+      const body = readBrace(stripped, braceAt)
+      dimensions.push(...parseEntries(body, { exportName, scope, file }))
+    }
+    match = exportRe.exec(stripped)
+  }
+  return dimensions
+}
+
+/**
+ * @param {Record<string, unknown> | undefined} names
+ * @param {LocalDimension} local
+ */
+export function desiredName(names, local) {
+  if (!names || typeof names !== 'object') return local.key
+  const direct = names[local.key]
+  if (typeof direct === 'string' && direct.trim() !== '') return direct
+  const scoped = names[local.scope]
+  if (scoped && typeof scoped === 'object') {
+    const value = /** @type {Record<string, unknown>} */ (scoped)[local.key]
+    if (typeof value === 'string' && value.trim() !== '') return value
+  }
+  return local.key
+}
+
+/**
+ * @param {LocalDimension[]} locals
+ * @param {Record<string, unknown> | undefined} names
+ * @returns {LocalDimension[]}
+ */
+export function applyDesiredNames(locals, names) {
+  return locals.map((local) => ({ ...local, name: desiredName(names, local) }))
+}
+
+/**
+ * Plan writing Piwik tracking ids back into the local map. Keys match on name within a scope.
+ * @param {LocalDimension[]} locals
+ * @param {RemoteDimension[]} remotes
+ */
+export function planLocalPull(locals, remotes) {
+  /** @type {Map<string, RemoteDimension>} */
+  const byName = new Map()
+  /** @type {string[]} */
+  const ambiguous = []
+  for (const remote of remotes) {
+    const key = `${remote.scope}:${remote.name}`
+    if (byName.has(key)) ambiguous.push(`${remote.scope} "${remote.name}"`)
+    else byName.set(key, remote)
+  }
+  if (ambiguous.length > 0) {
+    throw new PiwikDimensionError(`Piwik has more than one dimension named ${ambiguous.join(', ')}.`)
+  }
+
+  /** @type {{ local: LocalDimension, remote: RemoteDimension, next: number }[]} */
+  const updates = []
+  /** @type {LocalDimension[]} */
+  const inSync = []
+  /** @type {LocalDimension[]} */
+  const missingInPiwik = []
+  for (const local of locals) {
+    const remote = byName.get(`${local.scope}:${local.name}`)
+    if (!remote) {
+      missingInPiwik.push(local)
+      continue
+    }
+    const next = local.scope === 'product' ? remote.slot : remote.trackingId
+    if (next === local.slot) inSync.push(local)
+    else updates.push({ local, remote, next })
+  }
+
+  /** @type {Map<string, string>} */
+  const occupied = new Map()
+  for (const local of locals) {
+    const moving = updates.find((item) => item.local === local)
+    const slot = moving ? moving.next : local.slot
+    const key = `${local.scope}:${slot}`
+    const existing = occupied.get(key)
+    if (existing) {
+      throw new PiwikDimensionError(
+        `${local.scope} tracking_id ${slot} would be used by both "${existing}" and "${local.key}".`,
+      )
+    }
+    occupied.set(key, local.key)
+  }
+
+  const remoteOnly = remotes.filter(
+    (remote) => !locals.some((local) => local.scope === remote.scope && local.name === remote.name),
+  )
+  return { updates, inSync, missingInPiwik, remoteOnly }
+}
+
+/**
+ * Replace dimension numbers in a source file. `from` is matched together with the key so swaps stay unique.
+ * @param {string} source
+ * @param {{ key: string, from: number, to: number }[]} updates
+ */
+export function rewriteDimensionNumbers(source, updates) {
+  let next = source
+  for (const [index, update] of updates.entries()) {
+    const pattern = new RegExp(`(\\b${update.key}\\s*[:=]\\s*)${update.from}\\b`)
+    if (!pattern.test(next)) {
+      throw new PiwikDimensionError(`Could not find ${update.key}: ${update.from} in the dimension file.`)
+    }
+    next = next.replace(pattern, `$1__PIWIK_${index}__`)
+  }
+  for (const [index, update] of updates.entries()) {
+    next = next.replace(`__PIWIK_${index}__`, String(update.to))
+  }
+  return next
+}
+
+/**
+ * The app sends dimension{id}. For event and session that id is tracking_id.
+ * Product dimensions are chosen by slot.
+ * @param {{ scope: DimensionScope, slot: number, trackingId?: number }} dimension
+ */
+function dimensionKey(dimension) {
+  if (dimension.scope === 'product') return `product:slot:${dimension.slot}`
+  const trackingId = dimension.trackingId ?? dimension.slot
+  return `${dimension.scope}:tracking:${trackingId}`
+}
+
+/**
+ * @param {RemoteDimension[]} remotes
+ */
+function remoteByAppId(remotes) {
+  /** @type {Map<string, RemoteDimension>} */
+  const map = new Map()
+  for (const remote of remotes) {
+    const key = dimensionKey(remote)
+    if (map.has(key)) {
+      const label = remote.scope === 'product' ? `slot ${remote.slot}` : `tracking_id ${remote.trackingId}`
+      throw new PiwikDimensionError(`Piwik returned two ${remote.scope} dimensions for ${label}.`)
+    }
+    map.set(key, remote)
+  }
+  return map
+}
+
+/**
+ * @param {LocalDimension[]} locals
+ * @param {RemoteDimension[]} remotes
+ */
+export function diffDimensions(locals, remotes) {
+  const remoteMap = remoteByAppId(remotes)
+  const matched = new Set()
+  /** @type {LocalDimension[]} */
+  const missing = []
+  /** @type {{ local: LocalDimension, remote: RemoteDimension }[]} */
+  const inSync = []
+  /** @type {{ local: LocalDimension, remote: RemoteDimension }[]} */
+  const nameMismatch = []
+  /** @type {{ local: LocalDimension, remote: RemoteDimension }[]} */
+  const trackingMismatch = []
+
+  for (const local of locals) {
+    const remote = remoteMap.get(dimensionKey(local))
+    if (!remote) {
+      missing.push(local)
+      continue
+    }
+    matched.add(dimensionKey(remote))
+    if (remote.scope !== 'product' && remote.trackingId !== remote.slot) {
+      trackingMismatch.push({ local, remote })
+    }
+    if (remote.name !== local.name) nameMismatch.push({ local, remote })
+    else inSync.push({ local, remote })
+  }
+
+  const remoteOnly = remotes.filter((remote) => !matched.has(dimensionKey(remote)))
+  return { missing, inSync, nameMismatch, trackingMismatch, remoteOnly }
+}
+
+/**
+ * Lowest unused slot in a scope. Inactive dimensions still occupy their slot.
+ * @param {Set<number>} used
+ * @param {DimensionScope} scope
+ */
+export function nextFreeSlot(used, scope) {
+  const limit = SLOT_LIMITS[scope]
+  for (let slot = 1; slot <= limit; slot += 1) {
+    if (!used.has(slot)) return slot
+  }
+  return null
+}
+
+/**
+ * Lowest unused tracking_id across event and session. The app sends this number as dimensionN.
+ * @param {Set<number>} used
+ */
+export function nextFreeTrackingId(used) {
+  const limit = SLOT_LIMITS.event + SLOT_LIMITS.session
+  for (let id = 1; id <= limit; id += 1) {
+    if (!used.has(id)) return id
+  }
+  return null
+}
+
+/**
+ * @param {LocalDimension[]} missing
+ * @param {RemoteDimension[]} remotes
+ */
+export function planCreates(missing, remotes) {
+  const usedProductSlots = new Set(remotes.filter((remote) => remote.scope === 'product').map((remote) => remote.slot))
+  const usedTrackingIds = new Set(
+    remotes.filter((remote) => remote.scope !== 'product').map((remote) => remote.trackingId),
+  )
+
+  /** @type {LocalDimension[]} */
+  const creates = []
+  /** @type {{ local: LocalDimension, reason: string }[]} */
+  const blocked = []
+
+  const products = missing.filter((item) => item.scope === 'product').sort((a, b) => a.slot - b.slot)
+  for (const local of products) {
+    if (usedProductSlots.has(local.slot)) {
+      blocked.push({ local, reason: `Product slot ${local.slot} is already used in Piwik.` })
+      continue
+    }
+    creates.push(local)
+    usedProductSlots.add(local.slot)
+  }
+
+  const items = missing
+    .filter((item) => item.scope !== 'product')
+    .sort((a, b) => a.slot - b.slot || SCOPES.indexOf(a.scope) - SCOPES.indexOf(b.scope))
+  let blockedEarlier = false
+  for (const local of items) {
+    if (blockedEarlier) {
+      blocked.push({
+        local,
+        reason: 'An earlier dimension must be added first. Piwik assigns the next tracking_id and does not let you choose it.',
+      })
+      continue
+    }
+    if (usedTrackingIds.has(local.slot)) {
+      blocked.push({
+        local,
+        reason: `dimension${local.slot} is already used by another scope.`,
+      })
+      continue
+    }
+    const next = nextFreeTrackingId(usedTrackingIds)
+    if (next !== local.slot) {
+      blockedEarlier = true
+      blocked.push({
+        local,
+        reason:
+          next === null
+            ? 'No free tracking_id left.'
+            : `Next tracking_id is ${next}. ${local.key} sends dimension${local.slot}, and Piwik does not let you choose it.`,
+      })
+      continue
+    }
+    creates.push(local)
+    usedTrackingIds.add(local.slot)
+  }
+
+  return { creates, blocked }
+}
+
+/**
+ * @param {string} value
+ * @param {number} width
+ */
+function pad(value, width) {
+  const text = String(value)
+  return text.length >= width ? text : text.padEnd(width)
+}
+
+/**
+ * @param {boolean | null | undefined} active
+ */
+function activeLabel(active) {
+  if (active === true) return 'Active'
+  if (active === false) return 'Inactive'
+  return '—'
+}
+
+/**
+ * @param {string[]} headers
+ * @param {string[][]} rows
+ */
+export function renderTable(headers, rows) {
+  const widths = headers.map((header, index) =>
+    Math.max(header.length, ...rows.map((row) => String(row[index] ?? '').length)),
+  )
+  const rule = (left, join, right) => left + widths.map((width) => '─'.repeat(width + 2)).join(join) + right
+  const formatRow = (cells) => `│${cells.map((cell, index) => ` ${pad(cell, widths[index])} `).join('│')}│`
+  return [rule('┌', '┬', '┐'), formatRow(headers), rule('├', '┼', '┤'), ...rows.map(formatRow), rule('└', '┴', '┘')]
+}
+
+/**
+ * @param {ReturnType<typeof diffDimensions>} diff
+ * @param {ReturnType<typeof planCreates>} plan
+ */
+export function formatDimensionReport(diff, plan) {
+  const lines = []
+  lines.push(
+    `[piwik] ${diff.inSync.length} in sync, ${diff.nameMismatch.length} different name, ${plan.creates.length} missing in Piwik, ${diff.remoteOnly.length} only in Piwik, ${plan.blocked.length} cannot add`,
+  )
+  lines.push('[piwik] in app = name in the repo. in Piwik = name in Piwik. tracking_id = dimensionN sent by the app.')
+
+  /** @type {{ scope: DimensionScope, order: number, slot: string, trackingId: string, appName: string, piwikName: string, active: string, status: string, description: string }[]} */
+  const rows = []
+  const pushRow = (scope, order, slot, trackingId, appName, piwikName, active, status, description) => {
+    rows.push({
+      scope,
+      order,
+      slot: String(slot),
+      trackingId: String(trackingId),
+      appName,
+      piwikName,
+      active,
+      status,
+      description: description.trim(),
+    })
+  }
+  for (const { local, remote } of diff.inSync) {
+    pushRow(
+      local.scope,
+      remote.scope === 'product' ? remote.slot : remote.trackingId,
+      remote.slot,
+      remote.scope === 'product' ? '—' : remote.trackingId,
+      local.name,
+      remote.name,
+      activeLabel(remote.active),
+      'in sync',
+      remote.description,
+    )
+  }
+  for (const { local, remote } of diff.nameMismatch) {
+    pushRow(
+      local.scope,
+      remote.scope === 'product' ? remote.slot : remote.trackingId,
+      remote.slot,
+      remote.scope === 'product' ? '—' : remote.trackingId,
+      local.name,
+      remote.name,
+      activeLabel(remote.active),
+      'different name',
+      remote.description,
+    )
+  }
+  for (const local of plan.creates) {
+    pushRow(
+      local.scope,
+      local.slot,
+      '—',
+      local.scope === 'product' ? '—' : local.slot,
+      local.name,
+      '—',
+      '—',
+      'missing in Piwik',
+      '',
+    )
+  }
+  for (const { local } of plan.blocked) {
+    pushRow(
+      local.scope,
+      local.slot,
+      '—',
+      local.scope === 'product' ? '—' : local.slot,
+      local.name,
+      '—',
+      '—',
+      'cannot add',
+      '',
+    )
+  }
+  for (const remote of diff.remoteOnly) {
+    pushRow(
+      remote.scope,
+      remote.scope === 'product' ? remote.slot : remote.trackingId,
+      remote.slot,
+      remote.scope === 'product' ? '—' : remote.trackingId,
+      '—',
+      remote.name,
+      activeLabel(remote.active),
+      'only in Piwik',
+      remote.description,
+    )
+  }
+
+  const showDescription = rows.some((row) => row.description !== '')
+  for (const scope of SCOPES) {
+    const scoped = rows.filter((row) => row.scope === scope).sort((a, b) => a.order - b.order)
+    if (scoped.length === 0) continue
+    const headers = ['slot', 'tracking_id', 'in app', 'in Piwik', 'active', 'status']
+    if (showDescription) headers.push('description')
+    lines.push('')
+    lines.push(scope)
+    lines.push(
+      ...renderTable(
+        headers,
+        scoped.map((row) => {
+          const cells = [row.slot, row.trackingId, row.appName, row.piwikName, row.active, row.status]
+          if (showDescription) cells.push(row.description)
+          return cells
+        }),
+      ),
+    )
+  }
+
+  for (const { local, reason } of plan.blocked) {
+    lines.push(`[piwik] ${local.scope} dimension${local.slot} ${local.key}: ${reason}`)
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * @param {RemoteDimension} source
+ * @param {RemoteDimension} target
+ */
+function environmentChanges(source, target) {
+  /** @type {string[]} */
+  const fields = []
+  if (source.name !== target.name) fields.push('name')
+  if (source.description.trim() !== target.description.trim()) fields.push('description')
+  if (source.active !== target.active) fields.push('active')
+  return fields
+}
+
+/**
+ * @param {string[]} fields
+ */
+function environmentChangeStatus(fields) {
+  const labels = {
+    name: 'different name',
+    description: 'different description',
+    active: 'different active',
+  }
+  return fields.map((field) => labels[field] ?? field).join(', ')
+}
+
+/**
+ * Compare two Piwik sites. Event and session rows match on tracking_id. Product rows match on slot.
+ * @param {RemoteDimension[]} source
+ * @param {RemoteDimension[]} target
+ */
+export function diffEnvironments(source, target) {
+  const targetByKey = new Map(target.map((item) => [dimensionKey(item), item]))
+  const sourceKeys = new Set()
+  /** @type {{ source: RemoteDimension, target: RemoteDimension }[]} */
+  const inSync = []
+  /** @type {{ source: RemoteDimension, target: RemoteDimension, fields: string[] }[]} */
+  const changed = []
+  /** @type {RemoteDimension[]} */
+  const missing = []
+
+  for (const item of source) {
+    const key = dimensionKey(item)
+    sourceKeys.add(key)
+    const other = targetByKey.get(key)
+    if (!other) {
+      missing.push(item)
+      continue
+    }
+    const fields = environmentChanges(item, other)
+    if (fields.length === 0) inSync.push({ source: item, target: other })
+    else changed.push({ source: item, target: other, fields })
+  }
+
+  const targetOnly = target.filter((item) => !sourceKeys.has(dimensionKey(item)))
+  return { inSync, changed, missing, targetOnly }
+}
+
+/**
+ * @param {RemoteDimension} remote
+ * @returns {LocalDimension}
+ */
+function sourceAsLocal(remote) {
+  return {
+    key: remote.name,
+    name: remote.name,
+    slot: remote.scope === 'product' ? remote.slot : remote.trackingId,
+    scope: remote.scope,
+    file: '',
+    exportName: '',
+  }
+}
+
+/**
+ * @param {ReturnType<typeof diffEnvironments>} diff
+ * @param {RemoteDimension[]} target
+ */
+export function planEnvironmentMigration(diff, target) {
+  return planCreates(diff.missing.map(sourceAsLocal), target)
+}
+
+/**
+ * @param {string} sourceDescription
+ * @param {string} targetDescription
+ */
+function environmentDescription(sourceDescription, targetDescription) {
+  const from = sourceDescription.trim()
+  const to = targetDescription.trim()
+  if (from === to) return from
+  return `${from || '—'} → ${to || '—'}`
+}
+
+/**
+ * @param {boolean | null | undefined} sourceActive
+ * @param {boolean | null | undefined} targetActive
+ */
+function environmentActive(sourceActive, targetActive) {
+  const from = activeLabel(sourceActive)
+  const to = activeLabel(targetActive)
+  if (from === to) return from
+  return `${from} → ${to}`
+}
+
+/**
+ * @param {ReturnType<typeof diffEnvironments>} diff
+ * @param {ReturnType<typeof planCreates>} plan
+ * @param {string} fromName
+ * @param {string} toName
+ */
+export function formatEnvironmentReport(diff, plan, fromName, toName) {
+  const lines = []
+  lines.push(
+    `[piwik] ${fromName} → ${toName}: ${diff.inSync.length} in sync, ${diff.changed.length} different, ${plan.creates.length} missing in ${toName}, ${diff.targetOnly.length} only in ${toName}, ${plan.blocked.length} cannot add`,
+  )
+  lines.push('[piwik] Event and session rows match on tracking_id. Each environment has its own tracking_id column. A different slot is still in sync.')
+
+  /** @type {{ scope: DimensionScope, order: number, cells: string[], description: string }[]} */
+  const rows = []
+  const trackingCell = (remote) => (remote.scope === 'product' ? '—' : String(remote.trackingId))
+  const pushRow = (scope, order, slotFrom, trackingFrom, nameFrom, slotTo, trackingTo, nameTo, active, status, description) => {
+    rows.push({
+      scope,
+      order,
+      description,
+      cells: [String(slotFrom), String(trackingFrom), nameFrom, String(slotTo), String(trackingTo), nameTo, active, status],
+    })
+  }
+  for (const { source, target } of diff.inSync) {
+    pushRow(
+      source.scope,
+      source.scope === 'product' ? source.slot : source.trackingId,
+      source.slot,
+      trackingCell(source),
+      source.name,
+      target.slot,
+      trackingCell(target),
+      target.name,
+      environmentActive(source.active, target.active),
+      'in sync',
+      environmentDescription(source.description, target.description),
+    )
+  }
+  for (const { source, target, fields } of diff.changed) {
+    pushRow(
+      source.scope,
+      source.scope === 'product' ? source.slot : source.trackingId,
+      source.slot,
+      trackingCell(source),
+      source.name,
+      target.slot,
+      trackingCell(target),
+      target.name,
+      environmentActive(source.active, target.active),
+      environmentChangeStatus(fields),
+      environmentDescription(source.description, target.description),
+    )
+  }
+  const blockedIds = new Set(plan.blocked.map(({ local }) => `${local.scope}:${local.slot}`))
+  for (const source of diff.missing) {
+    const id = source.scope === 'product' ? source.slot : source.trackingId
+    const blocked = blockedIds.has(`${source.scope}:${id}`)
+    pushRow(
+      source.scope,
+      id,
+      source.slot,
+      trackingCell(source),
+      source.name,
+      '—',
+      '—',
+      '—',
+      activeLabel(source.active),
+      blocked ? 'cannot add' : `missing in ${toName}`,
+      source.description.trim(),
+    )
+  }
+  for (const target of diff.targetOnly) {
+    const id = target.scope === 'product' ? target.slot : target.trackingId
+    pushRow(
+      target.scope,
+      id,
+      '—',
+      '—',
+      '—',
+      target.slot,
+      trackingCell(target),
+      target.name,
+      activeLabel(target.active),
+      `only in ${toName}`,
+      target.description.trim(),
+    )
+  }
+
+  const showDescription = rows.some((row) => row.description !== '')
+  const headers = [
+    `slot ${fromName}`,
+    `tracking_id ${fromName}`,
+    fromName,
+    `slot ${toName}`,
+    `tracking_id ${toName}`,
+    toName,
+    'active',
+    'status',
+  ]
+  if (showDescription) headers.push('description')
+  for (const scope of SCOPES) {
+    const scoped = rows.filter((row) => row.scope === scope).sort((a, b) => a.order - b.order)
+    if (scoped.length === 0) continue
+    lines.push('')
+    lines.push(scope)
+    lines.push(
+      ...renderTable(
+        headers,
+        scoped.map((row) => (showDescription ? [...row.cells, row.description] : row.cells)),
+      ),
+    )
+  }
+
+  for (const { local, reason } of plan.blocked) {
+    lines.push(`[piwik] ${local.scope} dimension${local.slot} ${local.key}: ${reason}`)
+  }
+
+  return lines.join('\n')
+}