refactor: fold machine-remote-data into remote-data.ts, PascalCase load lifecycle (RD-11)

`machine-remote-data.ts` defined a third encoding of an in-flight fetch:
`LoadLifecycle`. It had three call sites, all one identical line, and the type
was never imported by name. Move the mapping into `remote-data.ts` as
`fromLoadLifecycle`, beside its neighbour `fromResource` — a `RemoteData`
constructor, not a sixth encoding.

The lowercase `loading`/`failed`/`loaded` tags on `BriefState`,
`OrgTemplateState` and `StamdataEditorState` existed only because
`LoadLifecycle` required them. Now that the constraint is inline and
PascalCase, the three machines' load-lifecycle tags become `Loading`,
`Failed` and `Loaded` — matching their own PascalCase message tags in the
same file. `stamdata-editor.machine.spec.ts` no longer asserts a PascalCase
message producing a lowercase state.

`BriefStatus` (the letter's draft/submitted/approved/rejected/sent status,
parsed off the wire from `BriefViewDto`) is a separate tag family and is
untouched — its tag count stays 54 before and after this change.

Delete `machine-remote-data.ts` and merge its spec into `remote-data.spec.ts`.
Regenerate `behaviour-spec.mdx` (the `machineRemoteData` section heading
becomes `fromLoadLifecycle`) and confirm `gen:snippets` reports no drift, since
`remote-data.ts` carries a showcase region.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

libs/beheer/src/application/stamdata.store.ts

@@ -1,6 +1,6 @@
 import { Injectable, computed, inject, signal } from '@angular/core';
 import { createStore } from '@shared/application/store';
-import { machineRemoteData } from '@shared/application/machine-remote-data';
+import { fromLoadLifecycle } from '@shared/application/remote-data';
 import { createHistory } from '@shared/application/history';
 import {
   ChangeCounts,
@@ -20,7 +20,7 @@ import {
 import { StamdataAdapter } from '@beheer/infrastructure/stamdata.adapter';
 import { BLOB_PRESENTER } from '@shared/application/blob-presenter';
 
-type LoadedState = Extract<StamdataEditorState, { tag: 'loaded' }>;
+type LoadedState = Extract<StamdataEditorState, { tag: 'Loaded' }>;
 
 /**
  * Root singleton for the stamdata maintenance editor (ADR-0004). The Elm machine owns the
@@ -42,11 +42,11 @@ export class StamdataStore {
       so toggling it never round-trips or drops unsaved edits (see domain `activeOn`). */
   readonly previewDate = signal<string>('');
 
-  readonly remoteData = computed(() => machineRemoteData(this.model()));
+  readonly remoteData = computed(() => fromLoadLifecycle(this.model()));
 
   private loaded = computed<LoadedState | null>(() => {
     const s = this.model();
-    return s.tag === 'loaded' ? s : null;
+    return s.tag === 'Loaded' ? s : null;
   });
   readonly table = computed<StamTable | null>(() => this.loaded()?.table ?? null);
   readonly rows = computed<readonly StamRow[]>(() => this.loaded()?.rows ?? []);

libs/beheer/src/domain/stamdata-editor.machine.spec.ts

@@ -24,40 +24,40 @@ const seedLoaded = (): StamdataEditorState =>
 describe('stamdata-editor reduce', () => {
   it('Loaded snapshots original independently of rows', () => {
     const s = seedLoaded();
-    expect(s.tag).toBe('loaded');
-    if (s.tag !== 'loaded') return;
+    expect(s.tag).toBe('Loaded');
+    if (s.tag !== 'Loaded') return;
     const edited = reduce(s, { tag: 'CellEdited', row: 0, column: 'beroep', value: 'Chirurg' });
-    if (edited.tag !== 'loaded') return;
+    if (edited.tag !== 'Loaded') return;
     expect(edited.rows[0]['beroep']).toBe('Chirurg');
     expect(edited.original[0]['beroep']).toBe('Arts'); // snapshot untouched → diff works
   });
 
   it('RowAdded appends an empty row shaped by the schema', () => {
     const s = reduce(seedLoaded(), { tag: 'RowAdded' });
-    if (s.tag !== 'loaded') return;
+    if (s.tag !== 'Loaded') return;
     expect(s.rows).toHaveLength(2);
     expect(s.rows[1]).toEqual({ program: '', beroep: '', geldigVan: '', geldigTot: '' });
   });
 
   it('RowRemoved drops the row at the index', () => {
     const s = reduce(reduce(seedLoaded(), { tag: 'RowAdded' }), { tag: 'RowRemoved', row: 0 });
-    if (s.tag !== 'loaded') return;
+    if (s.tag !== 'Loaded') return;
     expect(s.rows).toHaveLength(1);
   });
 
   it('edit messages are ignored unless loaded', () => {
     expect(reduce(initial, { tag: 'RowAdded' })).toBe(initial);
     expect(
-      reduce({ tag: 'failed', reason: 'x' }, { tag: 'CellEdited', row: 0, column: 'a', value: 'b' })
+      reduce({ tag: 'Failed', reason: 'x' }, { tag: 'CellEdited', row: 0, column: 'a', value: 'b' })
         .tag,
-    ).toBe('failed');
+    ).toBe('Failed');
   });
 
   it('LoadFailed and Loading transition regardless of prior state', () => {
     expect(reduce(seedLoaded(), { tag: 'LoadFailed', reason: 'boom' })).toEqual({
-      tag: 'failed',
+      tag: 'Failed',
       reason: 'boom',
     });
-    expect(reduce(seedLoaded(), { tag: 'Loading' })).toEqual({ tag: 'loading' });
+    expect(reduce(seedLoaded(), { tag: 'Loading' })).toEqual({ tag: 'Loading' });
   });
 });

libs/beheer/src/domain/stamdata-editor.machine.ts

@@ -11,9 +11,9 @@ import { StamRow, StamTable, emptyRow } from '@beheer/domain/stamdata';
  * apply path is a reviewed PR, not a runtime write — ADR-0004).
  */
 export type StamdataEditorState =
