@michaelthielemann/kestrel 4.1.2 → 5.0.0

package/layers/admin/app/pages/admin/login.vue

@@ -1,68 +0,0 @@
-<script setup lang="ts">
-definePageMeta({ layout: 'admin' })
-
-const { t } = useT()
-const route = useRoute()
-const password = ref('')
-const error = ref<string | null>(null)
-const loading = ref(false)
-
-async function submit() {
-  loading.value = true
-  error.value = null
-  try {
-    await useAuth().login(password.value)
-    await navigateTo(safeRedirect(route.query.redirect) ?? '/admin')
-  } catch (e: unknown) {
-    const status = (e as { statusCode?: number })?.statusCode
-    error.value = status === 401 ? t('login.invalid') : t('login.error')
-  } finally {
-    loading.value = false
-  }
-}
-</script>
-
-<template>
-  <form class="login" @submit.prevent="submit">
-    <div class="login__brand">
-      <KestrelUiBrand />
-      <span class="login__brand-word">kestrel</span>
-    </div>
-    <h1 class="login__title">{{ t('login.signIn') }}</h1>
-    <KestrelUiAlert v-if="error" variant="error">{{ error }}</KestrelUiAlert>
-    <KestrelUiField :label="t('login.password')">
-      <template #default="f">
-        <KestrelUiTextInput
-          v-model="password"
-          type="password"
-          autocomplete="current-password"
-          v-bind="f"
-        />
-      </template>
-    </KestrelUiField>
-    <KestrelUiButton type="submit" variant="primary" :loading="loading">{{ t('login.signIn') }}</KestrelUiButton>
-  </form>
-</template>
-
-<style lang="scss">
-.login {
-  display: flex;
-  flex-direction: column;
-  gap: var(--space-4);
-  max-width: 22rem;
-  margin-inline: auto;
-  overflow-y: auto;
-
-  &__brand {
-    display: inline-flex;
-    align-items: center;
-    gap: var(--space-2);
-    font-size: var(--text-lg);
-    font-weight: var(--weight-bold);
-  }
-  &__title {
-    font-size: var(--text-xl);
-    font-weight: var(--weight-bold);
-  }
-}
-</style>

package/layers/admin/app/pages/admin/media.vue

@@ -1,28 +0,0 @@
-<script setup lang="ts">
-definePageMeta({ layout: 'admin', middleware: 'admin-auth' })
-const { t } = useT()
-</script>
-
-<template>
-  <section class="media-page">
-    <h1 class="media-page__title">{{ t('media.title') }}</h1>
-    <KestrelMediaLibrary />
-  </section>
-</template>
-
-<style lang="scss">
-// Non-scrolling page section: the title stays fixed and MediaLibrary's grid owns the scroll.
-.media-page {
-  display: flex;
-  flex-direction: column;
-  gap: var(--space-4);
-  min-height: 0;
-  overflow: hidden;
-
-  &__title {
-    flex: 0 0 auto;
-    font-size: var(--text-xl);
-    font-weight: var(--weight-bold);
-  }
-}
-</style>

package/layers/admin/app/pages/admin/references.vue

