@byline/host-tanstack-start 4.0.0 → 4.2.0

package/src/auth/request-scope.test.node.ts

@@ -1,93 +0,0 @@
-/**
- * This Source Code is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright (c) Infonomic Company Limited
- */
-
-/**
- * Unit coverage for per-request memoization. Mocks the Start runtime's
- * `getRequest` so "which request am I in" can be simulated: a stable
- * object per request, or a throw when running outside a request.
- */
-
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const mocks = vi.hoisted(() => ({
-  getRequest: vi.fn(),
-}))
-
-vi.mock('@tanstack/react-start/server', () => ({
-  getRequest: mocks.getRequest,
-}))
-
-import { oncePerRequest } from './request-scope.js'
-
-describe('oncePerRequest', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mocks.getRequest.mockImplementation(() => {
-      throw new Error('No StartEvent found in AsyncLocalStorage')
-    })
-  })
-
-  it('resolves the factory once per request per key', async () => {
-    mocks.getRequest.mockReturnValue({ id: 'request-a' })
-    const factory = vi.fn(async () => ({ token: Math.random() }))
-
-    const first = await oncePerRequest('ctx', factory)
-    const second = await oncePerRequest('ctx', factory)
-
-    expect(second).toBe(first)
-    expect(factory).toHaveBeenCalledTimes(1)
-  })
-
-  it('keys memoization by request identity', async () => {
-    const requestA = { id: 'a' }
-    const requestB = { id: 'b' }
-    const factory = vi.fn(async () => ({ token: Math.random() }))
-
-    mocks.getRequest.mockReturnValue(requestA)
-    const first = await oncePerRequest('ctx', factory)
-    mocks.getRequest.mockReturnValue(requestB)
-    const second = await oncePerRequest('ctx', factory)
-
-    expect(second).not.toBe(first)
-    expect(factory).toHaveBeenCalledTimes(2)
-  })
-
-  it('isolates entries by key within one request', async () => {
-    mocks.getRequest.mockReturnValue({ id: 'request-a' })
-    const admin = vi.fn(async () => 'admin-context')
-    const publicCtx = vi.fn(async () => 'public-context')
-
-    await expect(oncePerRequest('admin', admin)).resolves.toBe('admin-context')
-    await expect(oncePerRequest('public', publicCtx)).resolves.toBe('public-context')
-    await expect(oncePerRequest('admin', admin)).resolves.toBe('admin-context')
-
-    expect(admin).toHaveBeenCalledTimes(1)
-    expect(publicCtx).toHaveBeenCalledTimes(1)
-  })
-
-  it('memoizes rejections for the remainder of the request', async () => {
-    mocks.getRequest.mockReturnValue({ id: 'request-a' })
-    const factory = vi.fn(async () => {
-      throw new Error('no admin session')
-    })
-
-    await expect(oncePerRequest('ctx', factory)).rejects.toThrow('no admin session')
-    await expect(oncePerRequest('ctx', factory)).rejects.toThrow('no admin session')
-    expect(factory).toHaveBeenCalledTimes(1)
-  })
-
-  it('runs unmemoized outside the Start runtime', async () => {
-    const factory = vi.fn(async () => ({ token: Math.random() }))
-
-    const first = await oncePerRequest('ctx', factory)
-    const second = await oncePerRequest('ctx', factory)
-
-    expect(second).not.toBe(first)
-    expect(factory).toHaveBeenCalledTimes(2)
-  })
-})

package/src/auth/request-scope.ts

