@ultimat3/cli 24.0.0 → 25.1.0

package/src/templates/scaffold-dashboard-example-tests.ts

@@ -0,0 +1,208 @@
+// The tests the `--example` dashboard ships beside its page and its view module — split from
+// `scaffold-dashboard-example.ts` to keep each file under the ceiling. Emitted, never run here: the
+// generated app's own `bun test` runs them, and the scaffold gate holds that run to green.
+
+import { sortedImports } from './imports';
+import type { NameSet } from './naming';
+
+export const exampleViewTest =
+  (): string => `// The numbers the dashboard shows, pinned against a fixed clock. The interesting cases are the
+// window edges: a post from eight days ago is in the prior week, not this one, and a day with no
+// posts is still a bar.
+import { expect, unitTest } from '@ultimat3/testing';
+import {
+  bucketByDay,
+  formatCount,
+  type PostRow,
+  postStats,
+  priceCeilings,
+  priceMix,
+  toPostRow,
+} from './dashboard-view';
+
+const NOW = new Date('2026-03-15T12:00:00.000Z');
+const DAY_MS = 86_400_000;
+
+const row = (id: string, daysAgo: number, minor = 0, currency = 'USD'): PostRow => ({
+  id,
+  title: \`post \${id}\`,
+  price: { minor, currency },
+  createdAt: new Date(NOW.getTime() - daysAgo * DAY_MS).toISOString(),
+});
+
+const rows = [row('a', 1), row('b', 3), row('c', 8)];
+
+unitTest('postStats counts the week, compares it with the prior one, and counts today', () => {
+  const stats = postStats(rows, NOW);
+  expect(stats.total).toBe(3);
+  expect(stats.lastWeek).toBe(2);
+  // Two this week against one the week before: +100%, and the chip says so.
+  expect(stats.delta).toEqual({ text: '+100%', trend: 'up' });
+  // 'a' is yesterday and nothing was created on 03-15 itself.
+  expect(stats.today).toBe(0);
+  expect(postStats([...rows, row('d', 0.25)], NOW).today).toBe(1);
+});
+
+unitTest('a zero baseline yields no delta, and no rows count nothing', () => {
+  expect(postStats([row('a', 1)], NOW).delta).toBeUndefined();
+  expect(postStats([], NOW)).toEqual({ total: 0, lastWeek: 0, delta: undefined, today: 0 });
+});
+
+unitTest('bucketByDay is one bar per day, oldest first, quiet days included', () => {
+  const points = bucketByDay(rows, NOW, 14);
+  expect(points).toHaveLength(14);
+  expect(points.at(-1)?.key).toBe('03-15');
+  expect(points[0]?.key).toBe('03-02');
+  expect(points.reduce((sum, point) => sum + point.value, 0)).toBe(3);
+  // Eight days ago is 03-07: inside a 14-day window, so the bar is there.
+  expect(points.find((point) => point.key === '03-07')?.value).toBe(1);
+  expect(bucketByDay([], NOW, 3).map((point) => point.value)).toEqual([0, 0, 0]);
+});
+
+unitTest('toPostRow serialises a Date, passes ISO text through, and keeps the price whole', () => {
+  const at = new Date('2026-01-02T03:04:05.000Z');
+  const price = { minor: 1900, currency: 'USD' };
+  expect(toPostRow({ id: 'x', title: 't', price, createdAt: at }).createdAt).toBe(at.toISOString());
+  expect(toPostRow({ id: 'x', title: 't', price, createdAt: '2026-01-01' })).toEqual({
+    id: 'x',
+    title: 't',
+    price,
+    createdAt: '2026-01-01',
+  });
+});
+
+unitTest('priceMix splits free from paid, and priceCeilings is the dearest per currency', () => {
+  const priced = [row('a', 1, 0), row('b', 1, 1900), row('c', 1, 500), row('d', 1, 300, 'JPY')];
+  expect(priceMix(priced)).toEqual({ free: 1, paid: 3 });
+  expect(priceMix([])).toEqual({ free: 0, paid: 0 });
+  // 300 yen is never measured against 1,900 cents: each currency has its own ceiling.
+  expect([...priceCeilings(priced)]).toEqual([
+    ['USD', 1900],
+    ['JPY', 300],
+  ]);
+});
+
+unitTest('formatCount follows the locale', () => {
+  expect(formatCount(1234, 'en')).toBe('1,234');
+  expect(formatCount(1234, 'de')).toBe('1.234');
+});
+`;
+
+export const examplePageTest = (
+  app: NameSet,
+): string => `// The dashboard, rendered as a request renders it: \`load\` reads the actor's org through the
+// slice's query — the in-memory driver under test — and the page turns the rows into tiles, a chart
+// and a table. Losing a policy is the other regression worth a test: the page's own, and the read's
+// — \`dashboard:read\` opens the page, and only \`post:read\` shows its posts.
+${sortedImports([
+  `import { driver } from '@${app.kebab}/db';`,
+  `import { useT } from '@${app.kebab}/i18n';`,
+  "import { ctxOf, frozenClock, isUltimateError, runWithContext } from '@ultimat3/core';",
+  "import { testActor } from '@ultimat3/policy';",
+  "import { dbUnavailable } from '@ultimat3/db';",
+  "import { afterEach, expect, renderRoute, unitTest } from '@ultimat3/testing';",
+])}
+// The app's API, as boot loads it: \`defineApi\` is what names the query the page reads, and a
+// query with no name is refused (X_QUERY_UNREGISTERED) before it reads a row.
+import '../../api';
+import { DEMO_ORG_ID } from '../../shared/demo-org';
+import * as repo from '../post/repo';
+import * as page from './page';
+
+const url = 'https://example.test/dashboard';
+// The read grant, a direct one: what a \`member\` holds in apps/web/shared/roles.ts.
+const read = 'post:read';
+const viewer = testActor('viewer', { orgId: DEMO_ORG_ID, permissions: [read] }).actor;
+const elsewhere = '00000000-0000-4000-8000-000000000009';
+const stranger = testActor('stranger', { orgId: elsewhere, permissions: [read] }).actor;
+
+const DAY_MS = 86_400_000;
+
+/**
+ * One post in the viewer's org, written the way the app writes one — \`daysAgo\` days before now.
+ * The request's clock is what stamps \`createdAt\`, so the test chooses the instant.
+ */
+const post = (title: string, daysAgo: number, minor = 0) => {
+  const clock = frozenClock(new Date(Date.now() - daysAgo * DAY_MS));
+  const draft = { orgId: DEMO_ORG_ID, title, price: { minor, currency: 'USD' } };
+  return runWithContext(ctxOf({ actor: viewer, clock }), () => repo.insert(draft));
+};
+
+/** The figure a tile shows, read off the markup by the \`stat\` the page gave it. */
+const stat = (html: string, name: string): string | undefined =>
+  html.match(new RegExp(\`data-stat="\${name}">([^<]*)<\`))?.[1];
+
+// One store per process: without this, one test's rows are the next test's fixtures.
+afterEach(() => {
+  driver.reset?.();
+});
+
+unitTest('the dashboard is gated, renders per request, and hydrates one island', async () => {
+  const view = await renderRoute(page, { url, actor: viewer });
+  expect(page.config.render).toBe('ssr');
+  expect(page.config.policy?.permission).toBe('dashboard:read');
+  expect(page.config.offline).toBe('runtime');
+  expect(page.config.budget.js).toBe('60kb');
+  // What the render emitted, beside what the config declares: the theme toggle, and only it.
+  expect(view.islands.map((island) => [island.moduleId, island.strategy])).toEqual([
+    ['shared-theme-toggle', 'visible'],
+  ]);
+});
+
+unitTest('it counts and lists the posts of the org that is looking', async () => {
+  await post('Last month', 30);
+  await post('This week', 3, 1900);
+  await post('Today', 0);
+  const view = await renderRoute(page, { url, actor: viewer });
+  // Newest first, as the query orders them — and each tile counts its own window.
+  expect(view.data.rows.map((row) => row.title)).toEqual(['Today', 'This week', 'Last month']);
+  expect(stat(view.html, 'posts-total')).toBe('3');
+  expect(stat(view.html, 'posts-week')).toBe('2');
+  expect(stat(view.html, 'posts-today')).toBe('1');
+  expect(stat(view.html, 'posts-paid')).toBe('1');
+  // One table row per post, each price with its in-cell bar.
+  expect(view.html.match(/<tr[^>]*\\sdata-row=/g)).toHaveLength(3);
+  expect(view.html.match(/data-inline-bar-value/g)).toHaveLength(3);
+  expect(view.text).toContain('$19.00');
+  // The trend is one filled series; the ring draws free and paid; the dial is a meter.
+  expect(view.html.match(/data-area="true"/g)).toHaveLength(1);
+  expect(view.html.match(/data-segment="/g)).toHaveLength(2);
+  expect(view.html).toContain('role="meter"');
+  expect(view.text).toContain('This week');
+  // The sidebar knows where it is.
+  expect(view.html).toMatch(/<a href="\\/dashboard" aria-current="page"/);
+});
+
+unitTest('another org sees none of them: the page says so instead of an empty table', async () => {
+  const t = useT();
+  await post('Not theirs', 0);
+  const view = await renderRoute(page, { url, actor: stranger });
+  expect(view.data.rows).toEqual([]);
+  expect(stat(view.html, 'posts-total')).toBe('0');
+  expect(view.html).not.toMatch(/<tr[^>]*\\sdata-row=/);
+  expect(view.text).toContain(t('app.dashboard.emptyTitle'));
+  expect(view.meta.title).toBe(t('app.dashboard.title'));
+  expect(view.meta.description).toBe(t('app.dashboard.description'));
+});
+
+unitTest('a viewer the post read refuses is refused, never shown the org’s posts', async () => {
+  await post('Not for them', 0);
+  // In the org, onto the page, without \`post:read\`: the query's policy decides, not the page's.
+  const outsider = testActor('outsider', { orgId: DEMO_ORG_ID }).actor;
+  const rendering = renderRoute(page, { url, actor: outsider });
+  const refused = await rendering.catch((error: unknown) => error);
+  expect(isUltimateError(refused) && refused.code).toBe('X_FORBIDDEN');
+});
+
+unitTest('the build measures the empty page: no database is not a failure there', async () => {
+  const measured = await page.dashboardData(() => Promise.reject(dbUnavailable('no database')));
+  // The clock is frozen under test, so the instant the windows are cut at is this one.
+  expect(measured).toEqual({ rows: [], now: new Date().toISOString() });
+});
+
+unitTest('any other failure of the read propagates', async () => {
+  const cause = new TypeError('the read broke');
+  const read = (): Promise<never> => Promise.reject(cause);
+  expect(await page.dashboardData(read).catch((error: unknown) => error)).toBe(cause);
+});
+`;