@@ -1,146 +0,0 @@
-<script setup lang="ts">
-definePageMeta({ layout: 'admin', middleware: 'admin-auth' })
-
-// The global broken-references report: every record that links to a deleted or unpublished target. The
-// referrer keeps its last published output (the stale link stays live) until it is re-edited — this is
-// the editor's queue for fixing those. Derived on read, so an entry clears once the link is fixed or the
-// target restored. Admin-only (the `brokenRefs` pipeline is outside the public set).
-interface BrokenRow {
-  source: { collection: string; id: number }
-  target: { collection: string; id: number }
-  reason: 'missing' | 'unpublished'
-}
-
-const { t } = useT()
-const broken = ref<BrokenRow[]>([])
-// Distinguish "the check ran and found nothing" from "the check failed": a failed fetch must NOT render
-// the green all-clear (that would imply a verified-clean site when nothing was actually verified).
-const loadError = ref(false)
-try {
-  broken.value = await $fetch<BrokenRow[]>('/api/brokenRefs')
-} catch {
-  loadError.value = true
-}
-</script>
-
-<template>
-  <section class="refs">
-    <NuxtLink to="/admin" class="refs__back">
-      <KestrelUiIcon name="arrow-left" :size="16" />
-      <span>{{ t('nav.dashboard') }}</span>
-    </NuxtLink>
-    <h1 class="refs__title">{{ t('refs.title') }}</h1>
-    <p class="refs__lede">{{ t('refs.lede') }}</p>
-
-    <KestrelUiAlert v-if="loadError" variant="error" class="refs__error">{{ t('refs.loadError') }}</KestrelUiAlert>
-    <KestrelUiEmptyState
-      v-else-if="!broken.length"
-      icon="check"
-      :title="t('refs.empty.title')"
-      :description="t('refs.empty.desc')"
-    />
-    <!-- The report table is the one scroll region; the back link, title and lede stay fixed above it. -->
-    <div v-else class="refs__scroll">
-      <table class="refs__table">
-        <thead>
-          <tr>
-            <th>{{ t('refs.colReferrer') }}</th>
-            <th>{{ t('refs.colTarget') }}</th>
-            <th>{{ t('refs.colReason') }}</th>
-          </tr>
-        </thead>
-        <tbody>
-          <tr v-for="(b, i) in broken" :key="i">
-            <td>
-              <NuxtLink :to="`/admin/${b.source.collection}/${b.source.id}`" class="refs__link">{{ b.source.collection }} #{{ b.source.id }}</NuxtLink>
-            </td>
-            <td class="refs__target">{{ b.target.collection }} #{{ b.target.id }}</td>
-            <td>
-              <span class="refs__reason" :class="`refs__reason--${b.reason}`">{{ t(`refs.reason.${b.reason}`) }}</span>
-            </td>
-          </tr>
-        </tbody>
-      </table>
-    </div>
-  </section>
-</template>
-
-<style lang="scss">
-// Non-scrolling section: the back link, title and lede stay fixed; the report table scrolls in .refs__scroll.
-.refs {
-  display: flex;
-  flex-direction: column;
-  gap: var(--space-3);
-  min-height: 0;
-  overflow: hidden;
-
-  &__back,
-  &__title,
-  &__lede {
-    flex: 0 0 auto;
-  }
-
-  &__scroll {
-    flex: 1 1 auto;
-    min-height: 0;
-    overflow: auto;
-  }
-
-  &__back {
-    display: inline-flex;
-    align-items: center;
-    gap: var(--space-1);
-    align-self: flex-start;
-    font-size: var(--text-sm);
-    color: var(--color-text-muted);
-    text-decoration: none;
-
-    &:hover {
-      color: var(--color-text);
-    }
-  }
-  &__title {
-    font-size: var(--text-xl);
-    font-weight: var(--weight-bold);
-  }
-  &__lede {
-    color: var(--color-text-muted);
-  }
-  &__table {
-    width: 100%;
-    border-collapse: collapse;
-    font-size: var(--text-sm);
-
-    th,
-    td {
-      text-align: start;
-      padding: var(--space-2) var(--space-3);
-      border-bottom: 1px solid var(--color-border);
-    }
-  }
-  &__link {
-    color: var(--color-primary);
-    text-decoration: none;
-    text-transform: capitalize;
-  }
-  &__target {
-    color: var(--color-text-muted);
-    text-transform: capitalize;
-  }
-  &__reason {
-    display: inline-flex;
-    padding: 1px var(--space-2);
-    border-radius: var(--radius-sm);
-    font-size: var(--text-xs);
-    font-weight: var(--weight-medium);
-    background: transparent;
-    border: 1px solid var(--color-warning);
-    color: var(--color-warning-text); /* warning conveyed as TEXT → needs 4.5:1, not the 3:1 icon accent */
-
-    &--missing {
-      background: var(--color-danger-solid);
-      color: var(--color-on-danger);
-    }
-  }
-}
-</style>

package/layers/admin/app/plugins/admin-style-guard.client.ts

