@ultimat3/admin 29.4.0 → 30.0.0

package/src/error-groups-store.ts

@@ -0,0 +1,173 @@
+// Single responsibility: what an error GROUP is — one row per `errorFingerprint`, first and last
+// seen, a count and one redacted sample — the store seam that keeps them, and its memory twin. The
+// Postgres store is `error-groups-pg.ts`; the sink that feeds either is `error-groups-sink.ts`.
+
+import { finiteCount } from '@ultimat3/core';
+import type { PurgeTarget } from '@ultimat3/jobs';
+import { ERROR_GROUPS_TABLE } from './error-groups-schema';
+
+/** Triage state. `resolved` re-opens on the next occurrence; `ignored` stays ignored. */
+export const ERROR_GROUP_STATUSES = ['open', 'resolved', 'ignored'] as const;
+
+export type ErrorGroupStatus = (typeof ERROR_GROUP_STATUSES)[number];
+
+/** One report, kept as the group's example: already redacted, never the thrown value. */
+export interface ErrorGroupSample {
+  readonly at: string;
+  readonly severity: string;
+  readonly title: string;
+  readonly cause: string;
+  readonly fix: string;
+  readonly release: string | null;
+  readonly environment: string;
+  readonly requestId: string | null;
+  readonly traceId: string | null;
+  readonly meta: Readonly<Record<string, unknown>> | null;
+  readonly stack: string | null;
+}
+
+/** What the sink hands a store: `count` reports of one group, the newest at `at`. */
+export interface ErrorGroupOccurrence {
+  readonly fingerprint: string;
+  readonly code: string;
+  readonly source: string;
+  readonly operation: string | null;
+  /** The cause's head, the line a list shows. */
+  readonly message: string;
+  readonly at: Date;
+  readonly count: number;
+  readonly sample: ErrorGroupSample;
+}
+
+export interface ErrorGroup {
+  readonly fingerprint: string;
+  readonly code: string;
+  readonly source: string;
+  readonly operation: string | null;
+  readonly message: string;
+  readonly status: ErrorGroupStatus;
+  readonly firstSeen: string;
+  readonly lastSeen: string;
+  readonly count: number;
+  readonly sample: ErrorGroupSample;
+}
+
+export interface ErrorGroupsQuery {
+  readonly status?: ErrorGroupStatus | undefined;
+  /** Newest-seen first. Default 50, at most `ERROR_GROUPS_MAX_LIMIT`. */
+  readonly limit?: number | undefined;
+}
+
+export const ERROR_GROUPS_DEFAULT_LIMIT = 50;
+export const ERROR_GROUPS_MAX_LIMIT = 500;
+
+export interface ErrorGroupsStore {
+  readonly kind: 'memory' | 'postgres';
+  /**
+   * Upsert on the fingerprint. `isNew` is true for exactly ONE caller per group, however many
+   * replicas raced to insert it — the answer `onNewGroup` is enqueued on.
+   */
+  record(occurrence: ErrorGroupOccurrence): Promise<{ readonly isNew: boolean }>;
+  list(query?: ErrorGroupsQuery): Promise<readonly ErrorGroup[]>;
+  get(fingerprint: string): Promise<ErrorGroup | undefined>;
+  /** The group after the change, or `undefined` when there is no such group. */
+  setStatus(fingerprint: string, status: ErrorGroupStatus): Promise<ErrorGroup | undefined>;
+  /** Deletes every group last seen before `beforeMs` (epoch ms); answers how many went. */
+  purge(beforeMs: number): Promise<number>;
+}
+
+/** The list limit, screened: a `NaN` here is `slice(0, NaN)`, an empty screen that looks fine. */
+export function errorGroupsLimit(subject: string, limit: number | undefined): number {
+  const asked = finiteCount(subject, 'limit', limit ?? ERROR_GROUPS_DEFAULT_LIMIT, 1);
+  return Math.min(asked, ERROR_GROUPS_MAX_LIMIT);
+}
+
+/** `resolved` → `open` on a new occurrence: a fault that came back is a regression to look at. */
+export const statusAfterOccurrence = (status: ErrorGroupStatus): ErrorGroupStatus =>
+  status === 'resolved' ? 'open' : status;
+
+/** For tests and `x dev`: one process's heap, held to the same contract as the Postgres store. */
+export function memoryErrorGroupsStore(): ErrorGroupsStore {
+  const groups = new Map<string, ErrorGroup>();
+  return {
+    kind: 'memory',
+    async record(occurrence) {
+      const at = occurrence.at.toISOString();
+      const seen = groups.get(occurrence.fingerprint);
+      if (seen === undefined) {
+        groups.set(occurrence.fingerprint, {
+          fingerprint: occurrence.fingerprint,
+          code: occurrence.code,
+          source: occurrence.source,
+          operation: occurrence.operation,
+          message: occurrence.message,
+          status: 'open',
+          firstSeen: at,
+          lastSeen: at,
+          count: occurrence.count,
+          sample: occurrence.sample,
+        });
+        return { isNew: true };
+      }
+      groups.set(occurrence.fingerprint, {
+        ...seen,
+        message: occurrence.message,
+        status: statusAfterOccurrence(seen.status),
+        lastSeen: at > seen.lastSeen ? at : seen.lastSeen,
+        count: seen.count + occurrence.count,
+        sample: occurrence.sample,
+      });
+      return { isNew: false };
+    },
+    async list(query = {}) {
+      const limit = errorGroupsLimit('memoryErrorGroupsStore', query.limit);
+      return [...groups.values()]
+        .filter((group) => query.status === undefined || group.status === query.status)
+        .sort((a, b) =>
+          a.lastSeen === b.lastSeen
+            ? a.fingerprint.localeCompare(b.fingerprint)
+            : a.lastSeen < b.lastSeen
+              ? 1
+              : -1,
+        )
+        .slice(0, limit);
+    },
+    async get(fingerprint) {
+      return groups.get(fingerprint);
+    },
+    async setStatus(fingerprint, status) {
+      const seen = groups.get(fingerprint);
+      if (seen === undefined) return undefined;
+      const next = { ...seen, status };
+      groups.set(fingerprint, next);
+      return next;
+    },
+    async purge(beforeMs) {
+      const before = new Date(beforeMs).toISOString();
+      let removed = 0;
+      for (const [fingerprint, group] of groups) {
+        if (group.lastSeen >= before) continue;
+        groups.delete(fingerprint);
+        removed += 1;
+      }
+      return removed;
+    },
+  };
+}
+
+export interface ErrorGroupsPurgeOptions {
+  /** REQUIRED: how long a group nobody has seen again is kept is the app's decision. */
+  readonly olderThanMs: number;
+}
+
+/** The sweep `purgeJob` runs: groups last seen more than `olderThanMs` before the job's clock. */
+export function errorGroupsPurgeTarget(
+  store: ErrorGroupsStore,
+  options: ErrorGroupsPurgeOptions,
+): PurgeTarget {
+  const olderThanMs = finiteCount('errorGroupsPurgeTarget', 'olderThanMs', options.olderThanMs, 1);
+  return {
+    name: ERROR_GROUPS_TABLE,
+    purgeExpired: (nowMs) => store.purge(nowMs - olderThanMs),
+  };
+}