@@ -1,62 +0,0 @@
-/**
- * This Source Code is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright (c) Infonomic Company Limited
- */
-
-/**
- * Per-request memoization for `RequestContext` factories.
- *
- * `RequestContext.requestId` is documented as "per logical request", and
- * the read-authorization layer binds every `ReadContext` to one immutable
- * request authority whose token includes that id. A factory that mints a
- * fresh context per call breaks both contracts as soon as two reads share
- * a `ReadContext` (the admin tree view, hook-threaded nested reads):
- * the second bind sees a different authority token and throws
- * 'ReadContext cannot be reused across request authorities'.
- *
- * Memoizing on the current Start request makes every context factory
- * request-stable. It also means at most one session verification — and at
- * most one refresh-token rotation — per request, instead of one per call.
- */
-
-import { getRequest } from '@tanstack/react-start/server'
-
-const requestScopes = new WeakMap<object, Map<string, Promise<unknown>>>()
-
-/**
- * Resolve `factory` at most once per HTTP request for a given `key`. The
- * returned promise is memoized on the current Start request — rejections
- * included, since a request's cookies cannot change mid-flight and retrying
- * a failed refresh would burn a second rotation on an already-rotated
- * token. Outside the Start runtime (seed scripts, unit tests, background
- * jobs) there is no request to key on and the factory runs unmemoized.
- */
-export function oncePerRequest<T>(key: string, factory: () => Promise<T>): Promise<T> {
-  const request = currentRequest()
-  if (!request) return factory()
-
-  let scope = requestScopes.get(request)
-  if (!scope) {
-    scope = new Map()
-    requestScopes.set(request, scope)
-  }
-
-  const existing = scope.get(key)
-  if (existing) return existing as Promise<T>
-
-  const pending = factory()
-  scope.set(key, pending)
-  return pending
-}
-
-function currentRequest(): object | undefined {
-  try {
-    return getRequest()
-  } catch {
-    // No StartEvent in AsyncLocalStorage — running outside a request.
-    return undefined
-  }
-}

package/src/integrations/byline-client.ts

@@ -1,68 +0,0 @@
-/**
- * This Source Code is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright (c) Infonomic Company Limited
- */
-
-/**
- * The admin webapp's `BylineClient` singleton.
- *
- * Configured with a `requestContext` factory that resolves the
- * authenticated admin actor per call via `getAdminRequestContext`. Every
- * admin server fn that reads documents goes through this client, so the
- * full read pipeline (`beforeRead` → `findDocuments` → `populate` →
- * `afterRead`) is uniform between admin and any future external
- * client. The collection runtime, db adapter, and storage provider are
- * sourced from the shared `getServerConfig()` so we don't duplicate
- * adapter wiring.
- */
-
-import { createSuperAdminContext } from '@byline/auth'
-import { type BylineClient, createBylineClient } from '@byline/client'
-import { getServerConfig } from '@byline/core'
-
-import { getAdminRequestContext } from '../auth/auth-context.js'
-
-let cachedClient: BylineClient | undefined
-
-export function getAdminBylineClient(): BylineClient {
-  if (cachedClient) return cachedClient
-  cachedClient = createBylineClient({
-    config: getServerConfig(),
-    // Resolved from the current request's session cookies, memoized per
-    // request: every read in one request binds the same context instance
-    // (and requestId), which the ReadContext authority check requires.
-    // `getAdminRequestContext` runs the refresh dance on its own and throws
-    // `ERR_UNAUTHENTICATED` when no session is present — the client
-    // surfaces the throw verbatim.
-    requestContext: getAdminRequestContext,
-  })
-  return cachedClient
-}
-
-let cachedSystemClient: BylineClient | undefined
-
-/**
- * A `BylineClient` bound to an explicit super-admin context — for
- * **system / background** work that is not scoped to an HTTP request:
- * lifecycle-hook search indexing, maintenance scripts, seeds, migrations.
- *
- * Unlike {@link getAdminBylineClient}, this does **not** read session
- * cookies, so it works outside the TanStack Start server runtime (a bare
- * `tsx` script, a seed, a test). Reaching for the request-scoped client in
- * a lifecycle hook couples that hook to the live server and throws
- * `No StartEvent found in AsyncLocalStorage` from any out-of-band write
- * path. Indexing is maintenance, not a user action — it reads the published
- * view and bypasses `beforeRead` — so the super-admin context is both
- * correct and runtime-agnostic. The context is auditable by its stable id.
- */
-export function getSystemBylineClient(): BylineClient {
-  if (cachedSystemClient) return cachedSystemClient
-  cachedSystemClient = createBylineClient({
-    config: getServerConfig(),
-    requestContext: createSuperAdminContext({ id: 'byline-system-client' }),
-  })
-  return cachedSystemClient
-}

package/src/integrations/byline-public-client.ts