@@ -1,76 +0,0 @@
-import { isProtectedStyle } from '../utils/admin-style-guard'
-
-function isKestrelOwned(node: Element): boolean {
-  const el = node as HTMLElement
-  const devId = el.dataset?.viteDevId ?? '' // Vite stamps the source path here in dev
-  const href = node.getAttribute?.('href') ?? ''
-  return isProtectedStyle(devId, href, el.dataset?.kestrel !== undefined)
-}
-
-/**
- * Dev-only admin style guard — keeps a consumer's public CSS out of /admin.
- *
- * In `pnpm dev` the whole app (the consumer's public site AND /admin) is ONE Vite SPA sharing one
- * `<head>`. A consumer's public global CSS — typically a reset with bare `html { font-size: … }`, `*`,
- * `#__nuxt > div`, `body` — is injected as a persistent `<style>` the moment a public route renders, and
- * Vite/Nuxt never unload it on client-side navigation. Soft-navigating to /admin therefore leaves that
- * sheet live, and because it is globally-selectored it restyles the admin shell (rescaled rems from a
- * changed root font-size, a collapsed rail, wrong fonts). Layout-chunk code-splitting only governs WHEN a
- * sheet is loaded, never WHICH elements it matches once it is present in a shared document — so it is not
- * isolation. This puts the defense upstream so consumers never have to scope their own styles defensively.
- *
- * While the active route is under /admin, this guard disables every stylesheet that is NOT Kestrel's own
- * by flipping its `media` to `not all` (remembering the previous value so it can be restored exactly on
- * leave — reversible, so returning to a public route never leaves it unstyled), and it watches `<head>` so
- * any sheet injected later (HMR, another layer) is disabled too. On leaving /admin it restores everything.
- *
- * Gated to development: in production the public site ships as a separate static `nuxt generate` build with
- * no /admin routes, and the origin serves /admin as its own document — there is no shared `<head>` to guard.
- * Client-only (the static renderer never runs client plugins). Note: Kestrel's admin also re-asserts the
- * root font-size inline while its layout is mounted (see admin.vue), which defends the rem base even in a
- * single-origin production deployment where this dev guard is inactive.
- */
-export default defineNuxtPlugin(() => {
-  if (!import.meta.dev) return
-
-  // Foreign sheets we disabled → their previous `media` value (null = attribute was absent).
-  const disabled = new Map<Element, string | null>()
-  let observer: MutationObserver | undefined
-
-  const disableForeign = () => {
-    for (const node of document.querySelectorAll('style, link[rel~="stylesheet"]')) {
-      if (isKestrelOwned(node) || disabled.has(node)) continue
-      disabled.set(node, node.getAttribute('media'))
-      node.setAttribute('media', 'not all')
-    }
-  }
-
-  const restoreAll = () => {
-    for (const [node, media] of disabled) {
-      if (media === null) node.removeAttribute('media')
-      else node.setAttribute('media', media)
-    }
-    disabled.clear()
-  }
-
-  // Runs on the initial client navigation and every subsequent one. A named global middleware — the
-  // anonymous form cannot take `{ global: true }`.
-  addRouteMiddleware(
-    'kestrel-admin-style-guard',
-    (to) => {
-      const onAdmin = to.path === '/admin' || to.path.startsWith('/admin/')
-      if (!onAdmin) {
-        observer?.disconnect()
-        observer = undefined
-        restoreAll()
-        return
-      }
-      disableForeign()
-      if (!observer) {
-        observer = new MutationObserver(disableForeign)
-        observer.observe(document.head, { childList: true, subtree: true })
-      }
-    },
-    { global: true },
-  )
-})

package/layers/admin/app/plugins/reauth.client.ts

@@ -1,20 +0,0 @@
-import { makeReauthInterceptor } from '../utils/reauth'
-
-/**
- * Global re-auth interceptor. When a guarded `/api` call 401s mid-session (the cookie expired or was
- * rotated server-side), an ofetch `onResponseError` hook clears the stale local auth and bounces to the
- * login screen with a redirect back to the current page. Client-only: the static renderer never runs
- * client plugins, so the prerender principal is unaffected; non-admin/public locations are filtered out
- * in `reauthTarget`.
- */
-export default defineNuxtPlugin(() => {
-  const auth = useAuth()
-  const router = useRouter()
-  const onResponseError = makeReauthInterceptor({
-    currentPath: () => router.currentRoute.value.fullPath,
-    reset: () => auth.reset(),
-    navigate: (to) => { navigateTo(to) },
-  })
-  // Wrap the auto-imported `$fetch` so every call (incl. useFetch/useAsyncData) runs through the hook.
-  globalThis.$fetch = globalThis.$fetch.create({ onResponseError }) as typeof globalThis.$fetch
-})

