collavre 0.24.0 → 0.25.0

data/app/javascript/lib/__tests__/skill_html_entities.test.js

@@ -0,0 +1,23 @@
+import { decodeHtmlEntities } from "../../../../skills/collavre/scripts/html_entities.js";
+
+describe("decodeHtmlEntities", () => {
+  test("decodes supported named and numeric entities", () => {
+    expect(decodeHtmlEntities("A & B <x> "q" 'a' AB"))
+      .toBe("A & B <x> \"q\" 'a' AB");
+  });
+
+  test("decodes each entity exactly once", () => {
+    expect(decodeHtmlEntities("&amp;lt; &amp;#60; &#38;gt; &#x26;quot;"))
+      .toBe("&lt; &#60; &gt; &quot;");
+  });
+
+  test("preserves unsupported and out-of-range entities", () => {
+    expect(decodeHtmlEntities("&copy; &#x110000;"))
+      .toBe("&copy; &#x110000;");
+  });
+
+  test("preserves empty values", () => {
+    expect(decodeHtmlEntities("")).toBe("");
+    expect(decodeHtmlEntities(null)).toBeNull();
+  });
+});

data/app/javascript/lib/__tests__/turbo_stream_actions.test.js

@@ -0,0 +1,190 @@
+/**
+ * @jest-environment jsdom
+ */
+import { jest } from '@jest/globals'
+
+const fakeTurbo = { StreamActions: {} }
+
+jest.unstable_mockModule('@hotwired/turbo-rails', () => ({ Turbo: fakeTurbo }))
+jest.unstable_mockModule('../../creatives/tree_renderer', () => ({
+  createRow: jest.fn(),
+  applyRowProperties: jest.fn(),
+  replaceProgressControl: jest.fn((_html, controlHtml) => controlHtml),
+  updateProgressHtml: jest.fn((html, progress) => progress === 1
+    ? html.replace('class="progress-toggle-checkbox"', 'class="progress-toggle-checkbox" checked="checked"')
+      .replace('data-current-progress="0"', 'data-current-progress="1"')
+      .replace('data-new-progress="1"', 'data-new-progress="0"')
+      .replace('title="Mark complete"', 'title="Mark incomplete"')
+    : html),
+}))
+
+await import('../turbo_stream_actions')
+const { createRow } = await import('../../creatives/tree_renderer')
+const { updateProgressForRow } = await import('../turbo_stream_actions')
+
+const EMPTY_HTML = '<div data-creatives-empty-state=""><p>No sub-creatives found.</p></div>'
+
+// Mirrors creatives/index.html.erb: title row above the tree container with the
+// server-rendered placeholder inside it.
+function renderEmptyTreeForParent(parentId) {
+  document.body.innerHTML = `
+    <creative-tree-row is-title creative-id="${parentId}"></creative-tree-row>
+    <div id="creatives">${EMPTY_HTML}</div>
+  `
+  createRow.mockImplementation((creative) => {
+    const row = document.createElement('creative-tree-row')
+    row.setAttribute('creative-id', String(creative.id))
+    row.setAttribute('parent-id', String(creative.parent_id))
+    return row
+  })
+  return document.getElementById('creatives')
+}
+
+function dispatchCreativeTreeStream(payload) {
+  fakeTurbo.StreamActions.refresh_creative_tree.call({
+    getAttribute: (name) => name === 'data' ? JSON.stringify(payload) : null,
+  })
+}
+
+afterEach(() => {
+  document.body.innerHTML = ''
+  jest.restoreAllMocks()
+})
+
+test('remote destroyed streams notify chat even when no tree row is visible', () => {
+  const destroyedEvents = []
+  const invalidatedEvents = []
+  document.addEventListener('creative-destroyed', (event) => destroyedEvents.push(event.detail), { once: true })
+  document.addEventListener('workspace-tree:invalidate', (event) => invalidatedEvents.push(event), { once: true })
+
+  dispatchCreativeTreeStream({
+    action: 'destroyed',
+    creative: { id: 123, linked_id: 456, parent_id: 42 },
+  })
+
+  expect(destroyedEvents).toEqual([{ creativeIds: ['456', '123'] }])
+  expect(invalidatedEvents).toHaveLength(1)
+})
+
+test('remote destroyed streams deduplicate identical effective and origin IDs', () => {
+  const listener = jest.fn()
+  document.addEventListener('creative-destroyed', listener, { once: true })
+
+  dispatchCreativeTreeStream({
+    action: 'destroyed',
+    creative: { id: 123 },
+  })
+
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    detail: { creativeIds: ['123'] },
+  }))
+})
+
+test('remote created streams clear the empty-state placeholder', () => {
+  const container = renderEmptyTreeForParent(42)
+
+  dispatchCreativeTreeStream({
+    action: 'created',
+    creative: { id: 7, parent_id: 42, level: 2, sequence: 0 },
+  })
+
+  expect(container.querySelector('creative-tree-row[creative-id="7"]')).not.toBeNull()
+  expect(container.querySelector('[data-creatives-empty-state]').hidden).toBe(true)
+})
+
+test('remote destroyed streams restore the empty-state placeholder for the last row', () => {
+  const container = renderEmptyTreeForParent(42)
+  dispatchCreativeTreeStream({
+    action: 'created',
+    creative: { id: 7, parent_id: 42, level: 2, sequence: 0 },
+  })
+
+  dispatchCreativeTreeStream({
+    action: 'destroyed',
+    creative: { id: 7, parent_id: 42 },
+  })
+
+  expect(container.querySelector('creative-tree-row')).toBeNull()
+  expect(container.querySelector('[data-creatives-empty-state]').hidden).toBe(false)
+})
+
+test('remote destroyed streams keep the placeholder hidden while rows remain', () => {
+  const container = renderEmptyTreeForParent(42)
+  dispatchCreativeTreeStream({
+    action: 'created',
+    creative: { id: 7, parent_id: 42, level: 2, sequence: 0 },
+  })
+  dispatchCreativeTreeStream({
+    action: 'created',
+    creative: { id: 8, parent_id: 42, level: 2, sequence: 1 },
+  })
+
+  dispatchCreativeTreeStream({
+    action: 'destroyed',
+    creative: { id: 7, parent_id: 42 },
+  })
+
+  expect(container.querySelector('creative-tree-row[creative-id="8"]')).not.toBeNull()
+  expect(container.querySelector('[data-creatives-empty-state]').hidden).toBe(true)
+})
+
+test('remote progress updates keep checkbox controls actionable', () => {
+  const row = {
+    dataset: {},
+    progressHtml: '<span class="progress-toggle-wrap" data-progress-toggle="true" data-current-progress="0" data-new-progress="1" data-mark-complete="Mark complete" data-mark-incomplete="Mark incomplete" title="Mark complete"><input type="checkbox" class="progress-toggle-checkbox"></span>',
+  }
+
+  updateProgressForRow(row, 1, '100%')
+
+  expect(row.progressHtml).toContain('checked="checked"')
+  expect(row.progressHtml).toContain('data-current-progress="1"')
+  expect(row.progressHtml).toContain('data-new-progress="0"')
+  expect(row.progressHtml).toContain('title="Mark incomplete"')
+})
+
+test('remote child creation changes the parent checkbox into its rollup control', () => {
+  document.body.innerHTML = '<div id="creatives"><creative-tree-row creative-id="42"></creative-tree-row></div>'
+  const parent = document.querySelector('creative-tree-row[creative-id="42"]')
+  parent.progressHtml = '<span data-progress-toggle="true"><input class="progress-toggle-checkbox"></span>'
+  parent.dataset.progressHtml = parent.progressHtml
+
+  dispatchCreativeTreeStream({
+    action: 'created',
+    creative: {
+      id: 7,
+      parent_id: 42,
+      level: 2,
+      sequence: 0,
+      ancestors: [{ id: 42, progress: 0.5, progress_html: '<span class="creative-progress-incomplete">50%</span>' }],
+    },
+  })
+
+  expect(parent.hasChildren).toBe(true)
+  expect(parent.progressHtml).toBe('<span class="creative-progress-incomplete">50%</span>')
+})
+
+test('remote child deletion restores the parent leaf checkbox control', () => {
+  document.body.innerHTML = `
+    <div id="creatives">
+      <creative-tree-row creative-id="42" has-children></creative-tree-row>
+      <div id="creative-children-42"><creative-tree-row creative-id="7"></creative-tree-row></div>
+    </div>
+  `
+  const parent = document.querySelector('creative-tree-row[creative-id="42"]')
+  parent.hasChildren = true
+  parent.progressHtml = '<span class="creative-progress-incomplete">0%</span>'
+  parent.dataset.progressHtml = parent.progressHtml
+  const checkbox = '<span data-progress-toggle="true"><input class="progress-toggle-checkbox"></span>'
+
+  dispatchCreativeTreeStream({
+    action: 'destroyed',
+    creative: {
+      id: 7,
+      parent_id: 42,
+      ancestors: [{ id: 42, progress: 0, progress_html: checkbox }],
+    },
+  })
+
+  expect(parent.hasChildren).toBe(false)
+  expect(parent.progressHtml).toBe(checkbox)
+})