@@ -1,67 +0,0 @@
-/**
- * This Source Code is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright (c) Infonomic Company Limited
- */
-
-/**
- * The host's *public-read* `BylineClient` singleton — the strict
- * "preview-can-never-apply" sibling of `getViewerBylineClient`.
- *
- * Configured with `actor: null` and `readMode: 'published'`, full stop.
- * The `requestContext` factory does not consult the `byline_preview`
- * cookie or attempt any admin-session resolution, so an admin browsing
- * with preview mode on cannot accidentally elevate a read that flows
- * through this client. `assertActorCanPerform` permits the null actor
- * exactly on `read` with `readMode === 'published'`, which is what the
- * factory always returns.
- *
- * **Use this client for:**
- *   - RSS feeds, Atom feeds, sitemaps
- *   - JSON or other endpoints exposed to third-party consumers
- *   - any response that an upstream CDN / cache might serve to multiple
- *     visitors without keying off the `byline_preview` cookie
- *
- * **Use `getViewerBylineClient` instead for:**
- *   - user-facing public pages where an admin's preview-mode session
- *     should be honoured
- *
- * Both clients share the same module-scoped singleton pattern so the
- * SDK's per-instance `collectionRecordCache` is amortised across the
- * process lifetime.
- *
- * Companion: `getAdminBylineClient` in `./byline-client.ts` for the
- * admin webapp's authenticated reads (resolves the `RequestContext`
- * from session cookies, memoized per request).
- */
-
-import { createRequestContext, type RequestContext } from '@byline/auth'
-import { type BylineClient, createBylineClient } from '@byline/client'
-import { getServerConfig } from '@byline/core'
-
-import { oncePerRequest } from '../auth/request-scope.js'
-
-/**
- * Anonymous, published-only context — memoized per request so the
- * context (and its requestId) is stable across every read in one
- * request: reads sharing a ReadContext must bind a single request
- * authority.
- */
-export function resolvePublicRequestContext(): Promise<RequestContext> {
-  return oncePerRequest('byline:public-request-context', async () =>
-    createRequestContext({ readMode: 'published' })
-  )
-}
-
-let cachedClient: BylineClient | undefined
-
-export function getPublicBylineClient(): BylineClient {
-  if (cachedClient) return cachedClient
-  cachedClient = createBylineClient({
-    config: getServerConfig(),
-    requestContext: resolvePublicRequestContext,
-  })
-  return cachedClient
-}

package/src/integrations/byline-viewer-client.ts