package/layers/admin/app/utils/admin-style-guard.ts

@@ -1,20 +0,0 @@
-// Kestrel's own stylesheets live under `…/kestrel/layers/…`; its extensions ship as `kestrel-*` packages
-// (or a monorepo `extensions/` dir → still resolved through a `kestrel-*` name). A Vue `<style scoped>`
-// block is component-scoped (its rules carry a `data-v-<hash>` attribute), so it can NEVER be the global
-// public CSS this guard targets — keep it wherever it comes from, which is what extension AND consumer
-// admin widgets (custom field types, registered editor bodies) rely on.
-const KESTREL_OWNED = /[/\\]kestrel[/\\]layers[/\\]/
-const KESTREL_EXTENSION = /[/\\]kestrel-[^/\\]+[/\\]/
-const SCOPED = /[?&]scoped[=&]/
-
-/**
- * Whether a stylesheet must be PROTECTED from the dev admin style-guard (i.e. NOT disabled on /admin). True
- * for Kestrel core/extension sheets, any component-scoped Vue style, or a node explicitly tagged
- * `data-kestrel`. Only genuinely foreign global CSS (a consumer's unscoped public reset) falls through to
- * false and gets disabled. Pure → unit-tested without a DOM.
- */
-export function isProtectedStyle(devId: string, href: string, hasDataKestrel: boolean): boolean {
-  if (hasDataKestrel) return true
-  if (SCOPED.test(devId)) return true
-  return KESTREL_OWNED.test(devId) || KESTREL_OWNED.test(href) || KESTREL_EXTENSION.test(devId) || KESTREL_EXTENSION.test(href)
-}

package/layers/admin/app/utils/block-tree.ts