data/app/javascript/lib/api/__tests__/creatives.test.js

@@ -0,0 +1,68 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from '@jest/globals'
+
+const csrfFetch = jest.fn()
+
+jest.unstable_mockModule('../csrf_fetch', () => ({ default: csrfFetch }))
+
+const creativesApi = await import('../creatives')
+
+describe('creatives API workspace invalidation', () => {
+  afterEach(() => {
+    csrfFetch.mockReset()
+  })
+
+  test('invalidates the workspace tree after a successful mutation', async () => {
+    const listener = jest.fn()
+    document.addEventListener('workspace-tree:invalidate', listener)
+    csrfFetch.mockResolvedValue({ ok: true })
+
+    await creativesApi.destroy(42)
+
+    expect(listener).toHaveBeenCalledTimes(1)
+    document.removeEventListener('workspace-tree:invalidate', listener)
+  })
+
+  test('does not invalidate the workspace tree after a failed mutation', async () => {
+    const listener = jest.fn()
+    document.addEventListener('workspace-tree:invalidate', listener)
+    csrfFetch.mockResolvedValue({ ok: false })
+
+    await creativesApi.archive(42)
+
+    expect(listener).not.toHaveBeenCalled()
+    document.removeEventListener('workspace-tree:invalidate', listener)
+  })
+
+  test('creates a rich-authored Markdown creative from a picker title', async () => {
+    const listener = jest.fn()
+    document.addEventListener('workspace-tree:invalidate', listener)
+    csrfFetch.mockResolvedValue({ ok: true, json: () => Promise.resolve({ id: 17 }) })
+
+    await expect(creativesApi.createFromTitle('New page')).resolves.toEqual({ id: 17 })
+
+    const [, options] = csrfFetch.mock.calls[0]
+    expect(csrfFetch.mock.calls[0][0]).toBe('/creatives')
+    expect(options.method).toBe('POST')
+    expect(options.body.get('creative[markdown_source]')).toBe('New page')
+    expect(options.body.get('creative[content_type_input]')).toBe('markdown')
+    expect(options.body.get('creative[markdown_editor]')).toBe('rich')
+    expect(listener).toHaveBeenCalledTimes(1)
+    document.removeEventListener('workspace-tree:invalidate', listener)
+  })
+
+  test('rejects a failed picker creation without invalidating the workspace tree', async () => {
+    const listener = jest.fn()
+    document.addEventListener('workspace-tree:invalidate', listener)
+    csrfFetch.mockResolvedValue({ ok: false, status: 422 })
+
+    await expect(creativesApi.createFromTitle('Invalid')).rejects.toThrow(
+      'Failed to create creative: 422',
+    )
+    expect(listener).not.toHaveBeenCalled()
+    document.removeEventListener('workspace-tree:invalidate', listener)
+  })
+})