-  | { tag: 'loading' }
-  | { tag: 'failed'; reason: string }
-  | { tag: 'loaded'; table: StamTable; rows: StamRow[]; original: readonly StamRow[] };
+  | { tag: 'Loading' }
+  | { tag: 'Failed'; reason: string }
+  | { tag: 'Loaded'; table: StamTable; rows: StamRow[]; original: readonly StamRow[] };
 
 export type StamdataEditorMsg =
   | { tag: 'Loading' }
@@ -24,29 +24,29 @@ export type StamdataEditorMsg =
   | { tag: 'RowRemoved'; row: number }
   | { tag: 'Seed'; state: StamdataEditorState }; // mount a specific state (stories/tests)
 
-export const initial: StamdataEditorState = { tag: 'loading' };
+export const initial: StamdataEditorState = { tag: 'Loading' };
 
 const copy = (rows: readonly StamRow[]): StamRow[] => rows.map((r) => ({ ...r }));
 
 export function reduce(s: StamdataEditorState, m: StamdataEditorMsg): StamdataEditorState {
   switch (m.tag) {
     case 'Loading':
-      return { tag: 'loading' };
+      return { tag: 'Loading' };
     case 'Loaded':
       // original is an independent snapshot so later edits never mutate it (drives the diff).
-      return { tag: 'loaded', table: m.table, rows: copy(m.rows), original: copy(m.rows) };
+      return { tag: 'Loaded', table: m.table, rows: copy(m.rows), original: copy(m.rows) };
     case 'LoadFailed':
-      return { tag: 'failed', reason: m.reason };
+      return { tag: 'Failed', reason: m.reason };
     case 'CellEdited':
-      if (s.tag !== 'loaded') return s;
+      if (s.tag !== 'Loaded') return s;
       return {
         ...s,
         rows: s.rows.map((r, i) => (i === m.row ? { ...r, [m.column]: m.value } : r)),
       };
     case 'RowAdded':
-      return s.tag === 'loaded' ? { ...s, rows: [...s.rows, emptyRow(s.table)] } : s;
+      return s.tag === 'Loaded' ? { ...s, rows: [...s.rows, emptyRow(s.table)] } : s;
     case 'RowRemoved':
-      return s.tag === 'loaded' ? { ...s, rows: s.rows.filter((_, i) => i !== m.row) } : s;
+      return s.tag === 'Loaded' ? { ...s, rows: s.rows.filter((_, i) => i !== m.row) } : s;
     case 'Seed':
       return m.state;
     default:

libs/shared/docs/behaviour-spec.mdx

@@ -819,6 +819,12 @@ classes.
 - is empty-safe: undefined, null, and empty string all yield the empty string
 - returns empty for an unparseable string rather than "Invalid Date"
 
+#### fromLoadLifecycle
+
+- maps Loading → Loading
+- maps Failed → Failure carrying an Error with the reason
+- maps Loaded → Success carrying the whole loaded state
+
 #### httpClientFetch
 
 - sends the pending idempotency key as a header for a write, not a fresh one per attempt
@@ -836,12 +842,6 @@ classes.
 - keeps query + hash on both targets
 - the root maps nl → / and en → /en/
 
-#### machineRemoteData
-
-- maps loading → Loading
-- maps failed → Failure carrying an Error with the reason
-- maps loaded → Success carrying the whole loaded state
-
 #### parseBsn (elfproef)
 
 - accepts a valid BSN (passes the elfproef)

libs/shared/docs/remote-data.mdx

@@ -69,7 +69,7 @@ The idiom this repo uses instead — see `brief.page.ts`, `dashboard.page.ts`,
 // in the component class
 protected readonly loaded = computed(() => {
   const s = this.model(); // or store.someRemoteData()
-  return s.tag === 'loaded' ? s : undefined;
+  return s.tag === 'Loaded' ? s : undefined;
 });
 ```
 
@@ -94,8 +94,8 @@ timing/outcome of `/api/*` calls. Try it on `/brief` or `/dashboard`.
 A store's own state machine (its `*.machine.ts`) should own the **domain** lifecycle of
 what it holds (draft → submitted → approved, in the brief's case) — not the network
 fetch's loading/failure, which is a generic concern `RemoteData` already models. Where a
-machine's own `loading`/`failed` tags purely mirror the fetch (nothing extra beyond "not
-loaded yet" / "the GET failed"), project them onto a `RemoteData` computed at the store
-layer for `<app-async>` to render, the way `BriefStore.remoteData` does — the machine
+machine's own `Loading`/`Failed`/`Loaded` tags purely mirror the fetch (nothing extra
+beyond "not loaded yet" / "the GET failed"), project them with `fromLoadLifecycle` at the
+store layer for `<app-async>` to render, the way `BriefStore.remoteData` does — the machine
 keeps deciding what the _letter_ is doing, `RemoteData` keeps deciding what the _fetch_ is
 doing.

libs/shared/src/application/machine-remote-data.spec.ts

@@ -1,20 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { machineRemoteData } from './machine-remote-data';
-import { loading, success } from '../testing/remote-data';
-
-describe('machineRemoteData', () => {
-  it('maps loading → Loading', () => {
-    expect(machineRemoteData({ tag: 'loading' })).toEqual(loading());
-  });
-
-  it('maps failed → Failure carrying an Error with the reason', () => {
-    const rd = machineRemoteData({ tag: 'failed', reason: 'boom' });
-    expect(rd.tag).toBe('Failure');
-    if (rd.tag === 'Failure') expect(rd.error.message).toBe('boom');
-  });
-
-  it('maps loaded → Success carrying the whole loaded state', () => {
-    const loaded = { tag: 'loaded', foo: 42 } as const;
-    expect(machineRemoteData(loaded)).toEqual(success(loaded));
-  });
-});

libs/shared/src/application/machine-remote-data.ts

@@ -1,24 +0,0 @@
-import { RemoteData } from '@shared/application/remote-data';
-
-/** The standard load-lifecycle tags an editor machine exposes. */
-export type LoadLifecycle =
-  { tag: 'loading' } | { tag: 'failed'; reason: string } | { tag: 'loaded' };
-
-/**
- * Project an Elm-machine state onto `RemoteData` for the `<app-async>` seam. The machine
- * keeps owning its own domain lifecycle (draft/submitted/…); this is purely the
- * loading/failed/loaded → async mapping, which was byte-identical across BriefStore,
- * OrgTemplateStore and StamdataStore (WP-31). Wrap the call in a `computed`.
- */
-export function machineRemoteData<S extends LoadLifecycle>(
-  s: S,
-): RemoteData<Error, Extract<S, { tag: 'loaded' }>> {
-  switch (s.tag) {
-    case 'loading':
-      return { tag: 'Loading' };
-    case 'failed':
-      return { tag: 'Failure', error: new Error(s.reason) };
-    default: // 'loaded'
-      return { tag: 'Success', value: s as Extract<S, { tag: 'loaded' }> };
-  }
-}

libs/shared/src/application/remote-data.spec.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { RemoteData, map2, map, successOf } from './remote-data';
+import { RemoteData, fromLoadLifecycle, map2, map, successOf } from './remote-data';
 import { loading, failure, empty, success } from '../testing/remote-data';
 
 const loadingRd: RemoteData<string, number> = loading();
@@ -33,3 +33,20 @@ describe('successOf', () => {
     expect(successOf(empty())).toBeUndefined();
   });
 });