package/src/templates/scaffold-dashboard-example.ts

@@ -1,9 +1,11 @@
 // The `--example` dashboard: the seeded `post` slice from above. Real rows through the slice's own
-// repo, aggregated by a pure view module this file also emits, so the numbers are testable without
-// a database. The page's route declaration and its island come from `scaffold-dashboard-shared.ts`.
+// query — never its repo, which the `boundaries` step refuses a route (X_BOUNDARY_ROUTE_TO_DB) —
+// aggregated by a pure view module this file also emits, so the numbers are testable without a
+// database. The page's route declaration and its island come from `scaffold-dashboard-shared.ts`.
 
 import { sortedImports } from './imports';
 import type { GeneratedFile, NameSet } from './naming';
+import { examplePageTest, exampleViewTest } from './scaffold-dashboard-example-tests';
 import { DASHBOARD_DIR, routeConfig, themeActions, themeIsland } from './scaffold-dashboard-shared';
 
 // Plain strings for the framework lines, never template literals: the workspace-dependency scanner
@@ -12,20 +14,25 @@ import { DASHBOARD_DIR, routeConfig, themeActions, themeIsland } from './scaffol
 const examplePage = (
   app: NameSet,
 ): string => `// The authed dashboard: what the seeded \`post\` slice looks like from above. Real rows, read
-// through the slice's own repo and aggregated by \`dashboard-view.ts\`, which is pure so the numbers
-// are testable without a database.
+// through the slice's own query and aggregated by \`dashboard-view.ts\`, which is pure so the
+// numbers are testable without a database. Every chart is server markup — an svg and a hidden data table —
+// so the page's only script is still the theme toggle.
 //
 // \`useT()\`, not \`t\` from @ultimat3/i18n — see apps/web/site/page.tsx for why.
 ${sortedImports([
   `import { useT } from '@${app.kebab}/i18n';`,
   "import { isUltimateError } from '@ultimat3/core';",
   "import { currentLocale } from '@ultimat3/i18n';",
+  "import { formatMoney } from '@ultimat3/money';",
   "import { defineRoute, island } from '@ultimat3/render';",
   [
     'import {',
-    '  BarChart,',
+    '  AreaChart,',
     '  DataTable,',
+    '  DonutChart,',
+    '  Gauge,',
     '  Grid,',
+    '  InlineBar,',
     '  PageHeader,',
     '  RelativeTime,',
     '  Section,',
@@ -35,13 +42,15 @@ ${sortedImports([
   ].join('\n'),
 ])}
 import { Shell } from '../../shared/shell';
-import * as repo from '../post/repo';
+import { postList } from '../post/live/post-list';
 import {
   bucketByDay,
   CHART_DAYS,
   formatCount,
   type PostRow,
   postStats,
+  priceCeilings,
+  priceMix,
   toPostRow,
 } from './dashboard-view';
 import styles from './page.module.scss';
@@ -53,7 +62,7 @@ const ROW_LIMIT = 500;
 const TABLE_ROWS = 10;
 
 export interface DashboardData {
-  /** Newest first, as the repo orders them. */
+  /** Newest first, as the query orders them. */
   readonly rows: readonly PostRow[];
   /** The instant the windows were cut at, so server and test agree on "the last 7 days". */
   readonly now: string;
@@ -78,11 +87,13 @@ export async function dashboardData(
 }
 
 /**
- * Whose posts: the ACTOR's org. The repo names none — the typed handle scopes every read to the
- * request's actor — so the viewer \`auth/dev-actor.ts\` resolves sees the rows
+ * Whose posts: the ACTOR's org, and only for an actor \`post:read\` admits. Through the query, never
+ * the repo: \`dashboard:read\` lets a viewer onto this page and says nothing about posts, and the
+ * query is where the read's policy, order and bound live. The typed handle under it scopes every
+ * read to the request's actor, so the viewer \`auth/dev-actor.ts\` resolves sees the rows
  * \`packages/db/src/seed.ts\` wrote, and a real session sees its own org's the day one exists.
  */
-const load = (): Promise<DashboardData> => dashboardData(() => repo.list(ROW_LIMIT));
+const load = (): Promise<DashboardData> => dashboardData(() => postList({ limit: ROW_LIMIT }));
 
 ${themeIsland}
 
@@ -98,7 +109,10 @@ export function Page(props: PageProps) {
   const now = new Date(props.data.now);
   const stats = postStats(props.data.rows, now);
   const points = bucketByDay(props.data.rows, now, CHART_DAYS);
+  const mix = priceMix(props.data.rows);
   const latest = props.data.rows.slice(0, TABLE_ROWS);
+  // Per currency: a bar is a share of the dearest post IN ITS CURRENCY, never of another's minor units.
+  const ceilings = priceCeilings(latest);
 
   return (
     <Shell
@@ -109,8 +123,8 @@ export function Page(props: PageProps) {
     >
       <div class={styles.page}>
         <PageHeader title={t('app.dashboard.title')} description={t('app.dashboard.subtitle')} />
-        {/* 10rem, not the catalog's 16rem default: three tiles fit across a tablet's main column
-            instead of leaving one alone on a second row. */}
+        {/* 10rem, not the catalog's 16rem default: two tiles sit side by side on a phone and four
+            across a monitor, instead of one alone on a row. */}
         <Grid minColumn="10rem">
           <StatTile
             stat="posts-total"
@@ -131,10 +145,47 @@ export function Page(props: PageProps) {
             value={formatCount(stats.today, locale)}
             hint={t('app.dashboard.hintToday')}
           />
+          <StatTile
+            stat="posts-paid"
+            label={t('app.dashboard.statPaid')}
+            value={formatCount(mix.paid, locale)}
+            hint={t('app.dashboard.hintPaid')}
+          />
         </Grid>
-        <Section title={t('app.dashboard.chartTitle')} description={t('app.dashboard.chartRange')}>
-          <BarChart label={t('app.dashboard.chartLabel')} points={points} />
-        </Section>
+        <div class={styles.charts}>
+          <Section
+            title={t('app.dashboard.chartTitle')}
+            description={t('app.dashboard.chartRange')}
+          >
+            <AreaChart
+              label={t('app.dashboard.chartLabel')}
+              keys={points.map((point) => point.key)}
+              series={[
+                { label: t('app.dashboard.chartSeries'), values: points.map((p) => p.value) },
+              ]}
+              keyLabel={t('app.dashboard.chartKey')}
+            />
+          </Section>
+          <Section title={t('app.dashboard.mixTitle')}>
+            <div class={styles.side}>
+              <DonutChart
+                label={t('app.dashboard.mixLabel')}
+                segments={[
+                  { label: t('app.dashboard.mixFree'), value: mix.free },
+                  { label: t('app.dashboard.mixPaid'), value: mix.paid },
+                ]}
+                centreLabel={t('app.dashboard.mixTotal')}
+                keyLabel={t('app.dashboard.mixKey')}
+                valueLabel={t('app.dashboard.statTotal')}
+              />
+              <Gauge
+                label={t('app.dashboard.gaugeLabel')}
+                value={stats.lastWeek}
+                max={stats.total}
+              />
+            </div>
+          </Section>
+        </div>
         <Section title={t('app.dashboard.tableTitle')}>
           <DataTable
             caption={t('app.dashboard.tableCaption')}
@@ -143,9 +194,24 @@ export function Page(props: PageProps) {
             emptyTitle={t('app.dashboard.emptyTitle')}
             columns={[
               { key: 'title', header: t('app.dashboard.columnTitle'), cell: (row) => row.title },
+              {
+                key: 'price',
+                header: t('app.dashboard.columnPrice'),
+                numeric: true,
+                cell: (row) => (
+                  <InlineBar
+                    value={row.price.minor}
+                    max={ceilings.get(row.price.currency) ?? 0}
+                    text={formatMoney(row.price, locale)}
+                  />
+                ),
+              },
               {
                 key: 'createdAt',
                 header: t('app.dashboard.columnCreated'),
+                // Below \`md\` the date folds into the row's "more" disclosure: the title and the
+                // price are what a phone has room for, and nothing is lost.
+                priority: 2,
                 cell: (row) => (
                   <RelativeTime value={row.createdAt} now={props.data.now} locale={locale} />
                 ),
@@ -163,6 +229,7 @@ const exampleView =
   (): string => `// The dashboard's numbers, apart from its markup: pure functions over the rows the page loaded,
 // so the server render and a test cannot disagree about a figure. No I/O, no \`t()\`, no JSX.
 