data/app/javascript/lib/api/__tests__/csrf_fetch.test.js

@@ -0,0 +1,27 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from '@jest/globals'
+import { refreshCsrfToken } from '../csrf_fetch'
+
+describe('refreshCsrfToken', () => {
+  afterEach(() => {
+    delete global.fetch
+  })
+
+  test('marks the refresh as a prefetch and passes through cancellation', async () => {
+    const signal = new AbortController().signal
+    const fetchMock = jest.fn().mockResolvedValue({ headers: new Headers() })
+    global.fetch = fetchMock
+
+    await refreshCsrfToken({ signal })
+
+    expect(fetchMock).toHaveBeenCalledWith(window.location.href, {
+      method: 'HEAD',
+      credentials: 'same-origin',
+      headers: { 'X-Sec-Purpose': 'prefetch' },
+      signal,
+    })
+  })
+})

data/app/javascript/lib/api/__tests__/topics_save_last_topic.test.js

@@ -0,0 +1,112 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from '@jest/globals'
+import { saveLastTopic } from '../topics'
+
+// update_last_topic broadcasts to every session of the saving user, and the
+// broadcast echoes back whatever client_id the save carried. That id is the
+// only thing that tells the session which made the save apart from a sibling
+// session that happened to pick the same topic, so it has to reach the server.
+describe('saveLastTopic', () => {
+  const bodyOfLastCall = () => JSON.parse(global.fetch.mock.calls.at(-1)[1].body)
+
+  beforeEach(() => {
+    document.head.innerHTML = '<meta name="csrf-token" content="test-csrf">'
+    global.fetch = jest.fn().mockImplementation((url, options) => {
+      if (options?.method === 'POST') {
+        return Promise.resolve({ ok: true, json: async () => ({ last_topic_save_fence: 1 }) })
+      }
+      return Promise.resolve({ ok: true, json: async () => ({}) })
+    })
+  })
+
+  afterEach(() => {
+    document.head.innerHTML = ''
+    delete global.fetch
+    jest.clearAllMocks()
+  })
+
+  test('sends the client id alongside the topic', async () => {
+    await expect(saveLastTopic('42', '3', 'save-abc')).resolves.toEqual({ success: true, lastTopicRevision: undefined })
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      '/creatives/42/user_creative_preferences/update_last_topic',
+      expect.objectContaining({ method: 'PATCH' }),
+    )
+    expect(bodyOfLastCall()).toEqual({ last_topic_id: '3', client_id: 'save-abc', last_topic_save_fence: 1 })
+  })
+
+  test('forwards an abort signal to the request', async () => {
+    const abortController = new AbortController()
+
+    await saveLastTopic('42', '3', 'save-abc', abortController.signal)
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      '/creatives/42/user_creative_preferences/update_last_topic',
+      expect.objectContaining({ signal: abortController.signal }),
+    )
+  })
+
+  test('sends null for both when clearing the selection anonymously', async () => {
+    await saveLastTopic('42', null)
+
+    expect(bodyOfLastCall()).toEqual({ last_topic_id: null, client_id: null, last_topic_save_fence: 1 })
+  })
+
+  test('reports a rejected save rather than throwing', async () => {
+    global.fetch.mockResolvedValue({ ok: false })
+
+    await expect(saveLastTopic('42', '3', 'save-abc')).resolves.toBe(false)
+  })
+
+  test('reports a stale ordered save as definitively rejected', async () => {
+    global.fetch.mockResolvedValueOnce({ ok: true, json: async () => ({ last_topic_save_fence: 1 }) })
+    global.fetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ success: false, stale_last_topic_save: true, last_topic_revision: [5, 2] }),
+    })
+
+    await expect(saveLastTopic('42', '3', 'save-abc')).resolves.toEqual({
+      success: false,
+      staleLastTopicSave: true,
+      lastTopicRevision: [5, 2],
+    })
+  })
+
+  test('does not PATCH when issuing the save fence is ambiguous', async () => {
+    global.fetch.mockResolvedValue({ ok: false, status: 502 })
+
+    await expect(saveLastTopic('42', '3', 'save-abc')).resolves.toBeNull()
+    expect(global.fetch).toHaveBeenCalledTimes(1)
+  })
+
+  test('falls back to the legacy PATCH when an older server lacks the fence endpoint', async () => {
+    global.fetch.mockResolvedValueOnce({ ok: false, status: 404 })
+    global.fetch.mockResolvedValueOnce({ ok: true, json: async () => ({}) })
+
+    await expect(saveLastTopic('42', '3', 'save-abc')).resolves.toEqual({ success: true, lastTopicRevision: undefined })
+
+    expect(global.fetch).toHaveBeenCalledTimes(2)
+    // No fence key at all: an older bundle cannot send one either, and the
+    // PATCH handler retires outstanding fences for every unfenced save.
+    expect(bodyOfLastCall()).toEqual({
+      last_topic_id: '3',
+      client_id: 'save-abc',
+    })
+  })
+
+  test('reports an ambiguous network failure separately from an HTTP rejection', async () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {})
+    global.fetch.mockRejectedValue(new Error('offline'))
+
+    await expect(saveLastTopic('42', '3', 'save-abc')).resolves.toBeNull()
+  })
+
+  test.each([ 502, 504 ])('treats gateway status %i as an ambiguous delivery', async (status) => {
+    global.fetch.mockResolvedValue({ ok: false, status })
+
+    await expect(saveLastTopic('42', '3', 'save-abc')).resolves.toBeNull()
+  })
+})