+
+describe('fromLoadLifecycle', () => {
+  it('maps Loading → Loading', () => {
+    expect(fromLoadLifecycle({ tag: 'Loading' })).toEqual(loading());
+  });
+
+  it('maps Failed → Failure carrying an Error with the reason', () => {
+    const rd = fromLoadLifecycle({ tag: 'Failed', reason: 'boom' });
+    expect(rd.tag).toBe('Failure');
+    if (rd.tag === 'Failure') expect(rd.error.message).toBe('boom');
+  });
+
+  it('maps Loaded → Success carrying the whole loaded state', () => {
+    const loadedState = { tag: 'Loaded', foo: 42 } as const;
+    expect(fromLoadLifecycle(loadedState)).toEqual(success(loadedState));
+  });
+});

libs/shared/src/application/remote-data.ts

@@ -27,6 +27,26 @@ export function fromResource<T>(
   return { tag: 'Loading' };
 }
 
+/**
+ * Project an Elm-machine's load lifecycle onto `RemoteData`, for the `<app-async>` seam. The
+ * machine keeps owning its own domain lifecycle (draft/submitted/…); this is purely the
+ * Loading/Failed/Loaded → async mapping, which was byte-identical across BriefStore,
+ * OrgTemplateStore and StamdataStore (WP-31). A `RemoteData` constructor, not a sixth
+ * encoding — wrap the call in a `computed`.
+ */
+export function fromLoadLifecycle<
+  S extends { tag: 'Loading' } | { tag: 'Failed'; reason: string } | { tag: 'Loaded' },
+>(s: S): RemoteData<Error, Extract<S, { tag: 'Loaded' }>> {
+  switch (s.tag) {
+    case 'Loading':
+      return { tag: 'Loading' };
+    case 'Failed':
+      return { tag: 'Failure', error: new Error(s.reason) };
+    default: // 'Loaded'
+      return { tag: 'Success', value: s as Extract<S, { tag: 'Loaded' }> };
+  }
+}
+
 // #region showcase:fold
 /** Exhaustive fold: you must handle every case, checked at compile time. */
 export function foldRemote<E, T, R>(