package/src/error-groups.ts

@@ -0,0 +1,24 @@
+// `@ultimat3/admin/error-groups` — the error-groups sink and its two stores, and nothing else:
+// the sink is an `ErrorReporter` EVERY role installs (a worker's failures are grouped too), so it
+// must load without one admin screen. The screens are `errorGroupsPages` on the main barrel.
+
+export { type PostgresErrorGroupsStoreOptions, postgresErrorGroupsStore } from './error-groups-pg';
+export {
+  ERROR_GROUPS_PER_MINUTE,
+  type ErrorGroupNotice,
+  type ErrorGroupsSink,
+  type ErrorGroupsSinkOptions,
+  errorGroupsSink,
+} from './error-groups-sink';
+export {
+  ERROR_GROUP_STATUSES,
+  type ErrorGroup,
+  type ErrorGroupOccurrence,
+  type ErrorGroupSample,
+  type ErrorGroupStatus,
+  type ErrorGroupsPurgeOptions,
+  type ErrorGroupsQuery,
+  type ErrorGroupsStore,
+  errorGroupsPurgeTarget,
+  memoryErrorGroupsStore,
+} from './error-groups-store';

package/src/errors-detail.tsx

@@ -0,0 +1,60 @@
+// `/admin/errors/:fingerprint`: one group — its counts, its status and the redacted sample the sink
+// kept. Instants are printed as the ISO text the store holds (UTC, said so), never formatted in an
+// ambient zone. A fingerprint with no group is a not-found body, not a blank page.
+
+import { t } from '@ultimat3/i18n';
+import { Card, Link } from '@ultimat3/ui';
+import type { JSX } from 'solid-js';
+import styles from './admin.module.scss';
+import type { ErrorGroupsStore } from './error-groups-store';
+import { jsonText } from './json-text';
+
+export async function ErrorsDetail(props: {
+  readonly store: ErrorGroupsStore;
+  readonly listPath: string;
+  readonly fingerprint: string;
+}): Promise<JSX.Element> {
+  const group = await props.store.get(props.fingerprint);
+  if (group === undefined) {
+    return (
+      <Card>
+        <p class="x-admin-empty">{t('admin.errors.missing')}</p>
+        <Link href={props.listPath}>{t('admin.errors.back')}</Link>
+      </Card>
+    );
+  }
+  const { sample } = group;
+  const facts: readonly (readonly [string, string])[] = [
+    ['admin.errors.field.code', group.code],
+    ['admin.errors.field.source', group.source],
+    ['admin.errors.field.operation', group.operation ?? ''],
+    ['admin.errors.field.status', t(`admin.errors.status.${group.status}`)],
+    ['admin.errors.field.count', String(group.count)],
+    ['admin.errors.field.first-seen', `${group.firstSeen} UTC`],
+    ['admin.errors.field.last-seen', `${group.lastSeen} UTC`],
+    ['admin.errors.field.release', sample.release ?? ''],
+    ['admin.errors.field.environment', sample.environment],
+    ['admin.errors.field.request', sample.requestId ?? ''],
+    ['admin.errors.field.trace', sample.traceId ?? ''],
+  ];
+  return (
+    <Card header={<h2 class={styles['mono']}>{group.fingerprint}</h2>}>
+      <dl>
+        {facts.map(([key, value]) => (
+          <>
+            <dt>{t(key)}</dt>
+            <dd class={styles['mono']}>{value}</dd>
+          </>
+        ))}
+      </dl>
+      <h3>{sample.title}</h3>
+      <p>{sample.cause}</p>
+      <p>
+        <code>{sample.fix}</code>
+      </p>
+      {sample.meta === null ? null : <pre class={styles['mono']}>{jsonText(sample.meta)}</pre>}
+      {sample.stack === null ? null : <pre class={styles['mono']}>{sample.stack}</pre>}
+      <Link href={props.listPath}>{t('admin.errors.back')}</Link>
+    </Card>
+  );
+}