@@ -1,214 +0,0 @@
-import type { SerializedBlock } from '@michaelthielemann/kestrel-core'
-import { reorder } from '../../../ui/app/utils/reorder'
-import { initialValues } from './edit-form'
-
-// Pure, immutable operations over a nested block tree (`content`), addressed by each block's stable
-// `id` rather than a positional index — this is what lets a single shared selection + one fields pane
-// edit a block at ANY depth: every op walks the whole tree by id and rebuilds only the path to it. No
-// Vue here — fully unit-testable.
-
-export interface BlockRow {
-  id: string
-  type: string
-  props: Record<string, unknown>
-  slots?: Record<string, unknown>
-}
-
-type GenId = () => string
-
-/** Stable config + id-addressed operations for the tree pane, threaded through the recursion as one
- *  object. Lives here (not in the SFC) so the component, the editor shell, and tests can share the type. */
-export interface BlockTreeCtx {
-  byName: Record<string, SerializedBlock>
-  allowedTypes: SerializedBlock[]
-  ops: {
-    select: (id: string | null) => void
-    add: (parentId: string | null, slotName: string | null, type: string) => void
-    remove: (id: string) => void
-    move: (id: string, dir: -1 | 1) => void
-    duplicate: (id: string) => void
-  }
-}
-
-/** A seeded blank block of `type`: fresh id + props defaulted from the type's field schema. */
-export function blankBlock(type: string, schemas: Record<string, SerializedBlock>, genId: GenId): BlockRow {
-  return { id: genId(), type, props: initialValues(schemas[type]?.fields ?? {}) }
-}
-
-/** Deep-clone a block subtree with fresh ids at every level (duplicate never shares an id or a ref). */
-export function cloneBlockTree(b: BlockRow, genId: GenId): BlockRow {
-  const copy: BlockRow = { ...b, id: genId(), props: JSON.parse(JSON.stringify(b.props ?? {})) }
-  if (b.slots) {
-    copy.slots = Object.fromEntries(
-      Object.entries(b.slots).map(([name, arr]) => [name, Array.isArray(arr) ? (arr as BlockRow[]).map((c) => cloneBlockTree(c, genId)) : arr]),
-    )
-  }
-  return copy
-}
-
-export interface Found {
-  block: BlockRow
-  /** The array that directly contains the block. */
-  siblings: BlockRow[]
-  index: number
-  /** The id of the block whose slot contains this one, or null at the root level. */
-  parentId: string | null
-  /** The slot name this block lives in, or null at the root level. */
-  slotName: string | null
-}
-
-/** Locate a block anywhere in the tree by id (with its container + position), or null. */
-export function findInTree(blocks: BlockRow[], id: string): Found | null {
-  function walk(arr: BlockRow[], parentId: string | null, slotName: string | null): Found | null {
-    for (let i = 0; i < arr.length; i++) {
-      const b = arr[i]!
-      if (b.id === id) return { block: b, siblings: arr, index: i, parentId, slotName }
-      if (b.slots) {
-        for (const [name, sub] of Object.entries(b.slots)) {
-          if (Array.isArray(sub)) {
-            const hit = walk(sub as BlockRow[], b.id, name)
-            if (hit) return hit
-          }
-        }
-      }
-    }
-    return null
-  }
-  return walk(blocks, null, null)
-}
-
-/** Immutably transform the block with `id` (block → new block), rebuilding ONLY the path to it; every
- *  untouched block AND array keeps its reference. Returning the original `blocks` when nothing changed is
- *  what makes the recursive `next !== sub` a correct change-detector (a bare `.map` always allocates, so it
- *  would rebuild every slot-bearing block in the tree on any edit). */
-function updateBlock(blocks: BlockRow[], id: string, fn: (b: BlockRow) => BlockRow): BlockRow[] {
-  let changed = false
-  const out = blocks.map((b) => {
-    if (b.id === id) { changed = true; return fn(b) }
-    if (!b.slots) return b
-    const mapped = withMappedSlots(b)
-    if (mapped !== b) changed = true
-    return mapped
-  })
-  return changed ? out : blocks
-  function withMappedSlots(b: BlockRow): BlockRow {
-    let changed = false
-    const slots: Record<string, unknown> = {}
-    for (const [name, sub] of Object.entries(b.slots!)) {
-      if (Array.isArray(sub)) {
-        const next = updateBlock(sub as BlockRow[], id, fn)
-        if (next !== sub) changed = true
-        slots[name] = next
-      } else slots[name] = sub
-    }
-    return changed ? { ...b, slots } : b
-  }
-}
-
-/** Immutably transform the ARRAY that directly contains `id` (array+index → new array); every untouched
- *  block AND array keeps its reference (same same-ref-when-unchanged rule as `updateBlock`). */
-function updateContaining(blocks: BlockRow[], id: string, fn: (arr: BlockRow[], index: number) => BlockRow[]): BlockRow[] {
-  const idx = blocks.findIndex((b) => b.id === id)
-  if (idx !== -1) return fn(blocks, idx)
-  let changed = false
-  const out = blocks.map((b) => {
-    if (!b.slots) return b
-    let slotChanged = false
-    const slots: Record<string, unknown> = {}
-    for (const [name, sub] of Object.entries(b.slots)) {
-      if (Array.isArray(sub)) {
-        const next = updateContaining(sub as BlockRow[], id, fn)
-        if (next !== sub) slotChanged = true
-        slots[name] = next
-      } else slots[name] = sub
-    }
-    if (!slotChanged) return b
-    changed = true
-    return { ...b, slots }
-  })
-  return changed ? out : blocks
-}
-
-export function updatePropById(blocks: BlockRow[], id: string, key: string, value: unknown): BlockRow[] {
-  return updateBlock(blocks, id, (b) => ({ ...b, props: { ...b.props, [key]: value } }))
-}
-
-/** Remove the block with `id` from wherever it lives. */
-export function removeById(blocks: BlockRow[], id: string): BlockRow[] {
-  return updateContaining(blocks, id, (arr, i) => arr.filter((_, j) => j !== i))
-}
-
-/** Where selection should move when the block with `id` is removed: previous sibling, else next, else
- *  the parent (null at the root). Computed against the tree BEFORE removal. */
-export function removalRetarget(blocks: BlockRow[], id: string): string | null {
-  const f = findInTree(blocks, id)
-  if (!f) return null
-  if (f.index > 0) return f.siblings[f.index - 1]!.id
-  if (f.index < f.siblings.length - 1) return f.siblings[f.index + 1]!.id
-  return f.parentId
-}
-
-/** Move the block with `id` one step within its container (`dir` -1 up / +1 down); clamps at the edges. */
-export function moveById(blocks: BlockRow[], id: string, dir: -1 | 1): BlockRow[] {
-  return updateContaining(blocks, id, (arr, i) => {
-    const to = i + dir
-    if (to < 0 || to >= arr.length) return arr
-    return reorder(arr, i, to)
-  })
-}
-
-/** Duplicate the block with `id` (fresh ids throughout) right after it; returns the new tree + new id. */
-export function duplicateById(blocks: BlockRow[], id: string, genId: GenId): { tree: BlockRow[]; newId: string } {
-  let newId = ''
-  const tree = updateContaining(blocks, id, (arr, i) => {
-    const copy = cloneBlockTree(arr[i]!, genId)
-    newId = copy.id
-    const next = [...arr]
-    next.splice(i + 1, 0, copy)
-    return next
-  })
-  return { tree, newId }
-}
-
-/** Append a seeded block of `type` at the root (`parentId` null) or into a parent's slot; returns the
- *  new tree + the new block's id. */
-export function addBlock(
-  blocks: BlockRow[],
-  parentId: string | null,
-  slotName: string | null,
-  type: string,
-  schemas: Record<string, SerializedBlock>,
-  genId: GenId,
-): { tree: BlockRow[]; newId: string } {
-  const block = blankBlock(type, schemas, genId)
-  if (parentId === null || slotName === null) return { tree: [...blocks, block], newId: block.id }
-  const tree = updateBlock(blocks, parentId, (parent) => {
-    const cur = Array.isArray(parent.slots?.[slotName]) ? (parent.slots![slotName] as BlockRow[]) : []
-    return { ...parent, slots: { ...(parent.slots ?? {}), [slotName]: [...cur, block] } }
-  })
-  return { tree, newId: block.id }
-}
-
-/** Ids of every block that itself has an error OR has a descendant with one (ancestor roll-up), for
- *  tree badges. `directIds` are the blocks the error map keys directly. */
-export function errorBearingIds(blocks: BlockRow[], directIds: Set<string>): Set<string> {
-  const out = new Set<string>()
-  function walk(arr: BlockRow[]): boolean {
-    let any = false
-    for (const b of arr) {
-      let descendantHasError = false
-      if (b.slots) {
-        for (const sub of Object.values(b.slots)) {
-          if (Array.isArray(sub) && walk(sub as BlockRow[])) descendantHasError = true
-        }
-      }
-      if (directIds.has(b.id) || descendantHasError) {
-        out.add(b.id)
-        any = true
-      }
-    }
-    return any
-  }
-  walk(blocks)
-  return out
-}