+import type { Money } from '@ultimat3/money';
 import { type ChartPoint, deltaOf, type StatDelta } from '@ultimat3/ui';
 
 /** Days of history the chart shows, oldest first. */
@@ -174,26 +241,54 @@ const DAY_MS = 86_400_000;
 export interface PostRow {
   readonly id: string;
   readonly title: string;
+  /** Integer minor units plus an ISO code, never a float — the entity's \`money()\` column. */
+  readonly price: Money;
   readonly createdAt: string;
 }
 
 /**
- * Duck-typed rather than the entity's own row: the page only ever reads these three columns. The
- * repo reads through the typed handle, so \`createdAt\` arrives as the \`Date\` the entity declares.
+ * Duck-typed rather than the entity's own row: the page only ever reads these four columns. The
+ * query reads through the typed handle, so \`createdAt\` arrives as the \`Date\` the entity declares.
  */
 export function toPostRow(row: {
   readonly id: string;
   readonly title: string;
+  readonly price: Money;
   readonly createdAt: Date | string;
 }): PostRow {
   const at = row.createdAt;
   return {
     id: row.id,
     title: row.title,
+    price: row.price,
     createdAt: at instanceof Date ? at.toISOString() : at,
   };
 }
 
+/** Free (a zero price) against paid, over every row loaded — the two halves of the ring. */
+export interface PriceMix {
+  readonly free: number;
+  readonly paid: number;
+}
+
+export function priceMix(rows: readonly PostRow[]): PriceMix {
+  const paid = rows.filter((row) => row.price.minor > 0).length;
+  return { free: rows.length - paid, paid };
+}
+
+/**
+ * The dearest price per currency, in minor units — what each row's in-cell bar is a share of.
+ * Per currency because 1,900 cents and 1,900 yen are not the same height.
+ */
+export function priceCeilings(rows: readonly PostRow[]): ReadonlyMap<string, number> {
+  const ceilings = new Map<string, number>();
+  for (const row of rows) {
+    const { currency, minor } = row.price;
+    ceilings.set(currency, Math.max(ceilings.get(currency) ?? 0, minor));
+  }
+  return ceilings;
+}
+
 export interface PostStats {
   readonly total: number;
   /** Created in the seven days ending at \`now\`. */
@@ -255,161 +350,6 @@ export const formatCount = (value: number, locale: string): string =>
   new Intl.NumberFormat(locale).format(value);
 `;
 
-const exampleViewTest =
-  (): string => `// The numbers the dashboard shows, pinned against a fixed clock. The interesting cases are the
-// window edges: a post from eight days ago is in the prior week, not this one, and a day with no
-// posts is still a bar.
-import { expect, unitTest } from '@ultimat3/testing';
-import { bucketByDay, formatCount, type PostRow, postStats, toPostRow } from './dashboard-view';
-
-const NOW = new Date('2026-03-15T12:00:00.000Z');
-const DAY_MS = 86_400_000;
-
-const row = (id: string, daysAgo: number): PostRow => ({
-  id,
-  title: \`post \${id}\`,
-  createdAt: new Date(NOW.getTime() - daysAgo * DAY_MS).toISOString(),
-});
-
-const rows = [row('a', 1), row('b', 3), row('c', 8)];
-
-unitTest('postStats counts the week, compares it with the prior one, and counts today', () => {
-  const stats = postStats(rows, NOW);
-  expect(stats.total).toBe(3);
-  expect(stats.lastWeek).toBe(2);
-  // Two this week against one the week before: +100%, and the chip says so.
-  expect(stats.delta).toEqual({ text: '+100%', trend: 'up' });
-  // 'a' is yesterday and nothing was created on 03-15 itself.
-  expect(stats.today).toBe(0);
-  expect(postStats([...rows, row('d', 0.25)], NOW).today).toBe(1);
-});
-
-unitTest('a zero baseline yields no delta, and no rows count nothing', () => {
-  expect(postStats([row('a', 1)], NOW).delta).toBeUndefined();
-  expect(postStats([], NOW)).toEqual({ total: 0, lastWeek: 0, delta: undefined, today: 0 });
-});
-
-unitTest('bucketByDay is one bar per day, oldest first, quiet days included', () => {
-  const points = bucketByDay(rows, NOW, 14);
-  expect(points).toHaveLength(14);
-  expect(points.at(-1)?.key).toBe('03-15');
-  expect(points[0]?.key).toBe('03-02');
-  expect(points.reduce((sum, point) => sum + point.value, 0)).toBe(3);
-  // Eight days ago is 03-07: inside a 14-day window, so the bar is there.
-  expect(points.find((point) => point.key === '03-07')?.value).toBe(1);
-  expect(bucketByDay([], NOW, 3).map((point) => point.value)).toEqual([0, 0, 0]);
-});
-
-unitTest('toPostRow serialises a Date and passes ISO text through', () => {
-  const at = new Date('2026-01-02T03:04:05.000Z');
-  expect(toPostRow({ id: 'x', title: 't', createdAt: at }).createdAt).toBe(at.toISOString());
-  expect(toPostRow({ id: 'x', title: 't', createdAt: '2026-01-01' }).createdAt).toBe('2026-01-01');
-});
-
-unitTest('formatCount follows the locale', () => {
-  expect(formatCount(1234, 'en')).toBe('1,234');
-  expect(formatCount(1234, 'de')).toBe('1.234');
-});
-`;
-
-const examplePageTest = (
-  app: NameSet,
-): string => `// The dashboard, rendered as a request renders it: \`load\` reads the actor's org through the
-// slice's repo — the in-memory driver under test — and the page turns the rows into tiles, a chart
-// and a table. Losing the policy is the other regression worth a test: the page still renders, to
-// anyone.
-${sortedImports([
-  `import { driver } from '@${app.kebab}/db';`,
-  `import { useT } from '@${app.kebab}/i18n';`,
-  "import { createContext, frozenClock, runWithContext } from '@ultimat3/core';",
-  "import { testActor } from '@ultimat3/policy';",
-  "import { dbUnavailable } from '@ultimat3/db';",
-  "import { afterEach, expect, renderRoute, unitTest } from '@ultimat3/testing';",
-])}
-import { DEMO_ORG_ID } from '../../shared/demo-org';
-import * as repo from '../post/repo';
-import * as page from './page';
-
-const url = 'https://example.test/dashboard';
-const viewer = testActor('viewer', { orgId: DEMO_ORG_ID }).actor;
-const stranger = testActor('stranger', { orgId: '00000000-0000-4000-8000-000000000009' }).actor;
-
-const DAY_MS = 86_400_000;
-
-/**
- * One post in the viewer's org, written the way the app writes one — \`daysAgo\` days before now.
- * The request's clock is what stamps \`createdAt\`, so the test chooses the instant.
- */
-const post = (title: string, daysAgo: number) => {
-  const clock = frozenClock(new Date(Date.now() - daysAgo * DAY_MS));
-  const draft = { orgId: DEMO_ORG_ID, title, price: { minor: 0, currency: 'USD' } };
-  return runWithContext(createContext({ actor: viewer, clock }), () => repo.insert(draft));
-};
-
-/** The figure a tile shows, read off the markup by the \`stat\` the page gave it. */
-const stat = (html: string, name: string): string | undefined =>
-  html.match(new RegExp(\`data-stat="\${name}">([^<]*)<\`))?.[1];
-
-// One store per process: without this, one test's rows are the next test's fixtures.
-afterEach(() => {
-  driver.reset?.();
-});
-
-unitTest('the dashboard is gated, renders per request, and hydrates one island', async () => {
-  const view = await renderRoute(page, { url, actor: viewer });
-  expect(page.config.render).toBe('ssr');
-  expect(page.config.policy?.permission).toBe('dashboard:read');
-  expect(page.config.offline).toBe('runtime');
-  expect(page.config.budget.js).toBe('60kb');
-  // What the render emitted, beside what the config declares: the theme toggle, and only it.
-  expect(view.islands.map((island) => [island.moduleId, island.strategy])).toEqual([
-    ['shared-theme-toggle', 'visible'],
-  ]);
-});
-
-unitTest('it counts and lists the posts of the org that is looking', async () => {
-  await post('Last month', 30);
-  await post('This week', 3);
-  await post('Today', 0);
-  const view = await renderRoute(page, { url, actor: viewer });
-  // Newest first, as the repo orders them — and each tile counts its own window.
-  expect(view.data.rows.map((row) => row.title)).toEqual(['Today', 'This week', 'Last month']);
-  expect(stat(view.html, 'posts-total')).toBe('3');
-  expect(stat(view.html, 'posts-week')).toBe('2');
-  expect(stat(view.html, 'posts-today')).toBe('1');
-  // One table row per post, and one bar per day of the window whether or not it has posts.
-  expect(view.html.match(/<tr data-row=/g)).toHaveLength(3);
-  expect(view.html.match(/data-bar="true"/g)).toHaveLength(14);
-  expect(view.text).toContain('This week');
-  // The sidebar knows where it is.
-  expect(view.html).toMatch(/<a href="\\/dashboard" aria-current="page"/);
-});
-
-unitTest('another org sees none of them: the page says so instead of an empty table', async () => {
-  const t = useT();
-  await post('Not theirs', 0);
-  const view = await renderRoute(page, { url, actor: stranger });
-  expect(view.data.rows).toEqual([]);
-  expect(stat(view.html, 'posts-total')).toBe('0');
-  expect(view.html).not.toContain('<tr data-row=');
-  expect(view.text).toContain(t('app.dashboard.emptyTitle'));
-  expect(view.meta.title).toBe(t('app.dashboard.title'));
-  expect(view.meta.description).toBe(t('app.dashboard.description'));
-});
-
-unitTest('the build measures the empty page: no database is not a failure there', async () => {
-  const measured = await page.dashboardData(() => Promise.reject(dbUnavailable('no database')));
-  // The clock is frozen under test, so the instant the windows are cut at is this one.
-  expect(measured).toEqual({ rows: [], now: new Date().toISOString() });
-});
-
-unitTest('any other failure of the read propagates', async () => {
-  const cause = new TypeError('the read broke');
-  const read = (): Promise<never> => Promise.reject(cause);
-  expect(await page.dashboardData(read).catch((error: unknown) => error)).toBe(cause);
-});
-`;
-
 /** The example dashboard's page, view module and the tests beside both. */
 export const exampleDashboardFiles = (app: NameSet): readonly GeneratedFile[] => [
   { path: `${DASHBOARD_DIR}/page.tsx`, contents: examplePage(app) },