package/src/errors-list.tsx

@@ -0,0 +1,74 @@
+// `/admin/errors`: every error group the sink folded, newest-seen first, one native GET form to
+// pick a status. No script, no state: the URL is the screen (`?status=`), and a parameter this
+// screen does not read is the list's 400, never the unfiltered list.
+
+import { t } from '@ultimat3/i18n';
+import { Badge, Card, Link } from '@ultimat3/ui';
+import type { JSX } from 'solid-js';
+import styles from './admin.module.scss';
+import {
+  ERROR_GROUP_STATUSES,
+  type ErrorGroupStatus,
+  type ErrorGroupsStore,
+} from './error-groups-store';
+import { AdminFilterInvalidError } from './errors';
+
+/** `?status=` and nothing else; empty is "every status". */
+export function errorsStatusOf(url: URL): ErrorGroupStatus | undefined {
+  for (const key of url.searchParams.keys()) {
+    if (key === 'status') continue;
+    throw new AdminFilterInvalidError({
+      entity: 'x_error_groups',
+      asked: key,
+      cause: 'is not a parameter of the error groups screen',
+      known: ['status'],
+    });
+  }
+  const asked = url.searchParams.get('status') ?? '';
+  if (asked === '') return undefined;
+  const status = ERROR_GROUP_STATUSES.find((known) => known === asked);
+  if (status !== undefined) return status;
+  throw new AdminFilterInvalidError({
+    entity: 'x_error_groups',
+    asked: `status=${asked}`,
+    cause: 'is not a triage status',
+    known: ERROR_GROUP_STATUSES.map((known) => `status=${known}`),
+  });
+}
+
+export async function ErrorsList(props: {
+  readonly store: ErrorGroupsStore;
+  readonly basePath: string;
+  readonly url: string;
+}): Promise<JSX.Element> {
+  const status = errorsStatusOf(new URL(props.url));
+  const groups = await props.store.list(status === undefined ? {} : { status });
+  return (
+    <Card>
+      <nav class={styles['filters']} aria-label={t('admin.errors.filter.status')}>
+        <Link href={props.basePath}>{t('admin.filter.any')}</Link>{' '}
+        {ERROR_GROUP_STATUSES.map((one) => (
+          <Link href={`${props.basePath}?status=${one}`}>{t(`admin.errors.status.${one}`)}</Link>
+        ))}
+      </nav>
+      {groups.length === 0 ? (
+        <p class="x-admin-empty">{t('admin.errors.empty')}</p>
+      ) : (
+        <ol class={styles['list']}>
+          {groups.map((group) => (
+            <li data-fingerprint={group.fingerprint}>
+              <a href={`${props.basePath}/${encodeURIComponent(group.fingerprint)}`}>
+                <code>{group.code}</code>
+              </a>{' '}
+              <span>{group.message}</span>{' '}
+              <span class={styles['mono']}>{group.operation ?? group.source}</span>{' '}
+              <Badge>{t('admin.errors.count', { count: group.count })}</Badge>{' '}
+              <span data-status={group.status}>{t(`admin.errors.status.${group.status}`)}</span>{' '}
+              <code>{group.lastSeen}</code>
+            </li>
+          ))}
+        </ol>
+      )}
+    </Card>
+  );
+}