package/layers/admin/app/utils/collection-ops.ts

@@ -1,69 +0,0 @@
-// Wire shapes for the collection batch endpoint, shared by the ops composable and the delete dialog.
-// Mirrors media/app/utils/ops.ts: one definition, no drift between the caller and the confirm UI.
-import type { SerializedAction } from '@michaelthielemann/kestrel-core'
-
-/** The four batch actions the command endpoint accepts (a row action is a bulk op with one id). */
-export type BatchAction = 'delete' | 'publish' | 'unpublish' | 'duplicate'
-
-/** The built-in actions the admin renders with its own dedicated presentation (Delete/Duplicate buttons,
- *  the Publish/Unpublish pair) — always present on the wire, but never re-rendered generically. */
-const BUILTIN_ACTION_NAMES = new Set(['deleteMany', 'duplicate'])
-
-/** The schema-driven actions beyond the built-ins — what a consumer's `definePipeline` adds. */
-export function customActions(actions: SerializedAction[]): SerializedAction[] {
-  return actions.filter((a) => !BUILTIN_ACTION_NAMES.has(a.name))
-}
-
-/** Custom actions invokable from the bulk-selection bar. */
-export function bulkCustomActions(actions: SerializedAction[]): SerializedAction[] {
-  return customActions(actions).filter((a) => a.kind === 'bulk' || a.kind === 'both')
-}
-
-/** Custom actions invokable from a single row. */
-export function recordCustomActions(actions: SerializedAction[]): SerializedAction[] {
-  return customActions(actions).filter((a) => a.kind === 'record' || a.kind === 'both')
-}
-
-/** What a batch pipeline answers with: `deleteMany`/`updateMany` a count plus the ids they touched,
- *  `duplicate` the created rows. */
-export type BatchPipelineResult = { count: number, ids: number[] } | { id: number }[]
-
-/** The batch outcome the list UI reports. For `duplicate`, `ids` are the CREATED rows. A custom action's
- *  `action` is its pipeline name — not one of the four built-ins. */
-export interface BulkResult {
-  action: BatchAction | (string & {})
-  count: number
-  ids: number[]
-}
-
-/** GET /api/{collection}/referrers?ids=1,2,3 response: id -> how many other records reference it.
- *  `checked` is false when the index lookup itself failed, in which case `counts` is empty because nothing
- *  could be read — NOT because nothing links to the selection. */
-export interface ReferrerCounts {
-  counts: Record<string, number>
-  checked: boolean
-}
-
-/** The pre-delete summary shown in the confirm dialog: how many rows, and how many of them other
- *  records still link to (aggregated from the referrer counts). */
-export interface BatchDeleteReport {
-  /** How many rows are about to be deleted. */
-  count: number
-  /** How many of those rows are referenced by at least one other record. */
-  referencedCount: number
-  /** Per-id breakdown for the referenced rows (id + inbound referrer count), in input order. */
-  referenced: { id: number; referrers: number }[]
-  /** Whether the referrer lookup actually ran. `false` means the check FAILED (not "none found"), so
-   *  the dialog must warn that inbound links are unverified rather than imply a safe delete. */
-  checked: boolean
-}
-
-/** Fold the referrer-count map into a delete report — pure, so it is unit-testable without a network.
- *  `checked` is the lookup's own outcome and is carried through untouched: an empty `counts` is ambiguous
- *  on its own, and only this flag tells the dialog whether it may claim nothing links to the selection. */
-export function buildDeleteReport(ids: number[], counts: Record<string, number>, checked: boolean): BatchDeleteReport {
-  const referenced = ids
-    .map((id) => ({ id, referrers: Number(counts[String(id)] ?? 0) }))
-    .filter((r) => r.referrers > 0)
-  return { count: ids.length, referencedCount: referenced.length, referenced, checked }
-}

