@prenta/admin 2.7.0 → 2.8.0

package/src/lib/api.ts

@@ -82,6 +82,8 @@ export interface CmsApiResult<T> {
    * narrow it themselves.
    */
   body?: unknown
+  /** The response's `ETag`, for endpoints that take `If-Match` on the next write. */
+  etag?: string
   status: number
 }
 
@@ -118,6 +120,10 @@ export async function cmsApi<T = unknown>(
     const res = await fetch(url, { ...options, headers, credentials: 'include' })
     const json = await res.json().catch(() => ({}))
 
+    // Test doubles often stub `fetch` with a bare `{ ok, json }`.
+    const etag =
+      typeof res.headers?.get === 'function' ? (res.headers.get('ETag') ?? undefined) : undefined
+
     if (!res.ok) {
       return {
         error: json.error || `Request failed (${res.status})`,
@@ -127,7 +133,12 @@ export async function cmsApi<T = unknown>(
       }
     }
 
-    return { data: json.data ?? json, body: json, status: res.status }
+    return {
+      data: json.data ?? json,
+      body: json,
+      status: res.status,
+      ...(etag ? { etag } : {}),
+    }
   } catch (err) {
     return { error: err instanceof Error ? err.message : 'Network error', status: 0 }
   }

package/src/lib/batch-wizard.ts

@@ -0,0 +1,188 @@
+/**
+ * The New batch AI job wizard (jobs-new.jsx, TRACKING P-20): its sources,
+ * validation and request, kept apart from the component so they can be
+ * tested on their own. The server's rules are in cms-core `jobs/batch-ai.ts`
+ * and CONFLICTS.md §4 (P-16).
+ */
+import type {
+  BatchAiEstimate,
+  BatchAiPayload,
+  BatchAiRequest,
+  BatchAiTextField,
+} from '@prenta/core'
+import { JOB_OPS } from './job-view.js'
+
+export type BatchOperation = BatchAiPayload['operation']
+export type BatchOp = (typeof JOB_OPS)[number]
+
+/** Where a batch runs: a page or post collection, or the media library. */
+export interface BatchSource {
+  /** The collection's key in the config, or `media`. */
+  id: string
+  /** The kit's Content select label ("Posts", "Media library"). */
+  label: string
+}
+
+export const MEDIA_SOURCE: BatchSource = { id: 'media', label: 'Media library' }
+
+/**
+ * Documents picked in a list (P-21's "Run with AI…"). They run as they are,
+ * without the operation's "Only where" preset.
+ */
+export interface BatchSelection {
+  /** A collection key, or `media` for images picked in the media library. */
+  source: string
+  documentIds: string[]
+}
+
+/** A custom instruction needs more than 8 characters, and at most 2,000. */
+const INSTRUCTION_MIN = 9
+export const INSTRUCTION_MAX = 2000
+/** The most documents one batch freezes. */
+const BATCH_MAX = 1000
+
+/**
+ * The fields a custom instruction can rewrite. `field` isn't in the kit's
+ * contract; it's the kit's "Field you choose" (CONFLICTS.md §4, P-16).
+ */
+export const CUSTOM_FIELDS: ReadonlyArray<{ id: BatchAiTextField; label: string }> = [
+  { id: 'metaDescription', label: 'Meta description' },
+  { id: 'seoTitle', label: 'SEO title' },
+  { id: 'excerpt', label: 'Excerpt' },
+]
+
+export function batchOp(id: BatchOperation): BatchOp {
+  return JOB_OPS.find((op) => op.id === id) ?? JOB_OPS[0]
+}
+
+interface ConfigCollection {
+  slug?: string
+  type?: string
+  labels?: { plural?: string }
+  admin?: { hidden?: boolean }
+}
+
+/**
+ * The Content select's options: the config's page and post collections, in
+ * config order, without hidden ones (as Settings → AI's brand voice lists
+ * them). The media library is added for alt text only.
+ */
+export function batchSources(config: unknown): BatchSource[] {
+  const raw = (config as { collections?: unknown } | null | undefined)?.collections
+  if (!raw || typeof raw !== 'object') return []
+  const entries: Array<[string, ConfigCollection]> = Array.isArray(raw)
+    ? (raw as ConfigCollection[]).map((c) => [c.slug ?? '', c])
+    : Object.entries(raw as Record<string, ConfigCollection>)
+  return entries
+    .filter(([key, c]) => key && (c.type === 'page' || c.type === 'post') && !c.admin?.hidden)
+    .map(([key, c]) => ({
+      id: key,
+      label: c.labels?.plural ?? key.charAt(0).toUpperCase() + key.slice(1),
+    }))
+}
+
+/** cms-core's `ADMIN_ROLES`: who may queue a batch that applies changes automatically. */
+export function isAdminRole(role: string | null | undefined): boolean {
+  return role === 'OWNER' || role === 'ADMIN'
+}
+
+/** Alt text runs on images; every other operation on a collection. */
+export function runsOnMedia(operation: BatchOperation): boolean {
+  return operation === 'alt'
+}
+
+/** Whether an operation can run on a picked selection's source. */
+export function operationFits(
+  operation: BatchOperation,
+  selection: BatchSelection | null,
+): boolean {
+  if (!selection) return true
+  return runsOnMedia(operation) === (selection.source === MEDIA_SOURCE.id)
+}
+
+/** Everything the wizard asks, before it becomes a request. */
+export interface BatchDraft {
+  operation: BatchOperation
+  instruction: string
+  field: BatchAiTextField
+  /** The collection picked in the Content select (ignored for alt text). */
+  collection: string
+  statusFilter: 'published' | 'all'
+  review: 'review' | 'auto'
+  onApprove: 'draft' | 'publish'
+  selection: BatchSelection | null
+}
+
+/** The source a draft runs on: the media library for alt text, else its collection. */
+function draftSource(draft: Pick<BatchDraft, 'operation' | 'collection'>): string {
+  return runsOnMedia(draft.operation) ? MEDIA_SOURCE.id : draft.collection
+}
+
+/** Step 1's check: a custom instruction needs more than 8 characters (the server's message). */
+export function instructionError(operation: BatchOperation, instruction: string): string | null {
+  if (operation !== 'custom') return null
+  return instruction.trim().length < INSTRUCTION_MIN
+    ? 'A custom instruction needs more than 8 characters.'
+    : null
+}
+
+/**
+ * The request for estimate, preview and create. "Apply automatically" never
+ * publishes (the server refuses it), so it always sends `draft`.
+ */
+export function batchRequest(draft: BatchDraft): BatchAiRequest {
+  const instruction = draft.instruction.trim()
+  return {
+    operation: draft.operation,
+    source: draft.selection?.source ?? draftSource(draft),
+    statusFilter: draft.statusFilter,
+    review: draft.review,
+    onApprove: draft.review === 'auto' ? 'draft' : draft.onApprove,
+    instruction: instruction || null,
+    ...(draft.operation === 'custom' ? { field: draft.field } : {}),
+    ...(draft.selection ? { filter: { documentIds: draft.selection.documentIds } } : {}),
+  }
+}
+
+/**
+ * The fields that change which documents match, or what the AI writes. An
+ * estimate or preview is stale once its key differs from the draft's.
+ */
+export function estimateKey(request: BatchAiRequest): string {
+  return JSON.stringify([
+    request.operation,
+    request.source,
+    request.statusFilter,
+    request.filter?.documentIds ?? null,
+  ])
+}
+
+export function previewKey(request: BatchAiRequest): string {
+  return JSON.stringify([estimateKey(request), request.instruction, request.field ?? null])
+}
+
+/** Why step 2 can't continue: nothing matches, or more than a batch holds. Null when it can. */
+export function matchProblem(estimate: BatchAiEstimate): string | null {
+  if (estimate.count === 0) return 'No documents match this filter.'
+  if (estimate.count > BATCH_MAX) {
+    return `This matches ${estimate.count.toLocaleString('en-US')} documents. Narrow it to ${BATCH_MAX.toLocaleString('en-US')} or fewer.`
+  }
+  return null
+}
+
+/** The estimate tiles: "~42 min" and "~38k tokens", as the kit rounds them. */
+export function estimateTiles(estimate: BatchAiEstimate): { minutes: string; tokens: string } {
+  return {
+    minutes: `~${estimate.minutes.toLocaleString('en-US')} min`,
+    tokens: `~${Math.round(estimate.tokens / 1000).toLocaleString('en-US')}k tokens`,
+  }
+}
+
+/** The line under the tiles. The limit sentence is left out when Settings → AI sets none. */
+export function estimateNote(estimate: BatchAiEstimate): string {
+  const pace = 'One document per slice, about one a minute.'
+  const pct = estimate.pctOfMonthlyLimit
+  if (pct === null) return pace
+  const share = pct === 0 && estimate.tokens > 0 ? 'under 1' : String(pct)
+  return `${pace} That’s ${share}% of this month’s AI limit.`
+}

package/src/lib/chrome-service.ts

@@ -0,0 +1,200 @@
+/**
+ * Site chrome API (DATA_CONTRACTS §2) for Appearance → Header & Footer.
+ * Region values and the announcement come with an `ETag`; a save sends it as
+ * `If-Match`, so a stale form gets 412 instead of overwriting a newer save.
+ */
+import type {
+  Announcement,
+  ChromeOverridesList,
+  ChromeRegionName,
+  ChromeSettings,
+  ChromeSyncStatus,
+  RegionSchema,
+  RegionValues,
+} from '@prenta/core'
+
+import { cmsApi } from './api.js'
+
+export interface ChromeSchemaView {
+  regions: RegionSchema[]
+  sync: ChromeSyncStatus
+}
+
+/** A result the screen can show: the value, or why there isn't one. */
+export type ChromeResult<T> =
+  | { ok: true; value: T; etag: string | null }
+  | { ok: false; status: number; error: string }
+
+function result<T>(res: {
+  data?: T
+  error?: string
+  status: number
+  etag?: string
+}): ChromeResult<T> {
+  if (res.error !== undefined || res.data === undefined) {
+    return { ok: false, status: res.status, error: res.error ?? 'Request failed' }
+  }
+  return { ok: true, value: res.data, etag: res.etag ?? null }
+}
+
+function ifMatch(etag: string | null): Record<string, string> {
+  return etag ? { 'If-Match': etag } : {}
+}
+
+export async function fetchChromeSchema(): Promise<ChromeResult<ChromeSchemaView>> {
+  return result(await cmsApi<ChromeSchemaView>('/chrome/schema'))
+}
+
+/** 404 until the site has pushed the region's schema. */
+export async function fetchRegion(region: ChromeRegionName): Promise<ChromeResult<RegionValues>> {
+  return result(await cmsApi<RegionValues>(`/chrome/${region}`))
+}
+
+/** What `PUT /chrome/:region` takes. `fields` replaces every saved value. */
+export interface RegionSaveBody {
+  variant: string
+  fields: Record<string, unknown>
+}
+
+export async function saveRegion(
+  region: ChromeRegionName,
+  body: RegionSaveBody,
+  etag: string | null,
+): Promise<ChromeResult<RegionValues>> {
+  return result(
+    await cmsApi<RegionValues>(`/chrome/${region}`, {
+      method: 'PUT',
+      headers: ifMatch(etag),
+      body: JSON.stringify(body),
+    }),
+  )
+}
+
+/** "Remove now" on the orphan row. */
+export async function removeOrphan(
+  region: ChromeRegionName,
+  key: string,
+): Promise<ChromeResult<RegionValues>> {
+  return result(
+    await cmsApi<RegionValues>(`/chrome/${region}/orphans/${encodeURIComponent(key)}`, {
+      method: 'DELETE',
+    }),
+  )
+}
+
+export async function fetchAnnouncement(): Promise<ChromeResult<Announcement>> {
+  return result(await cmsApi<Announcement>('/chrome/announcement'))
+}
+
+/** What `PUT /chrome/announcement` takes. The server mints `id`. */
+export type AnnouncementSaveBody = Omit<Announcement, 'id'>
+
+export async function saveAnnouncement(
+  body: AnnouncementSaveBody,
+  etag: string | null,
+): Promise<ChromeResult<Announcement>> {
+  return result(
+    await cmsApi<Announcement>('/chrome/announcement', {
+      method: 'PUT',
+      headers: ifMatch(etag),
+      body: JSON.stringify(body),
+    }),
+  )
+}
+
+export async function fetchChromeSettings(): Promise<ChromeResult<ChromeSettings>> {
+  return result(await cmsApi<ChromeSettings>('/chrome/settings'))
+}
+
+/**
+ * Saves the keys sent; one left out stays as it is. `secret` comes back once,
+ * when the save creates the revalidate webhook.
+ */
+export async function saveChromeSettings(
+  body: Partial<ChromeSettings>,
+): Promise<ChromeResult<ChromeSettings & { secret?: string }>> {
+  return result(
+    await cmsApi<ChromeSettings & { secret?: string }>('/chrome/settings', {
+      method: 'PUT',
+      body: JSON.stringify(body),
+    }),
+  )
+}
+
+/** The pages whose `_layout` overrides a region. A core before 8.11 answers 404. */
+export async function fetchChromeOverrides(): Promise<ChromeResult<ChromeOverridesList>> {
+  return result(await cmsApi<ChromeOverridesList>('/chrome/overrides'))
+}
+
+/** A menu item as the form and the preview mock read it. */
+export interface ChromeMenuItem {
+  id: string
+  label: string
+  url: string
+  target?: '_blank' | '_self'
+  /** Shown as a button (the kit's "Show as button"). */
+  button: boolean
+  children: ChromeMenuItem[]
+}
+
+/** A menu a menu field can pick, by its slug. */
+export interface ChromeMenuOption {
+  slug: string
+  name: string
+  items: ChromeMenuItem[]
+}
+
+function asText(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function menuItems(value: unknown, depth = 0): ChromeMenuItem[] {
+  if (!Array.isArray(value) || depth > 6) return []
+  const out: ChromeMenuItem[] = []
+  value.forEach((raw, index) => {
+    if (!raw || typeof raw !== 'object') return
+    const item = raw as Record<string, unknown>
+    const label = asText(item.label).trim()
+    if (!label) return
+    out.push({
+      id: asText(item.id) || `${depth}-${index}`,
+      label,
+      url: asText(item.url),
+      ...(item.target === '_blank' || item.target === '_self' ? { target: item.target } : {}),
+      button: item.button === true,
+      children: menuItems(item.children, depth + 1),
+    })
+  })
+  return out
+}
+
+/**
+ * Menus from the navigation plugin's `navigations` collection. Without the
+ * plugin there are none, and menu fields offer only what's saved.
+ */
+export async function fetchChromeMenus(): Promise<ChromeMenuOption[]> {
+  const res = await cmsApi<{
+    docs?: Array<{ slug?: string | null; title?: string | null; data?: unknown }>
+  }>('/collections/navigations?pageSize=100&sort=title&order=asc&pick=name,slug,items')
+  const menus: ChromeMenuOption[] = []
+  for (const doc of res.data?.docs ?? []) {
+    const data = (doc.data && typeof doc.data === 'object' ? doc.data : {}) as Record<
+      string,
+      unknown
+    >
+    const slug = asText(data.slug) || asText(doc.slug)
+    if (!slug || menus.some((menu) => menu.slug === slug)) continue
+    menus.push({
+      slug,
+      name: asText(data.name) || asText(doc.title) || slug,
+      items: menuItems(data.items),
+    })
+  }
+  return menus
+}
+
+/** The site title, for brand fields and the preview's logo. */
+export async function fetchSiteTitle(): Promise<string | null> {
+  const res = await cmsApi<{ siteTitle?: string | null }>('/appearance')
+  return typeof res.data?.siteTitle === 'string' && res.data.siteTitle ? res.data.siteTitle : null
+}

package/src/lib/job-view.ts

@@ -141,10 +141,18 @@ export interface JobRow {
   items: boolean
   /** Batch AI approval mode, for the cancel copy. Null for scans. */
   review: 'review' | 'auto' | null
+  /**
+   * Batch AI: only an admin may retry it, because "Apply automatically" was
+   * chosen when it was queued. A job from `/ai/batch` (a list's bulk actions)
+   * also applies directly, but stores no review mode, so it isn't admin-only.
+   */
+  adminRetry: boolean
   /** Run time of a finished job, e.g. "17 min". */
   took: string | null
   /** Who queued it: a person, or the cron. */
   by: string
+  /** The id of the person who queued it; null for a cron run. */
+  byId: string | null
   /** When it was queued, e.g. "34 min ago" or "Yesterday 16:04". */
   created: string
 }
@@ -261,6 +269,70 @@ export function hasReviewAction(j: JobRow): boolean {
   return view(j).k === 'review' || (j.items && j.pending > 0)
 }
 
+/** "document 8" or "page 101": where a retry picks up (jobs-drawer.jsx footer, jobs-view.jsx toast). */
+export function retryPoint(j: Pick<JobRow, 'type' | 'done'>): string {
+  return `${jobType(j.type).unit === 'pages' ? 'page' : 'document'} ${j.done + 1}`
+}
+
+/** Who is looking at the Jobs screen, from the admin session. */
+export interface JobViewer {
+  role: string | null
+  userId: string | null
+}
+
+/** Roles that may run, cancel and retry jobs: cms-core `WRITE_ROLES` (`requireStaffAccess`). */
+const JOB_WRITE_ROLES: ReadonlySet<string> = new Set(['OWNER', 'ADMIN', 'EDITOR', 'AUTHOR'])
+/** cms-core `ADMIN_ROLES`: may retry any batch. */
+const JOB_ADMIN_ROLES: ReadonlySet<string> = new Set(['OWNER', 'ADMIN'])
+
+function roleOf(viewer: JobViewer): string {
+  return (viewer.role ?? '').toUpperCase()
+}
+
+/** Run now and Cancel. An unknown role fails closed; the server checks every request anyway. */
+export function canActOnJobs(viewer: JobViewer): boolean {
+  return JOB_WRITE_ROLES.has(roleOf(viewer))
+}
+
+/**
+ * Retry, as cms-core's retry route allows it: a write role, and for a batch
+ * (`batchRetryDenial`) an admin, or the person who queued it when it doesn't
+ * apply changes directly. The server also wants their role unchanged since
+ * they queued it, which the list doesn't carry; it refuses that with a 403.
+ */
+export function canRetryJob(
+  j: Pick<JobRow, 'type' | 'adminRetry' | 'byId'>,
+  viewer: JobViewer,
+): boolean {
+  if (!canActOnJobs(viewer)) return false
+  if (j.type !== 'batch-ai' || JOB_ADMIN_ROLES.has(roleOf(viewer))) return true
+  return !j.adminRetry && j.byId !== null && j.byId === viewer.userId
+}
+
+/** The job actions a row or the drawer footer (jobs-drawer.jsx `.jd-f`) offers this viewer. */
+export interface JobActions {
+  /** Cancel job: while it's queued or running, until a cancel is asked for. */
+  cancel: boolean
+  /** "Retry from document {n+1}": a failed job. */
+  retry: boolean
+  /**
+   * "Retry now": a job waiting out a failed slice's backoff. Not on a stale
+   * lock, which the server still holds as running (the next worker run picks
+   * it up), and not while cancelling: a retry clears the cancel.
+   */
+  retryNow: boolean
+}
+
+export function jobActions(j: JobRow, viewer: JobViewer): JobActions {
+  const retryable = canRetryJob(j, viewer)
+  return {
+    cancel: canActOnJobs(viewer) && active(j) && !j.cancelling,
+    retry: retryable && j.state === 'dead',
+    retryNow:
+      retryable && j.state === 'queued' && j.status === 'queued' && !!j.error && !j.cancelling,
+  }
+}
+
 /** A running job whose lock is older than this crashed mid-slice (JOBS.md). */
 const STALE_LOCK_MS = 10 * 60_000
 /** The worker cron runs once a minute. */
@@ -392,6 +464,11 @@ function who(job: Job): string {
   return by.name
 }
 
+function whoId(job: Job): string | null {
+  const by = job.createdBy
+  return by && 'id' in by ? by.id : null
+}
+
 /** Claim order (`claimNext`): earliest `runAt`, then oldest. */
 function claimsBefore(a: Job, b: Job): boolean {
   const runA = Date.parse(a.runAt)
@@ -400,6 +477,16 @@ function claimsBefore(a: Job, b: Job): boolean {
   return Date.parse(a.createdAt) < Date.parse(b.createdAt)
 }
 
+/**
+ * How many units a job covers. A batch's worker sets `progress.total` on its
+ * first slice, so until then it's the documents frozen in its payload.
+ */
+export function jobTotal(job: Job): number {
+  if (job.progress.total > 0 || job.type !== 'batch-ai') return job.progress.total
+  const ids = 'documentIds' in job.payload ? job.payload.documentIds : null
+  return Array.isArray(ids) ? ids.length : 0
+}
+
 /**
  * API jobs in the kit's row shape. `now` is when the list was fetched, so the
  * retry countdown and "34 min ago" move with each poll. `worker` aligns the
@@ -427,7 +514,7 @@ export function toJobRows(jobs: Job[], now: number, worker: JobWorkerStatus | nu
       status: job.status,
       cancelling: !!job.cancelRequestedAt && isActive(job),
       done: job.progress.done,
-      total: job.progress.total,
+      total: jobTotal(job),
       attempts: job.attempts,
       maxAttempts: job.maxAttempts,
       error,
@@ -448,8 +535,15 @@ export function toJobRows(jobs: Job[], now: number, worker: JobWorkerStatus | nu
       pending: review?.pending ?? 0,
       items: !!review && review.pending + review.approved + review.rejected > 0,
       review: job.type === 'batch-ai' && 'review' in job.payload ? job.payload.review : null,
+      // cms-core `batchAiWriter`: only a stored `review: 'auto'` is admin-only.
+      adminRetry:
+        job.type === 'batch-ai' &&
+        'review' in job.payload &&
+        job.payload.review === 'auto' &&
+        job.payload.origin !== 'ai-batch',
       took: finished ? formatDuration(Date.parse(finished) - Date.parse(job.createdAt)) : null,
       by: who(job),
+      byId: whoId(job),
       created: formatCreated(job.createdAt, now),
     }
   })

package/src/lib/jobs-service.ts

@@ -7,7 +7,15 @@
  * failed request from an empty list and show the server's message (a
  * viewer's 403, a 409 for a job that can't be retried).
  */
-import type { Job, JobEvent, JobReviewItem, JobWorkerStatus } from '@prenta/core'
+import type {
+  BatchAiEstimate,
+  BatchAiPreviewItem,
+  BatchAiRequest,
+  Job,
+  JobEvent,
+  JobReviewItem,
+  JobWorkerStatus,
+} from '@prenta/core'
 import { cmsApi, getApiBase } from './api.js'
 
 export type JobsOutcome<T> = { ok: true; value: T } | { ok: false; error: string; status: number }
@@ -140,6 +148,53 @@ export function cancelJob(id: string): Promise<JobsOutcome<Job>> {
   return call(`/jobs/${encodeURIComponent(id)}/cancel`, { method: 'POST' })
 }
 
+/**
+ * `GET /jobs/batch-ai/estimate`: how many documents a batch would change,
+ * 3 of them as a sample, and its tokens, minutes and share of the monthly AI
+ * limit. The query carries the request's fields, `documentIds` comma-separated.
+ */
+export function estimateBatchAi(
+  request: BatchAiRequest,
+  signal?: AbortSignal,
+): Promise<JobsOutcome<BatchAiEstimate>> {
+  const params = new URLSearchParams({
+    operation: request.operation,
+    source: request.source,
+    statusFilter: request.statusFilter,
+  })
+  if (request.field) params.set('field', request.field)
+  if (request.instruction) params.set('instruction', request.instruction)
+  const ids = request.filter?.documentIds
+  if (ids?.length) params.set('documentIds', ids.join(','))
+  return call(`/jobs/batch-ai/estimate?${params}`, { signal })
+}
+
+/**
+ * `POST /jobs/batch-ai/preview`: what the AI would write for the first 3
+ * matching documents. Nothing is written. A document it would leave as it is
+ * isn't listed, and a spent AI cap is a 429.
+ */
+export async function previewBatchAi(
+  request: BatchAiRequest,
+  signal?: AbortSignal,
+): Promise<JobsOutcome<BatchAiPreviewItem[]>> {
+  const res = await call<{ items?: BatchAiPreviewItem[] }>('/jobs/batch-ai/preview', {
+    method: 'POST',
+    body: JSON.stringify(request),
+    signal,
+  })
+  return res.ok ? { ok: true, value: res.value.items ?? [] } : res
+}
+
+/**
+ * `POST /jobs/batch-ai`: resolve the documents once, freeze them in a new
+ * queued job, and return it. "Apply automatically" is admin-only (403), and
+ * a filter matching no documents, or more than 1,000, is a 400.
+ */
+export function createBatchAiJob(request: BatchAiRequest): Promise<JobsOutcome<Job>> {
+  return call('/jobs/batch-ai', { method: 'POST', body: JSON.stringify(request) })
+}
+
 function jobPath(id: string): string {
   return `/jobs/${encodeURIComponent(id)}`
 }

package/src/styles/prenta-tokens.css

@@ -128,6 +128,22 @@
   --code-btn-bg: #171a20;
   --code-btn-bdr: #2a2e36;
   --code-btn-txt: #c9cdd4;
+  --code-file: #8a8f99; /* File-name caption over a code block */
+
+  /* Site preview */
+  --site-bg: #ffffff;
+  --site-txt: #16181d;
+  --site-sub: #50555f;
+  --site-muted: #8a8f99;
+  --site-bdr: #e3e5ea;
+  --site-alt: #f4f5f7;
+  --site-alt2: #eef0f3;
+  --site-chip: #d9dce1;
+  --site-foot-txt: #c9cdd4;
+  /* The announcement's Alert tone, as the mock and the Style pills draw it */
+  --site-alert: #b45309;
+  --site-thumb: #2a2d33; /* Footer variant thumbnails */
+  --site-thumb-bar: #555555;
 
   /* Search preview */
   /*
@@ -155,6 +171,7 @@
   --fs-page: 21px; /* Page title */
   --fs-drawer: 16px; /* Drawer / modal title */
   --fs-stat: 20px; /* Jobs drawer result numbers */
+  --fs-figure: 14px; /* Batch wizard match count and estimates */
   --fs-card: 13.5px; /* Card heading */
   --fs-body: 13px; /* Body, controls, table cells */
   --fs-sm: 12.5px; /* Secondary rows, breadcrumbs, chips */

package/src/styles/theme.css

@@ -239,6 +239,19 @@
   --color-code-btn-bg: var(--code-btn-bg);
   --color-code-btn-bdr: var(--code-btn-bdr);
   --color-code-btn-txt: var(--code-btn-txt);
+  --color-code-file: var(--code-file);
+  --color-site-bg: var(--site-bg);
+  --color-site-txt: var(--site-txt);
+  --color-site-sub: var(--site-sub);
+  --color-site-muted: var(--site-muted);
+  --color-site-bdr: var(--site-bdr);
+  --color-site-alt: var(--site-alt);
+  --color-site-alt2: var(--site-alt2);
+  --color-site-chip: var(--site-chip);
+  --color-site-foot-txt: var(--site-foot-txt);
+  --color-site-alert: var(--site-alert);
+  --color-site-thumb: var(--site-thumb);
+  --color-site-thumb-bar: var(--site-thumb-bar);
 
   --text-page: var(--fs-page);
   --text-page--letter-spacing: -0.5px;
@@ -249,6 +262,8 @@
   --text-stat: var(--fs-stat);
   --text-stat--letter-spacing: -0.4px;
   --text-stat--font-weight: 700;
+  --text-figure: var(--fs-figure);
+  --text-figure--font-weight: 700;
   /* The kit's `text-card` would collide with the card color, which wins in v4. */
   --text-card-title: var(--fs-card);
   --text-body: var(--fs-body);