package/src/errors.ts

@@ -29,6 +29,7 @@ export const ADMIN_OWNED_ERROR_CODES = [
   'X_ADMIN_FILTER_INVALID',
   'X_ADMIN_ACTION_NOT_APPLICABLE',
   'X_ADMIN_MOUNT_MISSING',
+  'X_ADMIN_VIEW_WRITE',
 ] as const;
 
 /**
@@ -62,6 +63,7 @@ export const ADMIN_ERROR_TITLES: Readonly<Record<AdminOwnedErrorCode, string>> =
     'an admin list was asked for a filter, sort or scope its resource does not derive',
   X_ADMIN_ACTION_NOT_APPLICABLE: 'an admin action was run on a row its when() rule excludes',
   X_ADMIN_MOUNT_MISSING: 'an admin batch job ran in a process that never declared its admin',
+  X_ADMIN_VIEW_WRITE: 'an admin resource over a view entity offers a write',
 };
 
 // One unconditional call, so a second package claiming one of admin's codes throws
@@ -174,6 +176,8 @@ export class AdminFilterInvalidError extends UltimateError {
     cause: string;
     /** What the resource DOES answer, in the caller's own spelling. */
     known: readonly string[];
+    /** A site whose fix is not the manifest's — the audit trail's URL and its stores. */
+    fix?: string;
   }) {
     const known = input.known.length > 0 ? input.known.join(', ') : 'none';
     super({
@@ -181,7 +185,9 @@ export class AdminFilterInvalidError extends UltimateError {
       cause: `${input.entity}: "${input.asked}" ${input.cause} (this list answers: ${known})`,
       // The manifest records every resource's filters, sorts and scopes, so the command prints the
       // list this error names — for the resource, and for every other one.
-      fix: `x manifest --json   # admin[].resources lists the filters, sorts and scopes of "${input.entity}"`,
+      fix:
+        input.fix ??
+        `x manifest --json   # admin[].resources lists the filters, sorts and scopes of "${input.entity}"`,
     });
   }
 }

package/src/index.ts