package/layers/admin/app/utils/dead-refs.ts

@@ -1,30 +0,0 @@
-// Client-side shaping of the per-record dead-reference map (the `/dead-refs` endpoint payload) into the
-// sets the editor renders: which block nodes carry a stale reference (fed through `errorBearingIds` for
-// the tree roll-up, exactly like block errors) and which field keys are stale at a given location. Pure
-// + Vue-free so it unit-tests directly (happy-dom can't render the teleported field widgets).
-
-/** One stale reference a record holds, with its field/block location + why it is dead. Wire shape of the
- *  server's `LocatedDeadRef`; kept here so the admin client doesn't import the server (drizzle) module. */
-export interface DeadRef {
-  field: string
-  blockId?: string
-  collection: string
-  id: number
-  reason: 'missing' | 'unpublished'
-}
-
-/** Block-node ids that DIRECTLY hold a dead reference — feed into `errorBearingIds` for the tree roll-up. */
-export function deadBlockIds(refs: DeadRef[]): Set<string> {
-  const out = new Set<string>()
-  for (const r of refs) if (r.blockId) out.add(r.blockId)
-  return out
-}
-
-/** Field keys with a dead reference at a location: a block id, or `null` for the record/page root. */
-export function deadFieldsAt(refs: DeadRef[], blockId: string | null): Set<string> {
-  const out = new Set<string>()
-  for (const r of refs) {
-    if (blockId === null ? !r.blockId : r.blockId === blockId) out.add(r.field)
-  }
-  return out
-}