@@ -1,111 +0,0 @@
-/**
- * This Source Code is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright (c) Infonomic Company Limited
- */
-
-/**
- * The host's *viewer* `BylineClient` singleton — the preview-aware
- * sibling of `getPublicBylineClient` (`./byline-public-client.ts`).
- * Behaves identically to the public client until both the
- * `byline_preview` cookie is set **and** a valid admin session resolves;
- * at that point the per-call `requestContext` factory returns the
- * authenticated `AdminAuth` instead of the anonymous null actor.
- *
- * Why this matters: `assertActorCanPerform` (packages/core/src/auth) only
- * permits anonymous reads when `readMode === 'published'`. So if a server
- * fn passes `status: 'any'` to surface drafts, an anonymous request
- * trips the gate and throws — but a preview-mode admin sails through. The
- * source-view selection itself remains a per-call decision: the SDK's
- * `resolveReadMode` defaults to `'published'` regardless of context, so
- * every server fn still has to opt in by passing `status: 'any'`.
- *
- * The contract for callers:
- *
- *   1. Use `getViewerBylineClient()` on any user-facing public read
- *      where an admin's preview-mode session should be honoured. Use
- *      `getPublicBylineClient()` instead for endpoints where preview
- *      should never apply (RSS feeds, sitemaps, third-party endpoints,
- *      anything an upstream cache might serve without keying off the
- *      preview cookie).
- *   2. Call `isPreviewActive()` once per server fn to decide whether to
- *      pass `status: 'any'` on the read.
- *
- * Stale cookies fail closed: if the preview cookie is present but no
- * valid admin session resolves, the factory returns the same anonymous
- * + `'published'` context the public client would have used, so the
- * worst case is "preview cookie does nothing".
- *
- * The collection-record cache is per-instance, so a singleton here keeps
- * the same amortisation benefit `getPublicBylineClient` has — the two
- * helpers are parallel singletons (one cached `BylineClient` each).
- */
-
-import { createRequestContext } from '@byline/auth'
-import { type BylineClient, createBylineClient } from '@byline/client'
-import { getServerConfig } from '@byline/core'
-
-import { getAdminRequestContext } from '../auth/auth-context.js'
-import { readPreviewCookie } from '../auth/preview-cookies.js'
-import { oncePerRequest } from '../auth/request-scope.js'
-
-let cachedClient: BylineClient | undefined
-
-export function getViewerBylineClient(): BylineClient {
-  if (cachedClient) return cachedClient
-  cachedClient = createBylineClient({
-    config: getServerConfig(),
-    requestContext: resolveViewerRequestContext,
-  })
-  return cachedClient
-}
-
-/**
- * Preview-aware viewer context — memoized per request so every read in
- * one request binds the same context instance (and requestId): reads
- * sharing a ReadContext must resolve a single request authority.
- */
-export function resolveViewerRequestContext() {
-  return oncePerRequest('byline:viewer-request-context', resolveViewerContext)
-}
-
-async function resolveViewerContext() {
-  // No preview cookie → behave exactly like the public client.
-  // Cheap path; no JWT verification, no DB lookup.
-  if (!readPreviewCookie()) {
-    return createRequestContext({ readMode: 'published' })
-  }
-
-  // Preview cookie present → try the admin context. A failure means
-  // the cookie is stale (admin signed out, session expired, refresh
-  // rejected). We swallow the error and fall back to the public
-  // context so the page renders instead of erroring.
-  try {
-    const ctx = await getAdminRequestContext()
-    return { ...ctx, readMode: 'any' as const }
-  } catch {
-    return createRequestContext({ readMode: 'published' })
-  }
-}
-
-/**
- * Resolve whether the current request should surface non-published
- * versions. True iff the preview cookie is set **and** a valid admin
- * session resolves. Server fns call this once and pass the result to
- * `status: preview ? 'any' : 'published'` on the SDK read.
- *
- * Defensive by design: the cookie alone is not enough. A signed-out
- * browser carrying an old preview cookie still gets `false` here, which
- * keeps stray query strings or shared links from leaking drafts.
- */
-export async function isPreviewActive(): Promise<boolean> {
-  if (!readPreviewCookie()) return false
-  try {
-    await getAdminRequestContext()
-    return true
-  } catch {
-    return false
-  }
-}

package/src/integrations/request-context-contract.test.node.ts

