@ultimat3/cli 23.0.0 → 25.0.0

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) },

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

@@ -22,7 +22,7 @@ export const routeConfig = (load: string): string => `export const config = defi
   // toggle, provider, the ui runtime they share and the error registry are the rest. It was
   // 60.9kb before the framework stopped shipping solid-js twice and the i18n catalog with it
   // (issue #490), which is what put this at 64kb; 60kb is the figure the scaffold budgets held
-  // before that, kept rather than tightened so a Bun patch cannot red a first \`bin/check\`.
+  // before that, kept rather than tightened so a Bun patch cannot red a first \`bun run check\`.
   budget: { js: '60kb' },${load}
   meta: ({ t }) => ({
     title: t('app.dashboard.title'),
@@ -55,4 +55,65 @@ export const dashboardStyle = (): string => `@use '@ultimat3/ui/tokens' as token
   margin-inline: auto;
   color: tokens.role('fg');
 }
+
+// The trend beside the ring and the dial: side by side once the main column is wide enough for the
+// area chart to keep its 14 day labels legible, stacked before that.
+.charts {
+  display: grid;
+  gap: tokens.space(6);
+  min-inline-size: 0;
+
+  @include tokens.respond-to('lg') {
+    grid-template-columns: minmax(0, 2fr) minmax(0, 1fr);
+    align-items: start;
+  }
+}
+
+// The ring and the dial share a column: two across on a tablet, where one alone would leave half
+// the row empty, one above the other on a phone and in the narrow side column of a monitor.
+.side {
+  display: grid;
+  gap: tokens.space(4);
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 14rem), 1fr));
+}
+`;
+
+/**
+ * `apps/web/shared/theme.ts`: the app's brand, which the boot reads by this path and inlines in every
+ * document (`theme-brand.ts`). Emitted as the default theme — `defineTheme({})` renders no CSS, so
+ * no tag and no CSP entry — with the preset one edit away: the look is the app's choice (axiom 8).
+ */
+export const themeFile =
+  (): string => `// This app's brand: the boot reads \`brand\` from this file and inlines it in every document,
+// after global.scss, with its hash in the CSP. \`defineTheme({})\` is @ultimat3/ui's default theme
+// and renders nothing, so today no tag is emitted.
+//
+// \`defineTheme()\` is the one seam for restyling — colours, radii, fonts and shadows by role,
+// validated at the call. The dashboard look (near-black panels, a cyan accent, glowing edges, its
+// own eight chart series) is one edit:
+//
+//   export const brand = defineTheme({ preset: 'scifi' });
+//
+// Every other slot layers onto the preset role by role:
+//   defineTheme({ preset: 'scifi', colors: { dark: { 'chart-1': '120 220 255' } } })
+// A preset never forces a theme: to open dark whatever the OS says, set \`theme.defaultMode\` in
+// app.config.ts.
+import { defineTheme } from '@ultimat3/ui';
+
+export const brand = defineTheme({});
+`;
+
+/** Its test: what the brand renders is a fact the app pins, so opting in is a visible diff. */
+export const themeTest =
+  (): string => `// The brand the boot inlines. The default theme renders no CSS — no \`<style>\`, no CSP entry —
+// and the preset is a whole palette; either way \`defineTheme()\` validated it at import.
+import { expect, unitTest } from '@ultimat3/testing';
+import { defineTheme } from '@ultimat3/ui';
+import { brand } from './theme';
+
+unitTest('the app ships the default theme until it opts into a preset', () => {
+  expect(brand.css).toBe('');
+  // The opt-in is one edit, and what it would ship is real CSS the boot inlines.
+  expect(defineTheme({ preset: 'scifi' }).css).toContain('--color-');
+});
 `;

package/src/templates/scaffold-dashboard.ts

@@ -2,25 +2,29 @@
 // stopped being an `<h1>` in a panel. Two shapes, one per `x new` invocation, and both show only
 // what is true of the app that was just written:
 //
-//   --example     the seeded `post` slice: a stat row, a bar chart of posts per day, the latest
-//                 posts in a table. Real rows from the app's own repo, aggregated by a pure view
-//                 module this file also emits.
+//   --example     the seeded `post` slice: a stat row, an area chart of posts per day, a ring of
+//                 free against paid, a dial of this week's share, the latest posts in a table.
+//                 Real rows from the app's own repo, aggregated by a pure view module this file
+//                 also emits.
 //   --no-example  no entity, so no rows to count and nothing honest to chart. Framework facts
 //                 instead — routes, locales, roles, version — and the route table. A chart of
 //                 invented numbers would teach the wrong thing to every app that starts here.
 //
-// One island on the page, the theme toggle (`scaffold-shell.ts`); the tiles, chart and table are
+// One island on the page, the theme toggle (`scaffold-shell.ts`); the tiles, charts and table are
 // server markup, which is what keeps the route inside its 60kb budget.
 
 import type { GeneratedFile, NameSet } from './naming';
 import { bareDashboardFiles } from './scaffold-dashboard-bare';
 import { exampleDashboardFiles } from './scaffold-dashboard-example';
-import { DASHBOARD_DIR, dashboardStyle } from './scaffold-dashboard-shared';
+import { DASHBOARD_DIR, dashboardStyle, themeFile, themeTest } from './scaffold-dashboard-shared';
 
 /** `apps/web/app/dashboard/`, in the shape the invocation earns. */
 export function dashboardFiles(app: NameSet, example: boolean): readonly GeneratedFile[] {
   return [
     ...(example ? exampleDashboardFiles(app) : bareDashboardFiles(app)),
     { path: `${DASHBOARD_DIR}/page.module.scss`, contents: dashboardStyle() },
+    // Both shapes: the look is the app's to choose whether or not it has an entity yet.
+    { path: 'apps/web/shared/theme.ts', contents: themeFile() },
+    { path: 'apps/web/shared/theme.test.ts', contents: themeTest() },
   ];
 }

package/src/templates/scaffold-db-client.ts

@@ -74,7 +74,7 @@ export const dbClientSource = (
 // same two lines: its import, and \`<tableName>: <entity>,\` in the set.
 
 ${sortedImports([
-  "import { resolveEnvironment } from '@ultimat3/core';",
+  "import { storeMode } from '@ultimat3/core';",
   "import { type Driver, database, memoryDriver, postgresDriver } from '@ultimat3/entity';",
   ...entries.map(handleImportLine),
 ])}
@@ -86,9 +86,11 @@ ${sortedImports([
  * \`postgresDriver()\` takes no connection: it resolves \`@ultimat3/db\`'s process client, which is
  * the embedded PGlite under \`x dev\` and the \`DATABASE_URL\` pool in a container. \`bun test\`
  * installs no client, so a test gets the in-memory driver — the same contract, no database.
+ * \`storeMode\` is core's one answer to that question, shared with every other seam that has a
+ * memory and a database store.
  */
 export const selectDriver = (env: Readonly<Record<string, string | undefined>>): Driver =>
-  resolveEnvironment({ env }) === 'test' ? memoryDriver() : postgresDriver();
+  storeMode(env) === 'memory' ? memoryDriver() : postgresDriver();
 
 export const driver = selectDriver(Bun.env);
 

package/src/templates/scaffold-db-package.ts

@@ -165,7 +165,7 @@ const dbSeedTest = (app: NameSet, example: boolean): string =>
 // development viewer's tenant policy refuses, and the dashboard then counts zero.
 ${sortedImports([
   `import { DEMO_ORG_ID } from '@${app.kebab}/web/shared/demo-org';`,
-  "import { createContext, runWithContext } from '@ultimat3/core';",
+  "import { ctxOf, runWithContext } from '@ultimat3/core';",
   "import { testActor } from '@ultimat3/policy';",
   "import { afterEach, expect, unitTest } from '@ultimat3/testing';",
 ])}
@@ -174,7 +174,7 @@ import { ${app.camel}Seed } from './seed';
 
 /** The development viewer's org: every read below runs as an actor inside it. */
 const asViewer = <T>(run: () => Promise<T>): Promise<T> =>
-  runWithContext(createContext({ actor: testActor('viewer', { orgId: DEMO_ORG_ID }).actor }), run);
+  runWithContext(ctxOf({ actor: testActor('viewer', { orgId: DEMO_ORG_ID }).actor }), run);
 
 // One store per process: without this, one test's rows are the next test's fixtures.
 afterEach(() => {