@codingfactory/socialkit-vue 0.7.23 → 0.7.24

package/src/stores/__tests__/discussion.spec.ts

@@ -0,0 +1,945 @@
+import axios, { type AxiosInstance, type AxiosRequestConfig, type AxiosResponse, type GenericAbortSignal, type InternalAxiosRequestConfig } from 'axios'
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { ref } from 'vue'
+import { createDiscussionStoreDefinition, type DiscussionStoreReturn } from '../discussion.js'
+import type { DiscussionLoadingState, Reply, Space, Thread } from '../../types/discussion.js'
+
+function createLoadingState(): DiscussionLoadingState {
+  const isLoading = ref(false)
+  const error = ref<Error | null>(null)
+  const isEmpty = ref(false)
+
+  return {
+    isLoading,
+    error,
+    isEmpty,
+    setLoading(loading: boolean): void {
+      isLoading.value = loading
+    },
+    setError(nextError: Error | null): void {
+      error.value = nextError
+    },
+    setEmpty(empty: boolean): void {
+      isEmpty.value = empty
+    },
+  }
+}
+
+function createDeferred<T>(): {
+  promise: Promise<T>
+  resolve: (value: T | PromiseLike<T>) => void
+  reject: (reason?: unknown) => void
+} {
+  let resolve!: (value: T | PromiseLike<T>) => void
+  let reject!: (reason?: unknown) => void
+
+  const promise = new Promise<T>((innerResolve, innerReject) => {
+    resolve = innerResolve
+    reject = innerReject
+  })
+
+  return {
+    promise,
+    resolve,
+    reject,
+  }
+}
+
+function createResponse<T>(config: AxiosRequestConfig, data: T): AxiosResponse<T> {
+  return {
+    data,
+    status: 200,
+    statusText: 'OK',
+    headers: {},
+    // Axios response objects carry the same request config shape in practice;
+    // the tests only need a stable config echo, not internal adapter headers.
+    config: config as InternalAxiosRequestConfig,
+  }
+}
+
+function readRequestBody(config: AxiosRequestConfig): unknown {
+  if (typeof config.data === 'string') {
+    return JSON.parse(config.data) as unknown
+  }
+
+  return config.data
+}
+
+function createSpace(spaceId: string, slug: string, name: string): Space {
+  return {
+    id: spaceId,
+    slug,
+    name,
+    kind: 'forum',
+    created_at: '2026-03-08T06:00:00.000Z',
+  }
+}
+
+function createThread(threadId: string, overrides: Partial<Thread> = {}): Thread {
+  return {
+    id: threadId,
+    space_id: overrides.space_id ?? 'space-1',
+    author_id: overrides.author_id ?? 'author-1',
+    title: overrides.title ?? 'Thread title',
+    body: overrides.body ?? 'Thread body',
+    audience: overrides.audience ?? 'public',
+    status: overrides.status ?? 'open',
+    is_pinned: overrides.is_pinned ?? false,
+    reply_count: overrides.reply_count ?? 0,
+    last_activity_at: overrides.last_activity_at ?? '2026-03-08T06:23:34.000Z',
+    created_at: overrides.created_at ?? '2026-03-08T06:00:00.000Z',
+    ...(overrides.author ? { author: overrides.author } : {}),
+    ...(overrides.slug ? { slug: overrides.slug } : {}),
+    ...(overrides.body !== undefined ? { body: overrides.body } : {}),
+    ...(overrides.meta ? { meta: overrides.meta } : {}),
+    ...(overrides.space ? { space: overrides.space } : {}),
+    ...(overrides.latest_reply ? { latest_reply: overrides.latest_reply } : {}),
+    ...(overrides.tags ? { tags: overrides.tags } : {}),
+    ...(overrides.deleted_at !== undefined ? { deleted_at: overrides.deleted_at } : {}),
+  }
+}
+
+function createReply(replyId: string): Reply {
+  return {
+    id: replyId,
+    thread_id: 'thread-1',
+    author_id: 'author-1',
+    body: 'Reply body',
+    parent_reply_id: null,
+    depth: 0,
+    display_depth: 0,
+    created_at: '2026-03-08T06:10:00.000Z',
+    updated_at: '2026-03-08T06:10:00.000Z',
+  }
+}
+
+interface FakeEchoChannel {
+  listen: (event: string, callback: (payload: unknown) => void) => FakeEchoChannel
+}
+
+interface FakeEcho {
+  private: (channelName: string) => FakeEchoChannel
+  leave: (channelName: string) => void
+}
+
+interface CreateStoreOptions {
+  getEcho?: () => FakeEcho | null
+}
+
+function hasAbortListener(
+  signal: GenericAbortSignal | undefined,
+): signal is GenericAbortSignal & {
+  addEventListener: NonNullable<GenericAbortSignal['addEventListener']>
+} {
+  return typeof signal?.addEventListener === 'function'
+}
+
+function createEchoHarness(): {
+  echo: FakeEcho
+  threadListeners: Record<string, (payload: unknown) => void>
+  privateMock: ReturnType<typeof vi.fn<(channelName: string) => FakeEchoChannel>>
+  leaveMock: ReturnType<typeof vi.fn<(channelName: string) => void>>
+} {
+  const threadListeners: Record<string, (payload: unknown) => void> = {}
+  const channel: FakeEchoChannel = {
+    listen(event: string, callback: (payload: unknown) => void): FakeEchoChannel {
+      threadListeners[event] = callback
+      return channel
+    },
+  }
+  const privateMock = vi.fn<(channelName: string) => FakeEchoChannel>(() => channel)
+  const leaveMock = vi.fn<(channelName: string) => void>()
+
+  return {
+    echo: {
+      private: privateMock,
+      leave: leaveMock,
+    },
+    threadListeners,
+    privateMock,
+    leaveMock,
+  }
+}
+
+function createStore(client: AxiosInstance, options: CreateStoreOptions = {}): DiscussionStoreReturn {
+  const useDiscussionStore = createDiscussionStoreDefinition({
+    client,
+    getCurrentUserId: () => 'author-me',
+    getEcho: options.getEcho ?? (() => null),
+    onEchoInitialized: () => undefined,
+    onEchoReconnected: () => undefined,
+    createLoadingState,
+    logger: {
+      error: () => undefined,
+    },
+    storeId: `discussion-test-${Math.random().toString(36).slice(2)}`,
+  })
+
+  return useDiscussionStore()
+}
+
+describe('discussion store', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+  })
+
+  it('populates the latest browse list and normalizes reply counts', async () => {
+    const latestThread = createThread('thread-latest', { reply_count: 4 })
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        if ((config.method ?? 'get').toLowerCase() === 'get' && config.url === '/v1/discussion/threads/latest') {
+          return createResponse(config, {
+            data: [latestThread],
+            next_cursor: 'cursor-latest-2',
+          })
+        }
+
+        throw new Error(`Unhandled request: ${(config.method ?? 'get').toUpperCase()} ${config.url ?? ''}`)
+      },
+    })
+
+    const store = createStore(client)
+
+    await store.browseThreads('latest')
+
+    expect(store.currentBrowseMode).toBe('latest')
+    expect(store.browseThreadList).toHaveLength(1)
+    expect(store.browseThreadList[0]?.id).toBe('thread-latest')
+    expect(store.browseThreadList[0]?.reply_count).toBe(3)
+    expect(store.browseNextCursor).toBe('cursor-latest-2')
+  })
+
+  it('replaces the browse list when switching from latest to unanswered', async () => {
+    const latestThread = createThread('thread-latest')
+    const unansweredThread = createThread('thread-unanswered', { reply_count: 1 })
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        const url = config.url ?? ''
+        if ((config.method ?? 'get').toLowerCase() !== 'get') {
+          throw new Error(`Unhandled request: ${(config.method ?? 'get').toUpperCase()} ${url}`)
+        }
+
+        if (url === '/v1/discussion/threads/latest') {
+          return createResponse(config, {
+            data: [latestThread],
+            next_cursor: 'cursor-latest-2',
+          })
+        }
+
+        if (url === '/v1/discussion/threads/unanswered') {
+          return createResponse(config, {
+            data: [unansweredThread],
+            next_cursor: null,
+          })
+        }
+
+        throw new Error(`Unhandled request: GET ${url}`)
+      },
+    })
+
+    const store = createStore(client)
+
+    await store.browseThreads('latest')
+    await store.browseThreads('unanswered')
+
+    expect(store.currentBrowseMode).toBe('unanswered')
+    expect(store.browseThreadList).toHaveLength(1)
+    expect(store.browseThreadList[0]?.id).toBe('thread-unanswered')
+    expect(store.browseNextCursor).toBeNull()
+  })
+
+  it('loads a thread and subscribes to the thread realtime channel', async () => {
+    const threadId = '123e4567-e89b-42d3-a456-426614174000'
+    const space = createSpace('space-1', 'glass-space', 'Glass Space')
+    const echoHarness = createEchoHarness()
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        if ((config.method ?? 'get').toLowerCase() === 'get' && config.url === `/v1/discussion/threads/${threadId}`) {
+          return createResponse(config, {
+            data: createThread(threadId, {
+              space_id: space.id,
+              reply_count: 4,
+            }),
+          })
+        }
+
+        throw new Error(`Unhandled request: ${(config.method ?? 'get').toUpperCase()} ${config.url ?? ''}`)
+      },
+    })
+
+    const store = createStore(client, {
+      getEcho: () => echoHarness.echo,
+    })
+    store.spaces = [space]
+
+    await store.loadThread(space.slug, threadId)
+
+    expect(store.currentThread?.id).toBe(threadId)
+    expect(store.currentThread?.reply_count).toBe(3)
+    expect(echoHarness.privateMock).toHaveBeenCalledWith(`discussions.thread.${threadId}`)
+  })
+
+  it('keeps the shared loading state true until overlapping requests settle', async () => {
+    const spacesDeferred = createDeferred<AxiosResponse<unknown>>()
+    const searchDeferred = createDeferred<AxiosResponse<unknown>>()
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        const url = config.url ?? ''
+        const method = (config.method ?? 'get').toLowerCase()
+
+        if (method === 'get' && url === '/v1/discussion/spaces?tree=1') {
+          return spacesDeferred.promise
+        }
+
+        if (method === 'get' && url.startsWith('/v1/discussion/search/threads?')) {
+          return searchDeferred.promise
+        }
+
+        throw new Error(`Unhandled request: ${method.toUpperCase()} ${url}`)
+      },
+    })
+
+    const store = createStore(client)
+
+    const loadSpacesPromise = store.loadSpaces()
+    const searchPromise = store.searchThreads('glass')
+
+    expect(store.loading).toBe(true)
+
+    spacesDeferred.resolve(createResponse({ url: '/v1/discussion/spaces?tree=1' }, { items: [] }))
+    await loadSpacesPromise
+
+    expect(store.loading).toBe(true)
+
+    searchDeferred.resolve(createResponse({ url: '/v1/discussion/search/threads?q=glass' }, { results: [] }))
+    await searchPromise
+
+    expect(store.loading).toBe(false)
+  })
+
+  it('loads spaces with scoped query parameters for management surfaces', async () => {
+    const scopedSpace = createSpace('space-1', 'group-root', 'Group Root')
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        expect((config.method ?? 'get').toLowerCase()).toBe('get')
+        expect(config.url).toBe('/v1/discussion/spaces?tree=1&kind=forum&scope_id=circle-1')
+
+        return createResponse(config, {
+          items: [scopedSpace],
+        })
+      },
+    })
+
+    const store = createStore(client)
+
+    await store.loadSpaces({
+      kind: 'forum',
+      scope_id: 'circle-1',
+    })
+
+    expect(store.spaceTree).toHaveLength(1)
+    expect(store.spaceTree[0]?.slug).toBe('group-root')
+    expect(store.spaces).toHaveLength(1)
+    expect(store.spaces[0]?.id).toBe('space-1')
+  })
+
+  it('creates, moves, and reorders spaces through the management endpoints', async () => {
+    const requests: Array<{ method: string, url: string, body: unknown }> = []
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        const method = (config.method ?? 'get').toLowerCase()
+        const url = config.url ?? ''
+        requests.push({
+          method,
+          url,
+          body: readRequestBody(config),
+        })
+
+        if (method === 'post' && url === '/v1/discussion/spaces') {
+          return createResponse(config, {
+            data: createSpace('space-1', 'tips', 'Tips'),
+          })
+        }
+
+        if (method === 'post' && url === '/v1/discussion/spaces/space-1/move') {
+          return createResponse(config, {
+            data: createSpace('space-1', 'tips', 'Tips'),
+          })
+        }
+
+        if (method === 'post' && url === '/v1/discussion/spaces/reorder') {
+          return createResponse(config, {
+            data: true,
+          })
+        }
+
+        throw new Error(`Unhandled request: ${method.toUpperCase()} ${url}`)
+      },
+    })
+
+    const store = createStore(client)
+
+    await store.createSpace({
+      slug: 'tips',
+      name: 'Tips',
+      kind: 'forum',
+      scope_type: 'circle',
+      scope_id: 'circle-1',
+      visibility: 'private',
+      parent_id: 'space-root',
+      description: 'Scoped discussion tips',
+    })
+    await store.moveSpace('space-1', 'space-root')
+    await store.reorderSpaces(['space-1', 'space-2'])
+
+    expect(requests).toEqual([
+      {
+        method: 'post',
+        url: '/v1/discussion/spaces',
+        body: {
+          slug: 'tips',
+          name: 'Tips',
+          kind: 'forum',
+          scope_type: 'circle',
+          scope_id: 'circle-1',
+          visibility: 'private',
+          parent_id: 'space-root',
+          description: 'Scoped discussion tips',
+        },
+      },
+      {
+        method: 'post',
+        url: '/v1/discussion/spaces/space-1/move',
+        body: {
+          parent_id: 'space-root',
+        },
+      },
+      {
+        method: 'post',
+        url: '/v1/discussion/spaces/reorder',
+        body: {
+          ids: ['space-1', 'space-2'],
+        },
+      },
+    ])
+  })
+
+  it('clears reply state and resets the reply sort before loading a thread', async () => {
+    const threadDeferred = createDeferred<AxiosResponse<unknown>>()
+    const space = createSpace('space-1', 'glass-space', 'Glass Space')
+    const threadId = '123e4567-e89b-42d3-a456-426614174000'
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        const url = config.url ?? ''
+        const method = (config.method ?? 'get').toLowerCase()
+
+        if (method === 'get' && url === `/v1/discussion/threads/${threadId}`) {
+          return threadDeferred.promise
+        }
+
+        throw new Error(`Unhandled request: ${method.toUpperCase()} ${url}`)
+      },
+    })
+
+    const store = createStore(client)
+    store.spaces = [space]
+    store.currentSpace = space
+    store.replies = [createReply('reply-old')]
+    store.repliesNextCursor = 'cursor-1'
+    store.currentReplySort = 'new'
+
+    const loadThreadPromise = store.loadThread('glass-space', threadId)
+
+    expect(store.replies).toEqual([])
+    expect(store.repliesNextCursor).toBeNull()
+    expect(store.currentReplySort).toBe('best')
+    expect(store.loading).toBe(true)
+
+    threadDeferred.resolve(createResponse({ url: `/v1/discussion/threads/${threadId}` }, {
+      data: createThread(threadId, { space_id: space.id }),
+    }))
+    await loadThreadPromise
+
+    expect(store.currentThread?.id).toBe(threadId)
+  })
+
+  it('populates replies, stores the reply sort, and tracks the next cursor', async () => {
+    const threadId = 'thread-1'
+    const firstReply = createReply('reply-1')
+    const secondReply = createReply('reply-2')
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        if ((config.method ?? 'get').toLowerCase() === 'get' && config.url === `/v1/discussion/threads/${threadId}/replies?sort=new&format=tree&flatten=1`) {
+          return createResponse(config, {
+            data: [firstReply, secondReply],
+            next_cursor: 'cursor-replies-2',
+            meta: {
+              total: 2,
+            },
+          })
+        }
+
+        throw new Error(`Unhandled request: ${(config.method ?? 'get').toUpperCase()} ${config.url ?? ''}`)
+      },
+    })
+
+    const store = createStore(client)
+    store.currentThread = createThread(threadId, { body: '' })
+
+    await store.loadReplies(threadId, undefined, 'new')
+
+    expect(store.replies.map((reply) => reply.id)).toEqual(['reply-1', 'reply-2'])
+    expect(store.currentReplySort).toBe('new')
+    expect(store.repliesNextCursor).toBe('cursor-replies-2')
+  })
+
+  it('merges paginated replies without duplicating existing ids', async () => {
+    const threadId = 'thread-1'
+    const firstReply = createReply('reply-1')
+    const secondReply = createReply('reply-2')
+    const thirdReply = createReply('reply-3')
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        const url = config.url ?? ''
+        if ((config.method ?? 'get').toLowerCase() !== 'get') {
+          throw new Error(`Unhandled request: ${(config.method ?? 'get').toUpperCase()} ${url}`)
+        }
+
+        if (url === `/v1/discussion/threads/${threadId}/replies?sort=best&format=tree&flatten=1`) {
+          return createResponse(config, {
+            data: [firstReply, secondReply],
+            next_cursor: 'cursor-replies-2',
+            meta: {
+              total: 3,
+            },
+          })
+        }
+
+        if (url === `/v1/discussion/threads/${threadId}/replies?cursor=cursor-replies-2&sort=best&format=tree&flatten=1`) {
+          return createResponse(config, {
+            data: [secondReply, thirdReply],
+            next_cursor: null,
+            meta: {
+              total: 3,
+            },
+          })
+        }
+
+        throw new Error(`Unhandled request: GET ${url}`)
+      },
+    })
+
+    const store = createStore(client)
+    store.currentThread = createThread(threadId, { body: '' })
+
+    await store.loadReplies(threadId)
+    await store.loadReplies(threadId, 'cursor-replies-2')
+
+    expect(store.replies.map((reply) => reply.id)).toEqual(['reply-1', 'reply-2', 'reply-3'])
+    expect(store.repliesNextCursor).toBeNull()
+  })
+
+  it('adds a created reply to the active thread and increments reply counts', async () => {
+    const threadId = 'thread-1'
+    const createdReply = createReply('reply-created')
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        if ((config.method ?? 'post').toLowerCase() === 'post' && config.url === `/v1/discussion/threads/${threadId}/replies`) {
+          return createResponse(config, {
+            data: createdReply,
+          })
+        }
+
+        throw new Error(`Unhandled request: ${(config.method ?? 'post').toUpperCase()} ${config.url ?? ''}`)
+      },
+    })
+
+    const store = createStore(client)
+    store.currentThread = createThread(threadId, { body: '', reply_count: 0 })
+    store.threads = [createThread(threadId, { body: '', reply_count: 0 })]
+
+    await store.createReply(threadId, {
+      body: 'Fresh reply',
+    })
+
+    expect(store.replies.map((reply) => reply.id)).toEqual(['reply-created'])
+    expect(store.currentThread?.reply_count).toBe(1)
+    expect(store.threads[0]?.reply_count).toBe(1)
+  })
+
+  it('inserts new realtime top-level replies at the top when the active sort is new', async () => {
+    const threadId = 'thread-1'
+    const firstReply = createReply('reply-1')
+    const realtimeReply = createReply('reply-live')
+    const echoHarness = createEchoHarness()
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        if ((config.method ?? 'get').toLowerCase() === 'get' && config.url === `/v1/discussion/threads/${threadId}/replies?sort=new&format=tree&flatten=1`) {
+          return createResponse(config, {
+            data: [firstReply],
+            next_cursor: null,
+            meta: {
+              total: 1,
+            },
+          })
+        }
+
+        throw new Error(`Unhandled request: ${(config.method ?? 'get').toUpperCase()} ${config.url ?? ''}`)
+      },
+    })
+
+    const store = createStore(client, {
+      getEcho: () => echoHarness.echo,
+    })
+    store.currentThread = createThread(threadId, { body: '', reply_count: 1 })
+
+    await store.loadReplies(threadId, undefined, 'new')
+    echoHarness.threadListeners['.Discussion.ReplyCreated']?.(realtimeReply)
+
+    expect(store.replies.map((reply) => reply.id)).toEqual(['reply-live', 'reply-1'])
+  })
+
+  it('inserts new realtime top-level replies at the bottom for non-new sorts', async () => {
+    const threadId = 'thread-1'
+    const firstReply = createReply('reply-1')
+    const realtimeReply = createReply('reply-live')
+    const echoHarness = createEchoHarness()
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        if ((config.method ?? 'get').toLowerCase() === 'get' && config.url === `/v1/discussion/threads/${threadId}/replies?sort=best&format=tree&flatten=1`) {
+          return createResponse(config, {
+            data: [firstReply],
+            next_cursor: null,
+            meta: {
+              total: 1,
+            },
+          })
+        }
+
+        throw new Error(`Unhandled request: ${(config.method ?? 'get').toUpperCase()} ${config.url ?? ''}`)
+      },
+    })
+
+    const store = createStore(client, {
+      getEcho: () => echoHarness.echo,
+    })
+    store.currentThread = createThread(threadId, { body: '', reply_count: 1 })
+
+    await store.loadReplies(threadId)
+    echoHarness.threadListeners['.Discussion.ReplyCreated']?.(realtimeReply)
+
+    expect(store.replies.map((reply) => reply.id)).toEqual(['reply-1', 'reply-live'])
+  })
+
+  it('does not set an error when a global thread search is aborted', async () => {
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        const signal = config.signal
+        if (!hasAbortListener(signal)) {
+          throw new Error('Expected axios request signal support in test adapter')
+        }
+
+        return await new Promise<AxiosResponse>((_resolve, reject) => {
+          signal.addEventListener('abort', () => {
+            reject(new Error('Request aborted'))
+          }, { once: true })
+        })
+      },
+    })
+
+    const store = createStore(client)
+    const controller = new AbortController()
+
+    const searchPromise = store.searchThreadsGlobally('glass', { signal: controller.signal })
+    controller.abort()
+
+    await expect(searchPromise).resolves.toEqual([])
+    expect(store.error).toBeNull()
+  })
+
+  it('populates space summary on global search results when space fields are present', async () => {
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        return createResponse(config, {
+          data: {
+            results: [
+              {
+                id: 'thread-gs-1',
+                title: 'Fume extraction setup',
+                space_id: 'space-safety',
+                space_name: 'Safety & Ventilation',
+                space_slug: 'safety-ventilation',
+                author_id: 'author-1',
+                author_name: 'Artist One',
+                author_handle: 'artist-one',
+                created_at: '2026-03-10T09:00:00.000Z',
+                updated_at: '2026-03-10T09:30:00.000Z',
+                replies_count: 4,
+              },
+            ],
+          },
+        })
+      },
+    })
+
+    const store = createStore(client)
+    const results = await store.searchThreadsGlobally('fume')
+
+    expect(results).toHaveLength(1)
+    expect(results[0]?.space).toEqual({
+      id: 'space-safety',
+      slug: 'safety-ventilation',
+      name: 'Safety & Ventilation',
+    })
+  })
+
+  it('forwards AbortSignal to in-space thread searches', async () => {
+    let capturedSignal: GenericAbortSignal | undefined
+    const controller = new AbortController()
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        capturedSignal = config.signal
+
+        return createResponse(config, {
+          data: {
+            results: [
+              {
+                id: 'thread-search-1',
+                title: 'Torch settings for clean seals',
+                space_id: 'space-1',
+                author_id: 'author-1',
+                author_name: 'Artist One',
+                author_handle: 'artist-one',
+                created_at: '2026-03-08T06:00:00.000Z',
+                updated_at: '2026-03-08T06:10:00.000Z',
+                replies_count: 2,
+              },
+            ],
+          },
+        })
+      },
+    })
+
+    const store = createStore(client)
+
+    const invokeSearch = (
+      search: (query: string, spaceId: string, options?: { signal?: AbortSignal }) => Promise<Thread[]>,
+    ): Promise<Thread[]> => {
+      return search('torch', 'space-1', { signal: controller.signal })
+    }
+
+    const results = await invokeSearch(store.searchThreadsInSpace)
+
+    expect(capturedSignal).toBe(controller.signal)
+    expect(results.map((thread) => thread.id)).toEqual(['thread-search-1'])
+  })
+
+  it('sets a not-found error when loading a missing thread', async () => {
+    const threadId = 'missing-thread'
+    const client = axios.create({
+      adapter: async (_config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        throw {
+          isAxiosError: true,
+          response: {
+            status: 404,
+          },
+        }
+      },
+    })
+
+    const store = createStore(client)
+
+    await expect(store.loadThread('glass-space', threadId)).rejects.toMatchObject({
+      response: {
+        status: 404,
+      },
+    })
+    expect(store.error).toBe('Thread not found or has been deleted')
+  })
+
+  it('sets a permission error when loading a forbidden thread', async () => {
+    const threadId = 'forbidden-thread'
+    const client = axios.create({
+      adapter: async (_config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        throw {
+          isAxiosError: true,
+          response: {
+            status: 403,
+          },
+        }
+      },
+    })
+
+    const store = createStore(client)
+
+    await expect(store.loadThread('glass-space', threadId)).rejects.toMatchObject({
+      response: {
+        status: 403,
+      },
+    })
+    expect(store.error).toBe('You do not have permission to view this thread')
+  })
+
+  it('replaces stale destination space metadata when moving a thread', async () => {
+    const moveDeferred = createDeferred<AxiosResponse<unknown>>()
+    const sourceSpace = createSpace('space-source', 'source-space', 'Source Space')
+    const destinationSpace = createSpace('space-destination', 'destination-space', 'Destination Space')
+    const sourceSummary = {
+      id: sourceSpace.id,
+      slug: sourceSpace.slug,
+      name: sourceSpace.name,
+    }
+    const destinationSummary = {
+      id: destinationSpace.id,
+      slug: destinationSpace.slug,
+      name: destinationSpace.name,
+    }
+    const staleMovedThread = createThread('thread-1', {
+      space_id: destinationSpace.id,
+      space: sourceSummary,
+    })
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        const url = config.url ?? ''
+        const method = (config.method ?? 'get').toLowerCase()
+
+        if (method === 'post' && url === '/v1/discussion/threads/thread-1/move') {
+          return moveDeferred.promise
+        }
+
+        throw new Error(`Unhandled request: ${method.toUpperCase()} ${url}`)
+      },
+    })
+
+    const store = createStore(client)
+    store.spaces = [sourceSpace, destinationSpace]
+    store.currentSpace = destinationSpace
+    store.currentThread = createThread('thread-1', {
+      space_id: sourceSpace.id,
+      space: sourceSummary,
+    })
+    store.threads = [
+      createThread('thread-1', {
+        space_id: sourceSpace.id,
+        space: sourceSummary,
+      }),
+    ]
+
+    const moveThreadPromise = store.moveThread('thread-1', 'destination-space')
+
+    moveDeferred.resolve(createResponse({ url: '/v1/discussion/threads/thread-1/move' }, {
+      data: staleMovedThread,
+    }))
+    await moveThreadPromise
+
+    expect(store.currentThread?.space).toEqual(destinationSummary)
+    expect(store.currentThread?.space_id).toBe(destinationSpace.id)
+    expect(store.threads[0]?.space).toEqual(destinationSummary)
+    expect(store.threads[0]?.space_id).toBe(destinationSpace.id)
+  })
+
+  it('preserves is_author flag when a realtime ReplyUpdated broadcast overwrites a reply', async () => {
+    const threadId = 'thread-1'
+    const replyWithAuthorFlag = {
+      ...createReply('reply-1'),
+      is_author: true,
+    }
+    const echoHarness = createEchoHarness()
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        if ((config.method ?? 'get').toLowerCase() === 'get'
+          && config.url === `/v1/discussion/threads/${threadId}/replies?sort=best&format=tree&flatten=1`) {
+          return createResponse(config, {
+            data: [replyWithAuthorFlag],
+            next_cursor: null,
+            meta: { total: 1 },
+          })
+        }
+
+        throw new Error(`Unhandled request: ${(config.method ?? 'get').toUpperCase()} ${config.url ?? ''}`)
+      },
+    })
+
+    const store = createStore(client, {
+      getEcho: () => echoHarness.echo,
+    })
+    store.currentThread = createThread(threadId, { body: '', reply_count: 1 })
+
+    await store.loadReplies(threadId)
+
+    // Verify the initial state has is_author: true
+    expect(Reflect.get(store.replies[0] as object, 'is_author')).toBe(true)
+
+    // Simulate a broadcast ReplyUpdated event without is_author (broadcasts
+    // cannot determine authorship because they run without an authenticated user)
+    const broadcastPayload = {
+      ...createReply('reply-1'),
+      body: 'Updated body from broadcast',
+      is_author: false,
+    }
+    echoHarness.threadListeners['.Discussion.ReplyUpdated']?.(broadcastPayload)
+
+    // The body should update but is_author must be preserved from the original
+    expect(store.replies[0]?.body).toBe('Updated body from broadcast')
+    expect(Reflect.get(store.replies[0] as object, 'is_author')).toBe(true)
+  })
+
+  it('preserves is_author flag when a realtime ReplyCreated broadcast updates an existing reply', async () => {
+    const threadId = 'thread-1'
+    const replyWithAuthorFlag = {
+      ...createReply('reply-1'),
+      is_author: true,
+    }
+    const echoHarness = createEchoHarness()
+
+    const client = axios.create({
+      adapter: async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
+        if ((config.method ?? 'get').toLowerCase() === 'get'
+          && config.url === `/v1/discussion/threads/${threadId}/replies?sort=best&format=tree&flatten=1`) {
+          return createResponse(config, {
+            data: [replyWithAuthorFlag],
+            next_cursor: null,
+            meta: { total: 1 },
+          })
+        }
+
+        throw new Error(`Unhandled request: ${(config.method ?? 'get').toUpperCase()} ${config.url ?? ''}`)
+      },
+    })
+
+    const store = createStore(client, {
+      getEcho: () => echoHarness.echo,
+    })
+    store.currentThread = createThread(threadId, { body: '', reply_count: 1 })
+
+    await store.loadReplies(threadId)
+
+    // Simulate a ReplyCreated broadcast for the same reply ID (duplicate delivery).
+    // The broadcast payload has is_author: false since it lacks user context.
+    const broadcastPayload = {
+      ...createReply('reply-1'),
+      body: 'Duplicate delivery',
+      is_author: false,
+    }
+    echoHarness.threadListeners['.Discussion.ReplyCreated']?.(broadcastPayload)
+
+    // is_author must be preserved even through insertReplyIntoActiveThread merge
+    expect(Reflect.get(store.replies[0] as object, 'is_author')).toBe(true)
+  })
+})