@@ -1,131 +0,0 @@
-/**
- * This Source Code is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright (c) Infonomic Company Limited
- */
-
-/**
- * Cross-layer contract test: a real `BylineClient` wired to the real
- * cookie-derived host factory (`getAdminRequestContext`) under a mocked
- * Start request, running two operations that share one `ReadContext`.
- *
- * This is the seam every per-layer suite missed when the admin tree view
- * broke with 'ReadContext cannot be reused across request authorities':
- * client tests used stable test contexts, host auth tests called the
- * factory once, and tree tests mocked the handle. Here the factory's
- * request-stability contract (see `BylineClientConfig.requestContext`)
- * is exercised end-to-end through the SDK's authority binding.
- */
-
-import { AdminAuth } from '@byline/auth'
-import { createBylineClient } from '@byline/client'
-import type { CollectionDefinition, IDbAdapter } from '@byline/core'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const mocks = vi.hoisted(() => ({
-  verifyAccessToken: vi.fn(),
-  refreshSession: vi.fn(),
-  getCookie: vi.fn(),
-  setCookie: vi.fn(),
-  getRequestHeader: vi.fn(),
-  getRequest: vi.fn(),
-}))
-
-vi.mock('@byline/core', async () => {
-  const actual = await vi.importActual<typeof import('@byline/core')>('@byline/core')
-  return {
-    ...actual,
-    getServerConfig: () => ({
-      sessionProvider: {
-        verifyAccessToken: mocks.verifyAccessToken,
-        refreshSession: mocks.refreshSession,
-      },
-    }),
-  }
-})
-
-vi.mock('@tanstack/react-start/server', () => ({
-  getCookie: mocks.getCookie,
-  setCookie: mocks.setCookie,
-  getRequestHeader: mocks.getRequestHeader,
-  getRequest: mocks.getRequest,
-}))
-
-import { createReadContext } from '@byline/core'
-
-import { getAdminRequestContext } from '../auth/auth-context.js'
-
-const postsCollection: CollectionDefinition = {
-  path: 'posts',
-  labels: { singular: 'Post', plural: 'Posts' },
-  fields: [{ name: 'title', type: 'text', label: 'Title' }],
-}
-
-function mockDb(): IDbAdapter {
-  return {
-    commands: { collections: {}, documents: {}, counters: {} },
-    queries: {
-      collections: {
-        getCollectionByPath: vi.fn().mockResolvedValue({ id: 'col-1', version: 1 }),
-      },
-      documents: {
-        findDocuments: vi.fn().mockResolvedValue({ documents: [], total: 0 }),
-        getDocumentsByDocumentIds: vi.fn().mockResolvedValue([]),
-      },
-    },
-  } as unknown as IDbAdapter
-}
-
-describe('host factory ↔ client authority contract', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mocks.getCookie.mockImplementation((name: string) =>
-      name === 'byline_access_token' ? 'valid-access' : undefined
-    )
-    mocks.verifyAccessToken.mockResolvedValue({
-      actor: new AdminAuth({ id: 'admin-1', abilities: ['collections.posts.read'] }),
-    })
-  })
-
-  it('two reads sharing a ReadContext bind one authority within a request', async () => {
-    mocks.getRequest.mockReturnValue({ id: 'request-a' })
-    const db = mockDb()
-    const beforeRead = vi.fn(() => ({ title: 'scoped' }))
-    const client = createBylineClient({
-      db,
-      collections: [{ ...postsCollection, hooks: { beforeRead } }],
-      requestContext: getAdminRequestContext,
-    })
-    const readContext = createReadContext()
-
-    // The admin tree view shape: two top-level reads, one shared ReadContext.
-    await client.collection('posts').find({ status: 'any', _readContext: readContext })
-    await client.collection('posts').find({ status: 'any', _readContext: readContext })
-
-    expect(db.queries.documents.findDocuments).toHaveBeenCalledTimes(2)
-    // One session verification and one beforeRead compile for the whole
-    // request — the factory resolved a single request-stable context.
-    expect(mocks.verifyAccessToken).toHaveBeenCalledTimes(1)
-    expect(beforeRead).toHaveBeenCalledTimes(1)
-  })
-
-  it('still rejects a ReadContext carried across two different requests', async () => {
-    const db = mockDb()
-    const client = createBylineClient({
-      db,
-      collections: [{ ...postsCollection, hooks: { beforeRead: () => ({ title: 'scoped' }) } }],
-      requestContext: getAdminRequestContext,
-    })
-    const readContext = createReadContext()
-
-    mocks.getRequest.mockReturnValue({ id: 'request-a' })
-    await client.collection('posts').find({ status: 'any', _readContext: readContext })
-
-    mocks.getRequest.mockReturnValue({ id: 'request-b' })
-    await expect(
-      client.collection('posts').find({ status: 'any', _readContext: readContext })
-    ).rejects.toThrow('cannot be reused across request authorities')
-  })
-})

package/src/integrations/request-context-factories.test.node.ts

