@ultimat3/cli 22.14.0 → 23.0.0

package/src/templates/resource-form-island.ts

@@ -170,9 +170,9 @@ export function mount(el: HTMLElement, props: ${feature.pascal}FormProps): void
 const formIslandTest = (
   feature: NameSet,
   dir: string,
-): string => `// The form the browser actually runs. \`mountIsland\` builds this entry with the same
-// \`buildIslands\` that \`x build\` and \`x dev\` use, imports the emitted chunk the way the hydration
-// runtime does, and drives \`mount\` against a DOM small enough to read.
+): string => `// The form the browser actually runs, in every state its manifest declares: built once for this
+// file with the same \`buildIslands\` that \`x build\` and \`x dev\` use, imported the way the
+// hydration runtime imports it, and driven against a DOM small enough to read.
 //
 // It is the test that keeps this file a CLIENT entry. A generated form that only typechecks is
 // what shipped before: server-rendered, every \`on*\` prop dropped, every signal read once.
@@ -180,76 +180,46 @@ const formIslandTest = (
 import { join } from 'node:path';
 import { buildIslands } from '@ultimat3/cli';
 import {
-  afterAll,
-  beforeAll,
-  describe,
+  describeIslandState,
   expect,
   type FakeElement,
   type MountedIsland,
-  mountIsland,
   test,
 } from '@ultimat3/testing';
-
-const APP_ROOT = join(import.meta.dir, ${upToAppRoot(dir)});
-const ISLAND = '${dir}/${feature.kebab}-form.island.tsx';
-const ENDPOINT = '/api/${feature.kebab}/create-${feature.kebab}';
-
-const LABELS = {
-  title: 'Title',
-  price: 'Price',
-  submit: 'Save',
-  saved: 'Saved',
-  retry: 'Try again',
-};
+import { ${feature.camel}FormStates } from './${feature.kebab}-form.island.states';
 
 const calls: { url: string; body: Record<string, unknown> }[] = [];
 
-/** One stub, both outcomes: the mount costs seconds, so the network's answer is a switch. */
+/** One stub, both outcomes: a block shares its mount, so the network's answer is a switch. */
 let networkFails = false;
 
-let mounted: MountedIsland;
-
-// The build is a Babel pass plus a browser bundle — seconds, not milliseconds. It lives in
-// \`beforeAll\` with its own timeout because \`test\` takes no third argument: fixtures are resolved
-// per case, so the slow work goes where it can be given one and every case shares the result.
-beforeAll(async () => {
-  mounted = await mountIsland({
-    build: buildIslands,
-    root: APP_ROOT,
-    file: ISLAND,
-    props: { endpoint: ENDPOINT, locale: 'en', currency: 'USD', labels: LABELS },
-    // What the server rendered inside the island's wrapper. \`mount\` replaces it.
-    shell: '<p>Loading</p>',
-    globals: {
-      // The form sends through \`clientTransport\`, which calls \`globalThis.fetch\` — this stub.
-      fetch: (url: string, init: { body: string }): Promise<Response> => {
-        calls.push({ url, body: JSON.parse(init.body) as Record<string, unknown> });
-        // What a browser rejects with when there is no network. Not a response, which is exactly
-        // why the form has to catch it.
-        return networkFails
-          ? Promise.reject(new TypeError('Failed to fetch'))
-          : Promise.resolve(Response.json({ id: 'created' }));
-      },
+// One block per declared state: \`describeIslandState\` mounts it before the block's first test
+// and disposes it after the last. The props are the manifest's own — what
+// \`x shot --island ${feature.kebab}-form\` photographs — so the picture and the test are of one
+// component.
+const island = {
+  build: buildIslands,
+  root: join(import.meta.dir, ${upToAppRoot(dir)}),
+  // What the server rendered inside the island's wrapper. \`mount\` replaces it.
+  shell: '<p>Loading</p>',
+  globals: {
+    // The form sends through \`clientTransport\`, which calls \`globalThis.fetch\` — this stub.
+    fetch: (url: string, init: { body: string }): Promise<Response> => {
+      calls.push({ url, body: JSON.parse(init.body) as Record<string, unknown> });
+      // What a browser rejects with when there is no network. Not a response, which is exactly
+      // why the form has to catch it.
+      return networkFails
+        ? Promise.reject(new TypeError('Failed to fetch'))
+        : Promise.resolve(Response.json({ id: 'created' }));
     },
-  });
-}, 60_000);
-
-// The fake \`document\` is process-global: left installed it reaches every LATER FILE in the run.
-//
-// \`?.\` on a binding the type says is always set: TypeScript's definite-assignment analysis does not
-// cross the \`beforeAll\` closure, so a setup that REJECTED leaves this undefined at run time — and
-// bun runs \`afterAll\` regardless. Unguarded, the build failure is followed by a \`TypeError:
-// undefined is not an object\` that says nothing, and that second line is the one a tail reads.
-// Nothing is skipped by the guard: \`mountIsland\` restores the process itself when a mount throws.
-afterAll(() => {
-  mounted?.[Symbol.dispose]();
-});
+  },
+};
 
 /**
  * Until the status line changes, a bounded number of macrotasks: the send is several awaits deep
  * inside \`clientTransport\`, so counting microtasks would pin the transport, not the form.
  */
-async function statusSettled(): Promise<void> {
+async function statusSettled(mounted: MountedIsland): Promise<void> {
   const before = mounted.text('[data-role="status"]');
   for (let tick = 0; tick < 50; tick += 1) {
     if (mounted.text('[data-role="status"]') !== before) return;
@@ -257,53 +227,61 @@ async function statusSettled(): Promise<void> {
   }
 }
 
-/**
- * One mount, driven as a session: the cases below run in order against the same island, because
- * building the real chunk costs seconds and repeating it per case would pay them for state each
- * case sets up anyway. What each one asserts is independent.
- */
-describe('the ${feature.kebab} form island', () => {
+// Each case sets the network's answer itself and asserts on what its own submit produced, so
+// none depends on the one before it.
+describeIslandState(${feature.camel}FormStates, 'idle', island, (mounted) => {
   test('mount replaces the server shell with the editor', () => {
-    expect(mounted.find('p')?.getAttribute('data-role')).toBe('status');
+    expect(mounted().find('p')?.getAttribute('data-role')).toBe('status');
+    expect(mounted().text('button')).toBe('Save');
     // Solid compiles to real DOM calls; a chunk that fell back to the classic React factory names
     // a global that is not in it, and \`Bun.build\` answers \`success: true\` over that all the same.
-    expect(mounted.code).not.toMatch(/\\bReact\\b/);
+    expect(mounted().code).not.toMatch(/\\bReact\\b/);
   });
 
-  test('the fields track, and submit posts the create input', async () => {
-    const title: FakeElement | null = mounted.find('input[aria-label="Title"]');
-    const price: FakeElement | null = mounted.find('input[aria-label="Price"]');
+  test('the fields track, submit posts the create input, and the status answers', async () => {
+    networkFails = false;
+    const title: FakeElement | null = mounted().find('input[aria-label="Title"]');
+    const price: FakeElement | null = mounted().find('input[aria-label="Price"]');
     expect(title).not.toBeNull();
     expect(price).not.toBeNull();
     if (title !== null) title.value = 'First ${feature.camel}';
     if (price !== null) price.value = '12.50';
     // \`false\` means no handler ran — an island whose onInput never reached the DOM looks
     // identical to a selector typo otherwise.
-    expect(mounted.fire(title, 'input')).toBe(true);
-    expect(mounted.fire(price, 'input')).toBe(true);
-    expect(mounted.fire('form', 'submit', { preventDefault: () => {} })).toBe(true);
-    await statusSettled();
+    expect(mounted().fire(title, 'input')).toBe(true);
+    expect(mounted().fire(price, 'input')).toBe(true);
+    expect(mounted().fire('form', 'submit', { preventDefault: () => {} })).toBe(true);
+    await statusSettled(mounted());
 
     const body = {
       title: 'First ${feature.camel}',
       price: { minor: 1250, currency: 'USD' },
     };
-    expect(calls).toEqual([{ url: ENDPOINT, body }]);
-  });
-
-  test('the status line answers the response', () => {
+    // The endpoint is the state's own: the form posts where the server told it to.
+    expect(calls.at(-1)).toEqual({ url: '/api/${feature.pluralKebab}/create', body });
     // The signal reached the DOM: an eager JSX factory renders '' here and never runs again.
-    expect(mounted.text('[data-role="status"]')).toBe(LABELS.saved);
+    expect(mounted().text('[data-role="status"]')).toBe('Saved');
   });
 
   test('a request that never got a response still reaches retry', async () => {
     // The outcome \`retry\` is FOR. A \`fetch\` that rejects produces no answer, so without the
     // catch in \`send\` the status line stays on its last value and the rejection escapes.
     networkFails = true;
-    expect(mounted.fire('form', 'submit', { preventDefault: () => {} })).toBe(true);
-    await statusSettled();
+    expect(mounted().fire('form', 'submit', { preventDefault: () => {} })).toBe(true);
+    await statusSettled(mounted());
+
+    expect(mounted().text('[data-role="status"]')).toBe('That did not save. Try again.');
+  });
+});
 
-    expect(mounted.text('[data-role="status"]')).toBe(LABELS.retry);
+describeIslandState(${feature.camel}FormStates, 'long-labels', island, (mounted) => {
+  test('every label is the state’s own, in the locale it names', () => {
+    // Whether they FIT is a picture's question — \`x shot --island ${feature.kebab}-form\`. What a
+    // test can say is that the island was handed this state's text, and none of the idle one's.
+    expect(mounted().find('input[aria-label="Bezeichnung des Beitrags"]')).not.toBeNull();
+    expect(mounted().find('input[aria-label="Title"]')).toBeNull();
+    expect(mounted().text('button')).toBe('Änderungen speichern');
+    expect(mounted().documentElement.getAttribute('lang')).toBe('de');
   });
 });
 `;

package/src/templates/resource-page.ts

@@ -0,0 +1,269 @@
+// `x g resource <name>`'s page: the plural route a slice is reached at. It READS — `load` calls the
+// slice's own query as the request's actor — renders the rows through the slice's list component
+// inside `AsyncRegion` (ready, empty, failed), and mounts the slice's form island. `x g route`
+// writes a page with a heading and nothing to read; a resource has rows and a form, and a page
+// that showed neither was a slice nobody could reach without wiring it by hand.
+
+import { sortedImports } from './imports';
+import type { GeneratedFile, NameSet } from './naming';
+import { titleKey } from './naming';
+import { formIslandSpecifier } from './resource-form-island';
+import { LINE_WIDTH } from './wrap';
+
+/**
+ * The page's JS budget — MEASURED, never a ceiling picked to pass. `x build --target static` on a
+ * fresh `x new` app with `x g resource widget`, Bun 1.4.0 (CI's pin), 2026-10-01: 58,522 B — the
+ * form island 57,667 + the `visible` hydration runtime 855. 64kb is 65,536: the headroom is Bun's
+ * own movement on one source — a patch release that keeps core's declared modules measured +3.0 kB
+ * on the scaffold's theme island, and the tree-shaker flaps by up to 1.1 kB between runs. An app
+ * that adds per-document scripts (`navigation: { client: [...] }` charges its router, ~18 kB, to
+ * every `app/` page) is over it on its first build, and `nextSteps` sends the author there.
+ */
+export const RESOURCE_PAGE_BUDGET = '64kb';
+export const RESOURCE_PAGE_MEASURED = '58,522 B';
+
+/** How the page reaches a string — the same rule `route.ts` states, for the same issue (#249). */
+const catalogImport = (module: string | undefined): string =>
+  module === undefined
+    ? "import { t } from '@ultimat3/i18n';"
+    : `import { useT } from '${module}';`;
+
+/** `currentLocale` rides on the framework import when the app has no catalog module. */
+const i18nImports = (module: string | undefined): readonly string[] =>
+  module === undefined
+    ? ["import { currentLocale, t } from '@ultimat3/i18n';"]
+    : [catalogImport(module), "import { currentLocale } from '@ultimat3/i18n';"];
+
+/** `const load = … => rowsState(() => <read>(input()));`, as Biome prints it at any name length. */
+const loadLine = (read: string): string => {
+  const head = 'const load = (): Promise<PageData> =>';
+  const body = `rowsState(() => ${read}(input()));`;
+  return `${head} ${body}`.length <= LINE_WIDTH ? `${head} ${body}` : `${head}\n  ${body}`;
+};
+
+export interface ResourcePageOptions {
+  readonly feature: NameSet;
+  /** The slice: `apps/web/app/<feature>`. */
+  readonly dir: string;
+  /** Where the page lands: `apps/web/app/<features>`. */
+  readonly pageDir: string;
+  readonly catalogModule?: string;
+  /** The app has `apps/web/shared/shell.tsx` — every `x new` app does — so the page sits in it. */
+  readonly shell: boolean;
+  readonly dbModule: string;
+}
+
+const pageSource = (options: ResourcePageOptions): string => {
+  const { feature } = options;
+  const path = feature.pluralKebab;
+  const list = `${feature.camel}List`;
+  const open = options.shell
+    ? '<Shell>\n      <div class={styles.page}>'
+    : '<main class={styles.page}>';
+  const close = options.shell ? '      </div>\n    </Shell>' : '    </main>';
+  const indent = options.shell ? '        ' : '      ';
+  const inner = (lines: string): string =>
+    lines
+      .split('\n')
+      .map((line) => (line === '' ? line : `${indent}${line}`))
+      .join('\n');
+  return `// /${path}: the org's ${feature.pluralKebab}, newest first, and the form that adds one. \`load\`
+// reads through the slice's own query, so the policy, the tenancy and the order are the query's;
+// the form is the slice's island, the one module of this page a browser downloads.
+
+${sortedImports([
+  ...i18nImports(options.catalogModule),
+  "import { derivePath } from '@ultimat3/action';",
+  "import type { AsyncState } from '@ultimat3/core';",
+  "import type { KnownPermission } from '@ultimat3/policy';",
+  "import { defineRoute, island } from '@ultimat3/render';",
+  "import { AsyncRegion, EmptyState, PageHeader, Section, Skeleton } from '@ultimat3/ui';",
+])}
+${options.shell ? "import { Shell } from '../../shared/shell';\n" : ''}import type { ${feature.pascal} } from '../${feature.kebab}/entity';
+import { ${list} } from '../${feature.kebab}/live/${feature.kebab}-list';
+import { ${feature.pascal}List } from '../${feature.kebab}/ui';
+import styles from './page.module.scss';
+
+/** One page of rows: the read's own bound. Past it, page with a cursor (\`${list}.page\`). */
+const PAGE_ROWS = 50;
+
+/** The currency a price is typed in; the form sends integer minor units of it. */
+const CURRENCY = 'USD';
+
+type Row = ${feature.pascal};
+
+/** What \`load\` answers: the read's outcome as DATA, so the page renders each of its states. */
+export type PageData = AsyncState<readonly Row[]>;
+
+/**
+ * The read, as a state. A refusal or a failed read is the region's error branch — code, cause and
+ * fix on screen, the form still there — never a 500 for the whole document.
+ */
+export async function rowsState(read: () => Promise<readonly Row[]>): Promise<PageData> {
+  try {
+    return { status: 'ready', data: await read() };
+  } catch (error) {
+    return { status: 'failed', error };
+  }
+}
+
+/** No org: the query reads the ACTOR's, so a read can only ever be for the caller's own org. */
+const input = () => ({ limit: PAGE_ROWS });
+
+${loadLine(list)}
+
+// Declared ABOVE \`defineRoute\`: the route drains the islands declared before it. Named by
+// SPECIFIER, never imported — a string has no import edge, so the page's bundle graph stays the
+// page's (axiom 6). \`props\` are exactly the form's \`${feature.pascal}FormProps\` keys.
+const ${feature.pascal}Form = island({
+  src: '${formIslandSpecifier(feature, options.dir, options.pageDir)}',
+  props: ['endpoint', 'locale', 'currency', 'labels'],
+});
+
+export const config = defineRoute({
+  render: 'ssr',
+  hydrate: 'visible',
+  offline: 'runtime',
+  // An org's rows are not public: a route with no policy registers \`auth: 'public'\` and its
+  // response carries no \`vary: cookie\`. Which ORG is the query's decision, on every read.
+  policy: { permission: '${feature.kebab}:read' satisfies KnownPermission },
+  // measured: ${RESOURCE_PAGE_MEASURED} (\`x build --target static\`, Bun 1.4.0) — the form island and the
+  // \`visible\` runtime. why: the form is Solid, @ultimat3/ui's Form/Input/Button and the transport.
+  // A raise states its own measured bytes and why here, in the same diff (\`X_BUDGET_EXCEEDED\`).
+  budget: { js: '${RESOURCE_PAGE_BUDGET}' },
+  load,
+  meta: ({ t }) => ({
+    title: t('${titleKey(path)}'),
+    description: t('${titleKey(path).replace('.title', '.description')}'),
+  }),
+});
+
+export interface PageProps {
+  readonly data: PageData;
+}
+
+export function Page(props: PageProps) {${options.catalogModule === undefined ? '' : '\n  const t = useT();\n'}
+  return (
+    ${open}
+${inner(`<PageHeader title={t('${titleKey(path)}')} />
+<Section title={t('app.${feature.kebab}.new')}>
+  <${feature.pascal}Form
+    endpoint={derivePath('create${feature.pascal}').path}
+    locale={currentLocale()}
+    currency={CURRENCY}
+    labels={{
+      title: t('app.${feature.kebab}.titleLabel'),
+      price: t('app.${feature.kebab}.priceLabel'),
+      submit: t('app.${feature.kebab}.submit'),
+      saved: t('app.${feature.kebab}.saved'),
+      retry: t('app.${feature.kebab}.retry'),
+    }}
+  >
+    <Skeleton lines={3} />
+  </${feature.pascal}Form>
+</Section>
+<AsyncRegion
+  state={props.data}
+  reserve={{ lines: 3 }}
+  empty={() => <EmptyState title={t('app.${feature.kebab}.empty')} />}
+  ready={(rows) => <${feature.pascal}List rows={rows} />}
+/>`)}
+${close}
+  );
+}
+`;
+};
+
+const ORG = '00000000-0000-4000-8000-000000000002';
+const OTHER_ORG = '00000000-0000-4000-8000-000000000009';
+
+const pageTest = (options: ResourcePageOptions): string => {
+  const { feature } = options;
+  const t = options.catalogModule === undefined ? '' : '\n  const t = useT();';
+  return `// /${feature.pluralKebab}, 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 shows the rows, the empty state
+// or the refusal, with the form island beside them in every one.
+${sortedImports([
+  catalogImport(options.catalogModule),
+  `import { driver } from '${options.dbModule}';`,
+  "import { createContext, frozenClock, runWithContext } from '@ultimat3/core';",
+  "import { testActor } from '@ultimat3/policy';",
+  "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 * as repo from '../${feature.kebab}/repo';
+import * as page from './page';
+
+const url = 'https://example.test/${feature.pluralKebab}';
+const orgId = '${ORG}';
+const otherOrg = '${OTHER_ORG}';
+// The read grant, named once so every line below fits the formatter's width at any feature name.
+const read = '${feature.kebab}:read';
+// Holds the read grant in the org: what a member of it is.
+const member = testActor('member', { orgId, permissions: [read] }).actor;
+
+// The request clock, so \`createdAt\` is an instant this file chose and "newest" is decidable.
+const clock = frozenClock('2026-01-01T00:00:00.000Z');
+
+const store = (title: string) => {
+  const draft = { orgId, title, price: { minor: 1200, currency: 'USD' } };
+  return runWithContext(createContext({ actor: member, clock }), () => repo.insert(draft));
+};
+
+// One store per process: without this, one test's rows are the next test's fixtures.
+afterEach(() => {
+  driver.reset?.();
+});
+
+unitTest('the page lists the org’s rows, newest first, beside the form', async () => {
+  await store('older');
+  clock.advance(1000);
+  await store('newer');
+  const view = await renderRoute(page, { url, actor: member });
+  expect(view.data.status).toBe('ready');
+  expect(view.text.indexOf('newer')).toBeLessThan(view.text.indexOf('older'));
+  // The form is the one island, and it wakes when it is visible.
+  expect(view.islands.map((island) => island.strategy)).toEqual(['visible']);
+  expect(view.islands[0]?.moduleId).toContain('${feature.kebab}-form');
+});
+
+unitTest('an org with no rows reads the empty state, not an empty list', async () => {${t}
+  const view = await renderRoute(page, { url, actor: member });
+  expect(view.data).toEqual({ status: 'ready', data: [] });
+  expect(view.text).toContain(t('app.${feature.kebab}.empty'));
+  expect(view.meta.title).toBe(t('${titleKey(feature.pluralKebab)}'));
+});
+
+unitTest('a member of another org reads none of this org’s rows', async () => {
+  await store('ours');
+  // The same page, the same URL: which org it reads is the actor's, never a parameter.
+  const outsider = testActor('outsider', { orgId: otherOrg, permissions: [read] }).actor;
+  const view = await renderRoute(page, { url, actor: outsider });
+  expect(view.data).toEqual({ status: 'ready', data: [] });
+});
+
+unitTest('a caller the read refuses sees the refusal, and the page around it', async () => {
+  // In the org, without the grant: the query's policy refuses before any row is read.
+  const stranger = testActor('stranger', { orgId }).actor;
+  const view = await renderRoute(page, { url, actor: stranger });
+  expect(view.data.status).toBe('failed');
+  expect(view.html).toContain('X_FORBIDDEN');
+  expect(view.islands).toHaveLength(1);
+});
+
+unitTest('it is gated, rendered per request, and budgeted', () => {
+  expect(page.config.render).toBe('ssr');
+  expect(page.config.policy?.permission).toBe(read);
+  expect(page.config.offline).toBe('runtime');
+  expect(page.config.budget.js).toBe('${RESOURCE_PAGE_BUDGET}');
+});
+`;
+};
+
+/** The resource's `page.tsx` and its unit test. The stylesheet, e2e test and catalog are `x g route`'s. */
+export const resourcePageFiles = (options: ResourcePageOptions): readonly GeneratedFile[] => [
+  { path: `${options.pageDir}/page.tsx`, contents: pageSource(options) },
+  { path: `${options.pageDir}/page.test.ts`, contents: pageTest(options) },
+];

package/src/templates/resource-service.ts

@@ -0,0 +1,96 @@
+// `x g resource`'s service module and its test: business logic over the slice's repo, covered
+// against the in-memory driver. Split from `resource.ts`, which composes the slice — this file
+// owns the one module in it that holds a rule.
+
+import { sortedImports } from './imports';
+import type { GeneratedFile, NameSet } from './naming';
+
+const serviceSource = (
+  feature: NameSet,
+): string => `// Business logic for ${feature.pluralKebab}. Knows nothing about HTTP or requests, so a job and an
+// action can both call it. Takes values, not a request.
+
+import type { ${feature.pascal} } from './entity';
+import { ${feature.pascal}NotFoundError } from './errors';
+import * as repo from './repo';
+
+/** Derived from the row, never restated: a new column reaches this input without an edit here. */
+export type Create${feature.pascal}Input = Omit<${feature.pascal}, 'id' | 'createdAt'>;
+
+/** The row, aliased once, so every signature below reads at one width whatever the feature is
+ * called — a generated file the app's own formatter rewrites is a red \`lint\` over code nobody
+ * typed. */
+type Row = ${feature.pascal};
+
+export async function create(input: Create${feature.pascal}Input): Promise<Row> {
+  return repo.insert(input);
+}
+
+export async function require${feature.pascal}(id: string): Promise<Row> {
+  const row = await repo.byId(id);
+  if (row === undefined) throw new ${feature.pascal}NotFoundError({ id });
+  return row;
+}
+`;
+
+/** The feature's own code, spelled once: the class throws it and the test matches on it. */
+const notFoundCode = (feature: NameSet): string =>
+  `X_${feature.kebab.toUpperCase().split('-').join('_')}_NOT_FOUND`;
+
+const serviceTest = (
+  feature: NameSet,
+  dbModule: string,
+): string => `// The ${feature.kebab} service against the in-memory driver, and its failure, pinned: a code an
+// agent can match on, a cause naming the row, and a fix that is an instruction.
+${sortedImports([
+  "import { createContext, runWithContext } from '@ultimat3/core';",
+  "import { testActor } from '@ultimat3/policy';",
+  "import { afterEach, expect, unitTest } from '@ultimat3/testing';",
+  `import { driver } from '${dbModule}';`,
+])}
+import { ${feature.pascal}NotFoundError } from './errors';
+import { create, require${feature.pascal} } from './service';
+
+const orgId = '00000000-0000-4000-8000-000000000002';
+const absent = '00000000-0000-4000-8000-0000000000ff';
+const draft = { orgId, title: 'First', price: { minor: 1200, currency: 'USD' } };
+
+/** What a request is to the repo underneath: an actor, whose org every statement runs under. */
+const inOrg = <T>(run: () => Promise<T>): Promise<T> =>
+  runWithContext(createContext({ actor: testActor('member', { orgId }).actor }), run);
+
+// One store per process: without this, one test's rows are the next test's fixtures.
+afterEach(() => {
+  driver.reset?.();
+});
+
+unitTest('${feature.pascal}NotFoundError carries a code, a cause and a fix', () => {
+  const error = new ${feature.pascal}NotFoundError({ id: 'missing' });
+  expect(error).toBeUltimateError('${notFoundCode(feature)}');
+  expect(error.cause).toContain('missing');
+  expect(error.fix.length).toBeGreaterThan(0);
+});
+
+unitTest('create stores the row and the lookup answers it', async () => {
+  const created = await inOrg(() => create(draft));
+  expect(created.title).toBe('First');
+  // \`toEqualRow\`, never \`toEqual\`: a \`.sealed()\` column is a non-enumerable property of a row.
+  expect(await inOrg(() => require${feature.pascal}(created.id))).toEqualRow(created);
+});
+
+unitTest('the lookup refuses an id nothing holds', async () => {
+  const lookup = inOrg(() => require${feature.pascal}(absent));
+  const refused = await lookup.catch((error: unknown) => error);
+  expect(refused).toBeUltimateError('${notFoundCode(feature)}');
+});
+`;
+
+/** `service.ts` and the test that covers it. `dbModule` is where the test resets the driver. */
+export const serviceFiles = (
+  feature: NameSet,
+  dir: string,
+  dbModule: string,
+): readonly GeneratedFile[] => [
+  { path: `${dir}/service.ts`, contents: serviceSource(feature) },
+  { path: `${dir}/service.test.ts`, contents: serviceTest(feature, dbModule) },
+];