@@ -75,6 +75,8 @@ export {
   type AuditSink,
   auditCursorOf,
   auditEntry,
+  auditEntryMatches,
+  auditWindow,
   deniedDraft,
   diffRows,
   memoryAuditLog,
@@ -83,6 +85,12 @@ export {
   type PostgresAuditLogOptions,
   postgresAuditLog,
 } from './audit-pg';
+export {
+  type AuditRequest,
+  auditHref,
+  auditRequestOf,
+  HISTORY_PARAM,
+} from './audit-request';
 // The audit table's DDL is `@ultimat3/admin/schema`'s alone — one import path for one statement.
 export {
   type AdminActor,
@@ -155,7 +163,6 @@ export {
 export {
   AdminDetail,
   type AdminDetailProps,
-  HISTORY_PARAM,
 } from './detail';
 export {
   type AdminColumnFacts,
@@ -163,6 +170,9 @@ export {
   adminColumnsOf,
   adminSealedColumnsOf,
 } from './entity-columns';
+// The screens only. The sink and its stores are `@ultimat3/admin/error-groups`'s alone: every role
+// installs the sink, and this barrel would carry every admin screen into a worker's graph.
+export { ERRORS_READ, type ErrorGroupsPagesOptions, errorGroupsPages } from './error-groups-pages';
 // The /_x dashboard is NOT re-exported here — it has its own door, `@ultimat3/admin/dev`, so a
 // host that only mounts the dev panels never loads a production admin component.
 export {
@@ -380,6 +390,7 @@ export {
   type AdminScopeWhere,
   LOOKUP_SEGMENT,
 } from './resource-list';
+export { AdminViewWriteError, VIEW_OPERATIONS } from './resource-operations';
 export {
   type AdminRouteConfig,
   type AdminRouteMatch,

package/src/list-filters.ts

@@ -81,22 +81,26 @@ const onCalendar = (raw: string): boolean => {
 };
 
 /**
- * A typed instant → the ISO string a driver compares. `datetime-local` posts `YYYY-MM-DDTHH:mm`
- * and the control says UTC beside the box — the same contract the edit form states — and a bare
- * date is that day's first instant in UTC.
+ * An instant → the ISO string a store compares. It names its zone — an offset or `Z` — or it is a
+ * bare `YYYY-MM-DD`, that day's first instant in UTC. A zoneless time is refused: no store invents
+ * a zone. What the audit stores and the audit URL read.
  */
-const instantOf = (raw: string): string | undefined => {
+export const instantOf = (raw: string): string | undefined => {
   if (!onCalendar(raw)) return undefined;
-  const text = DATE.test(raw)
-    ? `${raw}T00:00:00.000Z`
-    : LOCAL_MINUTE.test(raw)
-      ? `${raw}:00.000Z`
-      : raw;
+  const text = DATE.test(raw) ? `${raw}T00:00:00.000Z` : raw;
   if (!ZONED.test(text)) return undefined;
   const at = new Date(text);
   return Number.isNaN(at.getTime()) ? undefined : at.toISOString();
 };
 
+/**
+ * A `datetime-local` control's value as the UTC its label states: `YYYY-MM-DDTHH:mm` gets its `Z`
+ * HERE, the one place a form's minute is given a zone, and everything else is `instantOf`'s. A
+ * list filter's range control and the audit trail's form post exactly that shape.
+ */
+export const utcFormInstantOf = (raw: string): string | undefined =>
+  instantOf(LOCAL_MINUTE.test(raw) ? `${raw}Z` : raw);
+
 interface Refusal {
   readonly cause: string;
 }
@@ -127,7 +131,7 @@ function scalarOf(field: AdminField, raw: unknown): Scalar | Refusal {
           : { cause: `takes a YYYY-MM-DD date, got ${shown(raw)}` };
       }
       return (
-        instantOf(raw) ?? {
+        utcFormInstantOf(raw) ?? {
           cause: `takes a UTC instant (YYYY-MM-DDTHH:mm, or ISO-8601 with an offset), got ${shown(raw)}`,
         }
       );

package/src/mcp-tools.ts

@@ -5,6 +5,7 @@
 // Tool descriptions are literal English on purpose: they are protocol payload read by a
 // model, not UI copy read by a person, so they are not `t()` keys.
 
+import { toolDescription } from '@ultimat3/core';
 import { adminPermissionForAction, decideAction, permissionsForAction } from './action-gate';
 import type { AdminApp } from './admin';
 import { type AdminDecision, decideAll } from './authz';
@@ -73,7 +74,7 @@ const actionEnvelope = (action: AdminAction): readonly AdminToolField[] => [
 /** What an agent reads about when and over what an action runs — the schema cannot say it. */
 const actionDescription = (action: AdminAction): string =>
   [
-    action.mcp?.description ?? `Run the ${action.name} action.`,
+    toolDescription(action),
     action.when === undefined
       ? ''
       : ' Applies only to some rows: a row it does not apply to is refused with X_ADMIN_ACTION_NOT_APPLICABLE.',

package/src/registry.ts

@@ -81,6 +81,11 @@ export interface AdminEntity {
    * renders it as an input — the acting actor's tenant is the only value it may hold.
    */
   readonly $tenantColumn?: string | null;
+  /**
+   * `entity({ view })`'s query, `null` on a table. Optional in this surface only because a
+   * hand-built fixture has none; a view offers reads alone (`resource-operations.ts`).
+   */
+  readonly $viewQuery?: { readonly materialized: boolean } | null;
   /** Resolves foreign-key targets. See `entity-columns.ts` for what the admin takes from it. */
   $describe(): AdminEntityDescription;
 }

package/src/resource-operations.ts

@@ -0,0 +1,36 @@
+// Single responsibility: which operations an admin resource offers. Every one, by default, on a
+// table; only the reads on a view entity (`entity({ view })`), whose rows Postgres derives — so a
+// view gets no create/edit/delete route, button or MCP tool, and an override asking for one is
+// refused where it was declared.
+
+import { renderFixShellArg, UltimateError } from '@ultimat3/core';
+import { ADMIN_OPERATIONS, type AdminOperation } from './permissions';
+import type { AdminEntity } from './registry';
+
+/** What a view offers. `search` reads, as `list` does. */
+export const VIEW_OPERATIONS: readonly AdminOperation[] = ['list', 'detail', 'search'];
+
+const READS: ReadonlySet<AdminOperation> = new Set(VIEW_OPERATIONS);
+
+/** An admin resource over a view entity was declared with a write it can never perform. */
+export class AdminViewWriteError extends UltimateError {
+  constructor(input: { readonly entity: string; readonly writes: readonly AdminOperation[] }) {
+    super({
+      code: 'X_ADMIN_VIEW_WRITE',
+      cause: `${input.entity} is a view (entity({ view })), whose rows Postgres derives, and its admin resource offers ${input.writes.join(', ')} — every one would be refused with X_ENTITY_VIEW_READ_ONLY`,
+      fix: `x entities show ${renderFixShellArg(input.entity, '<entity>')} --json   # then drop operations from its admin resource (a view lists read-only), or name only ${VIEW_OPERATIONS.join(', ')}`,
+    });
+  }
+}
+
+export function operationsFor(
+  entity: AdminEntity,
+  declared: readonly AdminOperation[] | undefined,
+): readonly AdminOperation[] {
+  const isView = entity.$viewQuery !== undefined && entity.$viewQuery !== null;
+  if (!isView) return declared ?? ADMIN_OPERATIONS;
+  if (declared === undefined) return VIEW_OPERATIONS;
+  const writes = declared.filter((operation) => !READS.has(operation));
+  if (writes.length > 0) throw new AdminViewWriteError({ entity: entity.$name, writes });
+  return declared;
+}

package/src/resource.ts

@@ -12,7 +12,7 @@ import {
   AdminRepoUnboundError,
 } from './errors';
 import type { AdminField } from './fields';
-import { ADMIN_OPERATIONS, type AdminOperation } from './permissions';
+import type { AdminOperation } from './permissions';
 import type { AdminAction, AdminEntity, AdminRepo, AdminRow, AdminSort } from './registry';
 import { type AdminFieldOverride, deriveField, secretField } from './resource-fields';
 import {
@@ -31,6 +31,7 @@ import {
   rowScopeOf,
   scopesOf,
 } from './resource-list';
+import { operationsFor } from './resource-operations';
 
 /** Six columns is what fits a laptop viewport without horizontal scroll. */
 const MAX_LIST_FIELDS = 6;
@@ -348,7 +349,7 @@ export function adminResource<Row extends AdminRow = AdminRow>(
     // `fetched.length > NaN` is false, the page is never trimmed, `hasMore` is false and the repo
     // is asked for `limit: NaN`. At least 1 — a page with no rows on it is not a page.
     pageSize: finiteCount('adminResource', 'pageSize', opts.pageSize ?? DEFAULT_PAGE_SIZE, 1),
-    operations: opts.operations ?? ADMIN_OPERATIONS,
+    operations: operationsFor(entity, opts.operations),
     actions,
     ...(opts.repo === undefined ? {} : { repo: opts.repo }),
     field(name: string): AdminField {

package/src/screen-resource.tsx

@@ -16,6 +16,7 @@ import {
 import type { AdminApp, AdminRoute } from './admin';
 import styles from './admin.module.scss';
 import { auditCursorOf } from './audit';
+import { HISTORY_PARAM, historyCursorOf, historyCursorText } from './audit-request';
 import {
   adminCreate,
   adminDestroy,
@@ -25,7 +26,7 @@ import {
   canOperate,
   decideOperation,
 } from './crud';
-import { AdminDetail, HISTORY_PARAM, historyCursorOf, historyCursorText } from './detail';
+import { AdminDetail } from './detail';
 import { AdminFilterInvalidError } from './errors';
 import { AdminForm } from './form';
 import { decodeForm, posted } from './form-decode';