@@ -1,140 +0,0 @@
-/**
- * This Source Code is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright (c) Infonomic Company Limited
- */
-
-/**
- * Direct regression coverage for the public and viewer request-context
- * factories: both must be request-stable (same instance, same requestId,
- * for every call within one Start request) so reads sharing a
- * `ReadContext` bind a single request authority.
- */
-
-import { AdminAuth } from '@byline/auth'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const mocks = vi.hoisted(() => ({
-  verifyAccessToken: vi.fn(),
-  refreshSession: vi.fn(),
-  getCookie: vi.fn(),
-  setCookie: vi.fn(),
-  getRequestHeader: vi.fn(),
-  getRequest: vi.fn(),
-}))
-
-vi.mock('@byline/core', async () => {
-  const actual = await vi.importActual<typeof import('@byline/core')>('@byline/core')
-  return {
-    ...actual,
-    getServerConfig: () => ({
-      sessionProvider: {
-        verifyAccessToken: mocks.verifyAccessToken,
-        refreshSession: mocks.refreshSession,
-      },
-    }),
-  }
-})
-
-vi.mock('@tanstack/react-start/server', () => ({
-  getCookie: mocks.getCookie,
-  setCookie: mocks.setCookie,
-  getRequestHeader: mocks.getRequestHeader,
-  getRequest: mocks.getRequest,
-}))
-
-import { resolvePublicRequestContext } from './byline-public-client.js'
-import { resolveViewerRequestContext } from './byline-viewer-client.js'
-
-function cookiesReturn(values: Record<string, string | undefined>) {
-  mocks.getCookie.mockImplementation((name: string) => values[name])
-}
-
-describe('request-context factories', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mocks.getRequest.mockImplementation(() => {
-      throw new Error('No StartEvent found in AsyncLocalStorage')
-    })
-    cookiesReturn({})
-  })
-
-  describe('resolvePublicRequestContext', () => {
-    it('returns the same anonymous published context for every call in one request', async () => {
-      mocks.getRequest.mockReturnValue({ id: 'request-a' })
-
-      const first = await resolvePublicRequestContext()
-      const second = await resolvePublicRequestContext()
-
-      expect(second).toBe(first)
-      expect(first.actor).toBeNull()
-      expect(first.readMode).toBe('published')
-      expect(second.requestId).toBe(first.requestId)
-    })
-
-    it('resolves independently across requests', async () => {
-      mocks.getRequest.mockReturnValue({ id: 'request-a' })
-      const first = await resolvePublicRequestContext()
-      mocks.getRequest.mockReturnValue({ id: 'request-b' })
-      const second = await resolvePublicRequestContext()
-
-      expect(second).not.toBe(first)
-      expect(second.requestId).not.toBe(first.requestId)
-    })
-  })
-
-  describe('resolveViewerRequestContext', () => {
-    it('returns the same anonymous context per request when no preview cookie is set', async () => {
-      mocks.getRequest.mockReturnValue({ id: 'request-a' })
-
-      const first = await resolveViewerRequestContext()
-      const second = await resolveViewerRequestContext()
-
-      expect(second).toBe(first)
-      expect(first.actor).toBeNull()
-      expect(first.readMode).toBe('published')
-    })
-
-    it('returns the same admin any-mode context per request in preview mode', async () => {
-      mocks.getRequest.mockReturnValue({ id: 'request-a' })
-      cookiesReturn({ byline_preview: '1', byline_access_token: 'valid-access' })
-      const actor = new AdminAuth({ id: 'admin-1', abilities: [] })
-      mocks.verifyAccessToken.mockResolvedValue({ actor })
-
-      const first = await resolveViewerRequestContext()
-      const second = await resolveViewerRequestContext()
-
-      expect(second).toBe(first)
-      expect(first.actor).toBe(actor)
-      expect(first.readMode).toBe('any')
-      // The viewer context and the nested admin resolution are both
-      // memoized — one session verification per request, not per call.
-      expect(mocks.verifyAccessToken).toHaveBeenCalledTimes(1)
-    })
-
-    it('falls back to one stable anonymous context when the preview session is stale', async () => {
-      mocks.getRequest.mockReturnValue({ id: 'request-a' })
-      cookiesReturn({ byline_preview: '1', byline_access_token: 'stale' })
-      mocks.verifyAccessToken.mockRejectedValue(new Error('expired'))
-
-      const first = await resolveViewerRequestContext()
-      const second = await resolveViewerRequestContext()
-
-      expect(second).toBe(first)
-      expect(first.actor).toBeNull()
-      expect(first.readMode).toBe('published')
-    })
-
-    it('resolves independently across requests', async () => {
-      mocks.getRequest.mockReturnValue({ id: 'request-a' })
-      const first = await resolveViewerRequestContext()
-      mocks.getRequest.mockReturnValue({ id: 'request-b' })
-      const second = await resolveViewerRequestContext()
-
-      expect(second).not.toBe(first)
-      expect(second.requestId).not.toBe(first.requestId)
-    })
-  })
-})