data/app/javascript/lib/api/creatives.js

@@ -2,14 +2,15 @@ import csrfFetch from './csrf_fetch'
 
 const JSON_HEADERS = { Accept: 'application/json' }
 
-export function get(id) {
-  return csrfFetch(`/creatives/${id}.json`, {
-    headers: JSON_HEADERS,
-  }).then((response) => response.json())
+function invalidateWorkspaceTreeOnSuccess(response) {
+  if (response.ok && typeof document !== 'undefined') {
+    document.dispatchEvent(new CustomEvent('workspace-tree:invalidate'))
+  }
+  return response
 }
 
-export function parentSuggestions(id) {
-  return csrfFetch(`/creatives/${id}/parent_suggestions.json`, {
+export function get(id) {
+  return csrfFetch(`/creatives/${id}.json`, {
     headers: JSON_HEADERS,
   }).then((response) => response.json())
 }
@@ -43,12 +44,30 @@ export function search(query, { simple = false } = {}) {
   }).then((response) => response.json())
 }
 
+export function createFromTitle(title) {
+  const body = new FormData()
+  body.append('creative[description]', title)
+  body.append('creative[content_type_input]', 'markdown')
+  body.append('creative[markdown_source]', title)
+  body.append('creative[markdown_editor]', 'rich')
+
+  return csrfFetch('/creatives', {
+    method: 'POST',
+    headers: JSON_HEADERS,
+    body,
+  }).then((response) => {
+    if (!response.ok) throw new Error(`Failed to create creative: ${response.status}`)
+    invalidateWorkspaceTreeOnSuccess(response)
+    return response.json()
+  })
+}
+
 export function save(action, method, form) {
   return csrfFetch(action, {
     method,
     headers: JSON_HEADERS,
     body: new FormData(form),
-  })
+  }).then(invalidateWorkspaceTreeOnSuccess)
 }
 
 export function linkExisting(parentId, originId) {
@@ -60,33 +79,33 @@ export function linkExisting(parentId, originId) {
     method: 'POST',
     headers: JSON_HEADERS,
     body,
-  })
+  }).then(invalidateWorkspaceTreeOnSuccess)
 }
 
 export function destroy(id, withChildren = false) {
   const query = withChildren ? '?delete_with_children=true' : ''
   return csrfFetch(`/creatives/${id}${query}`, {
     method: 'DELETE',
-  })
+  }).then(invalidateWorkspaceTreeOnSuccess)
 }
 
 export function archive(id) {
   return csrfFetch(`/creatives/${id}/archive`, {
     method: 'PATCH',
-  })
+  }).then(invalidateWorkspaceTreeOnSuccess)
 }
 
 export function unarchive(id) {
   return csrfFetch(`/creatives/${id}/unarchive`, {
     method: 'PATCH',
-  })
+  }).then(invalidateWorkspaceTreeOnSuccess)
 }
 
 export function unconvert(id) {
   return csrfFetch(`/creatives/${id}/unconvert`, {
     method: 'POST',
     headers: JSON_HEADERS,
-  })
+  }).then(invalidateWorkspaceTreeOnSuccess)
 }
 
 export function updateMetadata(id, data) {
@@ -102,10 +121,10 @@ export function updateMetadata(id, data) {
 
 const creativesApi = {
   get,
-  parentSuggestions,
   loadChildren,
   browse,
   search,
+  createFromTitle,
   save,
   linkExisting,
   destroy,

data/app/javascript/lib/api/csrf_fetch.js

@@ -20,15 +20,17 @@ export function updateCsrfTokenFromResponse(response) {
 }
 
 /**
- * Fetch a fresh CSRF token from the server.  Uses a lightweight HEAD
- * request to the current page — the response body is discarded but the
- * X-CSRF-Token header gives us a valid token.
+ * Fetch a fresh CSRF token from the server. Uses a lightweight HEAD request
+ * marked as a prefetch so endpoints that record ordinary visits do not treat
+ * the refresh as navigation.
  */
-export async function refreshCsrfToken() {
+export async function refreshCsrfToken({ signal } = {}) {
   try {
     const response = await fetch(window.location.href, {
       method: 'HEAD',
       credentials: 'same-origin',
+      headers: { 'X-Sec-Purpose': 'prefetch' },
+      signal,
     })
     updateCsrfTokenFromResponse(response)
     return readCsrfToken()

data/app/javascript/lib/api/topics.js

@@ -30,22 +30,80 @@ export async function fetchNextTopicName(creativeId) {
  * Save the last selected topic for a creative (server-side persistence).
  * @param {string|number} creativeId
  * @param {string|number|null} topicId
- * @returns {Promise<boolean>}
+ * @param {string} [clientId] - echoed back on the broadcast, so the session
+ *   that made this save can recognise it and not treat it as someone else's
+ * @param {AbortSignal} [signal] - cancels a request that can no longer keep
+ *   later selections waiting
+ * @returns {Promise<{success: true, lastTopicRevision: unknown}|boolean|null>} `null` means the request outcome is unknown
+ *   (for example, a network failure after the server received the request).
  */
-export async function saveLastTopic(creativeId, topicId) {
+export async function saveLastTopic(creativeId, topicId, clientId, signal) {
     try {
+        const saveFence = await issueLastTopicSaveFence(creativeId, signal)
+        if (saveFence !== undefined && !Number.isSafeInteger(saveFence)) return saveFence
+
+        const body = { last_topic_id: topicId || null, client_id: clientId || null }
+        // An undefined fence means this client fell back through an older
+        // instance. The PATCH handler retires outstanding fences for every
+        // unfenced save, so the fallback needs no marker of its own — an older
+        // bundle cannot send one either, and it is the case that has to be
+        // ordered correctly.
+        if (saveFence !== undefined) body.last_topic_save_fence = saveFence
+
         const response = await fetch(`/creatives/${creativeId}/user_creative_preferences/update_last_topic`, {
             method: 'PATCH',
             headers: {
                 'Content-Type': 'application/json',
                 'X-CSRF-Token': csrfToken()
             },
-            body: JSON.stringify({ last_topic_id: topicId || null })
+            body: JSON.stringify(body),
+            signal
         })
-        return response.ok
+        // A 5xx response can have been generated by a gateway after Rails
+        // committed and broadcast the update, so it cannot prove the save did
+        // not land. Only an application-level rejection is definitive.
+        if (response.ok) {
+            let data = {}
+            try {
+                data = await response.json()
+            } catch (_) {
+                // Older servers returned an empty success response. Keep accepting it
+                // while newer servers provide the revision that orders delayed echoes.
+            }
+            if (data.success === false) {
+                return data.stale_last_topic_save === true
+                    ? { success: false, staleLastTopicSave: true, lastTopicRevision: data.last_topic_revision }
+                    : false
+            }
+            return { success: true, lastTopicRevision: data.last_topic_revision }
+        }
+        return response.status >= 500 ? null : false
     } catch (e) {
         console.error('Error saving last topic', e)
-        return false
+        return null
+    }
+}
+
+async function issueLastTopicSaveFence(creativeId, signal) {
+    try {
+        const response = await fetch(`/creatives/${creativeId}/user_creative_preferences/update_last_topic`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRF-Token': csrfToken()
+            },
+            signal
+        })
+        // During a rolling deploy, an older instance does not have the POST
+        // fence endpoint yet. Its PATCH endpoint remains compatible with the
+        // pre-fence request body, so save through that endpoint instead.
+        if (response.status === 404) return undefined
+        if (!response.ok) return response.status >= 500 ? null : false
+        const data = await response.json()
+        return Number.isSafeInteger(data.last_topic_save_fence) ? data.last_topic_save_fence : null
+    } catch (e) {
+        console.error('Error issuing last topic save fence', e)
+        return null
     }
 }