@specverse/engines 4.1.30 → 4.2.0

package/libs/instance-factories/applications/templates/react-starter/__tests__/helpers-emitter.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import * as ts from 'typescript';
+import { emitEntityDisplay } from '../helpers-emitter.js';
+
+function assertValidTsx(source: string, label: string): void {
+  const result = ts.transpileModule(source, {
+    compilerOptions: {
+      jsx: ts.JsxEmit.Preserve,
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      strict: true,
+    },
+    reportDiagnostics: true,
+  });
+  const errors = result.diagnostics?.filter(d => d.category === ts.DiagnosticCategory.Error) ?? [];
+  if (errors.length > 0) {
+    const message = errors
+      .map(d => ts.flattenDiagnosticMessageText(d.messageText, '\n'))
+      .join('\n');
+    throw new Error(`${label} failed to parse as TypeScript:\n${message}`);
+  }
+}
+
+describe('emitEntityDisplay', () => {
+  it('produces a module that parses under strict TypeScript', () => {
+    assertValidTsx(emitEntityDisplay(), 'entity-display.ts');
+  });
+
+  it('exports both getEntityDisplayName and resolveEntityDisplayName', () => {
+    const src = emitEntityDisplay();
+    expect(src).toMatch(/export function getEntityDisplayName/);
+    expect(src).toMatch(/export function resolveEntityDisplayName/);
+  });
+
+  it('uses the canonical candidate list in documented order', () => {
+    const src = emitEntityDisplay();
+    // Order matters: name → title → displayName → label → username → email.
+    // The order mirrors @specverse/runtime/views/core/entity-display.
+    const candidatesLine = src.match(/const candidates = \[([^\]]+)\]/)?.[1];
+    expect(candidatesLine).toBeDefined();
+    expect(candidatesLine).toContain("'name'");
+    expect(candidatesLine).toContain("'title'");
+    expect(candidatesLine).toContain("'displayName'");
+    expect(candidatesLine).toContain("'email'");
+    // Check relative order
+    const order = ['name', 'title', 'displayName', 'label', 'username', 'email'];
+    let lastIdx = -1;
+    for (const n of order) {
+      const idx = candidatesLine!.indexOf(`'${n}'`);
+      expect(idx).toBeGreaterThan(lastIdx);
+      lastIdx = idx;
+    }
+  });
+});

package/libs/instance-factories/applications/templates/react-starter/__tests__/html-to-jsx.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect } from 'vitest';
+import { htmlToJsx } from '../html-to-jsx.js';
+
+describe('htmlToJsx — attribute renames', () => {
+  it('renames class → className', () => {
+    expect(htmlToJsx('<div class="foo">x</div>')).toBe('<div className="foo">x</div>');
+  });
+
+  it('renames class inside nested elements', () => {
+    const input = '<div class="a"><span class="b">hi</span></div>';
+    const expected = '<div className="a"><span className="b">hi</span></div>';
+    expect(htmlToJsx(input)).toBe(expected);
+  });
+
+  it('renames for → htmlFor on labels', () => {
+    expect(htmlToJsx('<label for="id">X</label>')).toBe('<label htmlFor="id">X</label>');
+  });
+
+  it('renames tabindex → tabIndex', () => {
+    expect(htmlToJsx('<div tabindex="0">x</div>')).toBe('<div tabIndex="0">x</div>');
+  });
+
+  it('renames multiple attributes in a single tag', () => {
+    const input = '<input class="c" readonly maxlength="10" />';
+    const out = htmlToJsx(input);
+    expect(out).toContain('className="c"');
+    expect(out).toContain('readOnly');
+    expect(out).toContain('maxLength="10"');
+  });
+
+  it('does not rewrite attribute values that contain "class"', () => {
+    // The substring "class" in an attribute value should not be renamed.
+    const input = '<div class="has class word" data-x="my class name">y</div>';
+    const out = htmlToJsx(input);
+    // Expected: only the class ATTRIBUTE is renamed; values unchanged.
+    expect(out).toBe('<div className="has class word" data-x="my class name">y</div>');
+  });
+});
+
+describe('htmlToJsx — void elements', () => {
+  it('self-closes img', () => {
+    expect(htmlToJsx('<img src="a.png" alt="A">')).toBe('<img src="a.png" alt="A" />');
+  });
+
+  it('self-closes br', () => {
+    expect(htmlToJsx('line<br>break')).toBe('line<br />break');
+  });
+
+  it('self-closes input', () => {
+    expect(htmlToJsx('<input type="text" class="f">')).toBe('<input type="text" className="f" />');
+  });
+
+  it('self-closes hr', () => {
+    expect(htmlToJsx('<hr>')).toBe('<hr />');
+  });
+
+  it('leaves already-self-closed void elements alone', () => {
+    expect(htmlToJsx('<br />')).toBe('<br />');
+    expect(htmlToJsx('<img src="a" />')).toBe('<img src="a" />');
+  });
+
+  it('handles void elements in the middle of content', () => {
+    const input = '<p>hello<br>world<br>!</p>';
+    expect(htmlToJsx(input)).toBe('<p>hello<br />world<br />!</p>');
+  });
+});
+
+describe('htmlToJsx — inline style conversion', () => {
+  it('converts a single-declaration style', () => {
+    const input = '<div style="color: red">x</div>';
+    const out = htmlToJsx(input);
+    expect(out).toBe("<div style={{ color: 'red' }}>x</div>");
+  });
+
+  it('converts multiple declarations and camelCases property names', () => {
+    const input = '<div style="color: red; font-size: 14px; background-color: blue">x</div>';
+    const out = htmlToJsx(input);
+    expect(out).toBe("<div style={{ color: 'red', fontSize: '14px', backgroundColor: 'blue' }}>x</div>");
+  });
+
+  it('handles empty style', () => {
+    expect(htmlToJsx('<div style="">x</div>')).toBe('<div style={{}}>x</div>');
+  });
+
+  it('escapes single quotes inside values', () => {
+    const input = `<div style="font-family: 'Helvetica Neue'">x</div>`;
+    const out = htmlToJsx(input);
+    expect(out).toBe("<div style={{ fontFamily: '\\'Helvetica Neue\\'' }}>x</div>");
+  });
+
+  it('strips trailing semicolons and extra spacing', () => {
+    const input = '<div style="color:red;  font-size: 14px ;">x</div>';
+    const out = htmlToJsx(input);
+    expect(out).toBe("<div style={{ color: 'red', fontSize: '14px' }}>x</div>");
+  });
+});
+
+describe('htmlToJsx — idempotence', () => {
+  it('is a no-op on already-transformed input', () => {
+    const jsxLike = '<div className="a"><input type="text" /><br /></div>';
+    expect(htmlToJsx(jsxLike)).toBe(jsxLike);
+  });
+});
+
+describe('htmlToJsx — empty / degenerate input', () => {
+  it('returns empty string for empty input', () => {
+    expect(htmlToJsx('')).toBe('');
+  });
+
+  it('returns text-only input unchanged', () => {
+    expect(htmlToJsx('Loading...')).toBe('Loading...');
+  });
+});
+
+describe('htmlToJsx — realistic Tailwind-adapter output', () => {
+  it('transforms a typical table produced by the adapter', () => {
+    const input =
+      '<table class="w-full text-left border-collapse">' +
+      '<thead><tr><th class="px-4 py-2 font-semibold">Title</th></tr></thead>' +
+      '<tbody><tr class="hover:bg-gray-50"><td class="px-4 py-2">Hello</td></tr></tbody>' +
+      '</table>';
+    const out = htmlToJsx(input);
+    expect(out).toContain('className="w-full text-left border-collapse"');
+    expect(out).toContain('className="px-4 py-2 font-semibold"');
+    expect(out).toContain('className="hover:bg-gray-50"');
+    expect(out).not.toContain('class=');
+  });
+
+  it('transforms a form-group with inputs', () => {
+    const input =
+      '<div class="space-y-4">' +
+      '<label for="title" class="text-sm">Title</label>' +
+      '<input type="text" class="border rounded px-2 py-1">' +
+      '</div>';
+    const out = htmlToJsx(input);
+    expect(out).toContain('htmlFor="title"');
+    expect(out).toContain('className="text-sm"');
+    expect(out).toContain('<input type="text" className="border rounded px-2 py-1" />');
+  });
+});

package/libs/instance-factories/applications/templates/react-starter/__tests__/list-body-composer.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest';
+import * as ts from 'typescript';
+import { composeListBody } from '../list-body-composer.js';
+import { emitView, type EmitContext, type ModelSpec } from '../view-emitter.js';
+
+/**
+ * End-to-end: the canonical Tailwind adapter renders the table shell,
+ * the composer injects a JSX row-map, the emitter substitutes into
+ * the skeleton. The full output must parse as valid TSX.
+ */
+
+function makeContext(overrides: Partial<EmitContext> = {}): EmitContext {
+  const post: ModelSpec = {
+    name: 'Post',
+    attributes: {
+      // `id` is excluded by runtime's inferFieldsFromSchema directly.
+      id: { type: 'UUID', required: true },
+      title: { type: 'String', required: true },
+      body: { type: 'Text', required: false },
+      // `auto=now` is what marks publishedAt as excluded from column
+      // inference — the canonical rule from runtime pattern-engine.
+      publishedAt: { type: 'DateTime', required: false, auto: 'now' },
+      authorId: { type: 'UUID', required: true },
+    },
+  };
+
+  return {
+    view: { type: 'list', model: 'Post' },
+    viewName: 'PostListView',
+    model: post,
+    modelSchemas: { Post: post },
+    renderBody: composeListBody,
+    ...overrides,
+  };
+}
+
+function assertValidTsx(source: string, label: string): void {
+  const result = ts.transpileModule(source, {
+    compilerOptions: {
+      jsx: ts.JsxEmit.Preserve,
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      strict: false,
+    },
+    reportDiagnostics: true,
+  });
+  const errors = result.diagnostics?.filter(d => d.category === ts.DiagnosticCategory.Error) ?? [];
+  if (errors.length > 0) {
+    const message = errors
+      .map(d => ts.flattenDiagnosticMessageText(d.messageText, '\n'))
+      .join('\n');
+    throw new Error(`${label} failed to parse as TSX:\n${message}\n\n--- source ---\n${source}`);
+  }
+}
+
+describe('composeListBody — direct output', () => {
+  it('produces JSX containing the canonical table shell', () => {
+    const body = composeListBody(makeContext());
+    // Comes from the Tailwind adapter's table template
+    expect(body).toContain('overflow-x-auto');
+    expect(body).toContain('min-w-full');
+    expect(body).toContain('<thead');
+    expect(body).toContain('<tbody');
+    // After html-to-jsx: class → className
+    expect(body).toContain('className=');
+    expect(body).not.toMatch(/\bclass=/);
+  });
+
+  it('renders one header cell per non-metadata attribute, humanized', () => {
+    const body = composeListBody(makeContext());
+    expect(body).toContain('>Title<');
+    expect(body).toContain('>Body<');
+    expect(body).toContain('>Author Id<');   // authorId humanized
+    expect(body).not.toContain('>Id<');       // id filtered as metadata
+    expect(body).not.toContain('>Published At<'); // publishedAt filtered as metadata
+  });
+
+  it('emits a filtered.map expression with one cell per column', () => {
+    const body = composeListBody(makeContext());
+    expect(body).toContain('filtered.map((item, idx) =>');
+    expect(body).toContain('onClick={() => onSelect?.(item)}');
+
+    // Count how many times each field name appears in cell-context (inside
+    // the `<td>...item.FIELD ??` substring). Metadata should appear 0 times;
+    // business fields exactly once each.
+    const cellsRegion = body.slice(body.indexOf('<tbody'));
+    const cellAppearances = (field: string) =>
+      (cellsRegion.match(new RegExp(`item as any\\)\\.${field} \\?\\?`, 'g')) ?? []).length;
+
+    expect(cellAppearances('title')).toBe(1);
+    expect(cellAppearances('body')).toBe(1);
+    expect(cellAppearances('authorId')).toBe(1);
+    expect(cellAppearances('id')).toBe(0);           // metadata
+    expect(cellAppearances('publishedAt')).toBe(0);  // metadata
+  });
+
+  it('handles a model with zero non-metadata attributes', () => {
+    const empty: ModelSpec = {
+      name: 'Pulse',
+      attributes: { id: { type: 'UUID', required: true } },
+    };
+    const body = composeListBody(makeContext({
+      model: empty,
+      view: { type: 'list', model: 'Pulse' },
+      viewName: 'PulseListView',
+      modelSchemas: { Pulse: empty },
+    }));
+    // Table renders with empty columns array (no <th> cells inside <tr>)
+    expect(body).toContain('<thead');
+    // Row map still present — but cells block empty
+    expect(body).toContain('filtered.map');
+  });
+});
+
+describe('emitView wired to composeListBody — end-to-end', () => {
+  it('produces a complete PostListView.tsx that parses', () => {
+    const source = emitView(makeContext());
+    assertValidTsx(source, 'PostListView');
+  });
+
+  it('integrates skeleton + composer correctly', () => {
+    const source = emitView(makeContext());
+    // From skeleton
+    expect(source).toContain('export function PostListView');
+    expect(source).toContain('usePostsQuery');
+    expect(source).toContain('useDeletePostMutation');
+    // From composer (canonical adapter shell + row map)
+    expect(source).toContain('filtered.map');
+    expect(source).toContain('onSelect?.(item)');
+    expect(source).toContain('>Title<');
+    // No stray sentinels or placeholders
+    expect(source).not.toContain('__SPECVERSE_TBODY_ROWS__');
+    expect(source).not.toMatch(/\{\{[A-Z_]+\}\}/);
+  });
+
+  it('produces readable, line-broken output (no wall of HTML)', () => {
+    const source = emitView(makeContext());
+    // Sanity: the emitted file should be multi-line idiomatic React,
+    // not one giant collapsed line.
+    const lines = source.split('\n');
+    expect(lines.length).toBeGreaterThan(30);
+    // And no obviously-HTML escape leakage
+    expect(source).not.toContain('dangerouslySetInnerHTML');
+  });
+});

package/libs/instance-factories/applications/templates/react-starter/__tests__/orchestrator.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import * as ts from 'typescript';
+import { generate } from '../orchestrator.js';
+import { sha256, HASHES_DIR, HASHES_FILE } from '../regen-safety.js';
+
+let projectRoot: string;
+
+beforeEach(() => {
+  projectRoot = mkdtempSync(join(tmpdir(), 'react-starter-orch-'));
+  // Suppress the orchestrator's console.log summary during tests.
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+});
+
+afterEach(() => {
+  rmSync(projectRoot, { recursive: true, force: true });
+  vi.restoreAllMocks();
+});
+
+function makeSpec() {
+  return {
+    metadata: { name: 'My App' },
+    models: {
+      Post: {
+        name: 'Post',
+        attributes: {
+          id: { type: 'UUID', auto: 'uuid4' },
+          title: { type: 'String', required: true },
+          body: { type: 'Text' },
+        },
+      },
+    },
+    views: {},
+  };
+}
+
+function assertValidTsx(source: string, label: string): void {
+  const result = ts.transpileModule(source, {
+    compilerOptions: {
+      jsx: ts.JsxEmit.Preserve,
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      strict: false,
+    },
+    reportDiagnostics: true,
+  });
+  const errors = result.diagnostics?.filter(d => d.category === ts.DiagnosticCategory.Error) ?? [];
+  if (errors.length > 0) {
+    const msg = errors.map(d => ts.flattenDiagnosticMessageText(d.messageText, '\n')).join('\n');
+    throw new Error(`${label} failed to parse:\n${msg}`);
+  }
+}
+
+/**
+ * Apply an orchestrator output to disk — simulates what realize does
+ * when it receives the multi-file generator result.
+ */
+function applyOutput(output: Record<string, string>, root: string): void {
+  for (const [relPath, content] of Object.entries(output)) {
+    const abs = join(root, relPath);
+    mkdirSync(join(abs, '..'), { recursive: true });
+    writeFileSync(abs, content, 'utf8');
+  }
+}
+
+describe('orchestrator — first-run (empty project)', () => {
+  it('returns the full set of files: views + helpers + App.tsx + package.json + hash manifest', async () => {
+    const output = await generate({ spec: makeSpec(), projectRoot });
+    const paths = Object.keys(output).sort();
+    expect(paths).toEqual([
+      `${HASHES_DIR}/${HASHES_FILE}`,
+      'package.json',
+      'src/App.tsx',
+      'src/lib/entity-display.ts',
+      'src/views/PostDashboardView.tsx',
+      'src/views/PostDetailView.tsx',
+      'src/views/PostFormView.tsx',
+      'src/views/PostListView.tsx',
+    ]);
+  });
+
+  it('does not write to disk (that is realize\'s job)', async () => {
+    await generate({ spec: makeSpec(), projectRoot });
+    // Orchestrator is pure — nothing on disk yet.
+    expect(existsSync(join(projectRoot, 'package.json'))).toBe(false);
+    expect(existsSync(join(projectRoot, 'src/App.tsx'))).toBe(false);
+  });
+
+  it('every emitted .tsx parses as valid TSX', async () => {
+    const output = await generate({ spec: makeSpec(), projectRoot });
+    for (const [path, source] of Object.entries(output)) {
+      if (path.endsWith('.tsx')) assertValidTsx(source, path);
+    }
+  });
+
+  it('package.json has no @specverse/runtime dependency', async () => {
+    const output = await generate({ spec: makeSpec(), projectRoot });
+    const pkg = JSON.parse(output['package.json']);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    expect(deps['@specverse/runtime']).toBeUndefined();
+  });
+
+  it('the emitted hash manifest records every approved file', async () => {
+    const output = await generate({ spec: makeSpec(), projectRoot });
+    const manifestKey = `${HASHES_DIR}/${HASHES_FILE}`;
+    const manifest = JSON.parse(output[manifestKey]);
+    // Every returned file (except the manifest itself) should have a hash.
+    for (const path of Object.keys(output)) {
+      if (path === manifestKey) continue;
+      expect(manifest[path]).toBe(sha256(output[path]));
+    }
+  });
+});
+
+describe('orchestrator — regeneration safety', () => {
+  it('re-approves pristine files on a second run', async () => {
+    // First run — write outputs to disk to simulate realize.
+    const firstOutput = await generate({ spec: makeSpec(), projectRoot });
+    applyOutput(firstOutput, projectRoot);
+
+    // Second run — everything is pristine, should be re-approved.
+    const secondOutput = await generate({ spec: makeSpec(), projectRoot });
+    // The view files etc. should reappear in the output (realize will overwrite).
+    expect(secondOutput['src/views/PostListView.tsx']).toBeDefined();
+  });
+
+  it('omits a user-edited file from the output', async () => {
+    const firstOutput = await generate({ spec: makeSpec(), projectRoot });
+    applyOutput(firstOutput, projectRoot);
+
+    // User edits one of the files
+    const editedPath = 'src/views/PostListView.tsx';
+    writeFileSync(join(projectRoot, editedPath), '/* edited */', 'utf8');
+
+    const secondOutput = await generate({ spec: makeSpec(), projectRoot });
+
+    // User-edited file not in the output → realize won't overwrite it
+    expect(secondOutput[editedPath]).toBeUndefined();
+    // Other files still present
+    expect(secondOutput['src/views/PostDetailView.tsx']).toBeDefined();
+    // Manifest preserves the OLD hash for the skipped file
+    const manifest = JSON.parse(secondOutput[`${HASHES_DIR}/${HASHES_FILE}`]);
+    const oldManifest = JSON.parse(firstOutput[`${HASHES_DIR}/${HASHES_FILE}`]);
+    expect(manifest[editedPath]).toBe(oldManifest[editedPath]);
+  });
+
+  it('is cautious when the user deletes the hash manifest', async () => {
+    const firstOutput = await generate({ spec: makeSpec(), projectRoot });
+    applyOutput(firstOutput, projectRoot);
+
+    // User deletes the hash manifest
+    rmSync(join(projectRoot, HASHES_DIR), { recursive: true, force: true });
+
+    const secondOutput = await generate({ spec: makeSpec(), projectRoot });
+
+    // All existing files are now "unknown origin" → skipped.
+    // Output should only contain the fresh hash manifest.
+    expect(Object.keys(secondOutput)).toEqual([`${HASHES_DIR}/${HASHES_FILE}`]);
+  });
+});

package/libs/instance-factories/applications/templates/react-starter/__tests__/parity-p2-factory-imports.test.ts

@@ -0,0 +1,116 @@
+/**
+ * P2 — Factory generators consume the pattern library, not forks
+ *
+ * Architectural invariant I5 from VIEW-RENDERING-ARCHITECTURE.md:
+ *   "Factory generators are consumers of the pattern library, not
+ *    reimplementations of it."
+ *
+ * Every composer / body-generator under react-starter must import
+ * from `@specverse/runtime/views/core` or `@specverse/runtime/views/tailwind`.
+ * A generator that doesn't is a reimplementation — it's drift-prone
+ * and violates the "one pattern library, three consumers" contract.
+ *
+ * Scope: files matching *-composer.ts or view-emitter.ts / generator
+ * files that actually produce view-layout code. Skeletons (.tsx.template)
+ * are content-only and exempt. helpers-emitter / html-to-jsx are
+ * transformation utilities, exempt — they don't consume pattern data.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const HERE = fileURLToPath(import.meta.url);
+const STARTER_DIR = resolve(HERE, '..', '..');
+
+const RUNTIME_IMPORT_PATTERN =
+  /from\s+['"]@specverse\/runtime\/views\/(core|tailwind)['"]/;
+
+/**
+ * Files required to import from @specverse/runtime/views/core or
+ * /views/tailwind. The filenames match the convention of any generator
+ * that emits view layout or composes pattern data.
+ */
+const MUST_IMPORT_FROM_RUNTIME = (filename: string): boolean => {
+  // Every body composer (list / detail / form / dashboard).
+  if (/-body-composer\.ts$/.test(filename)) return true;
+  return false;
+};
+
+/**
+ * Files explicitly exempt from P2 — orchestrators, transformers, and
+ * utilities that don't consume pattern data. Each exemption carries
+ * a short justification as an inline comment near the import list.
+ */
+const EXEMPT_FILES = new Set([
+  // Orchestrator: dispatches to composers (which do import runtime).
+  'views-generator.ts',
+  'view-emitter.ts',
+  'orchestrator.ts',
+  // Pure string transformer, no pattern data.
+  'html-to-jsx.ts',
+  // Emits inline source code; no adapter calls needed.
+  'helpers-emitter.ts',
+  'app-tsx-generator.ts',
+  'package-json-generator.ts',
+  // Pure utility for content-hashing, no pattern consumption.
+  'regen-safety.ts',
+]);
+
+function collectTypeScriptFiles(dir: string, prefix = ''): string[] {
+  const out: string[] = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === '__tests__' || entry.name === 'skeletons') continue;
+    const full = join(dir, entry.name);
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      out.push(...collectTypeScriptFiles(full, rel));
+    } else if (entry.isFile() && entry.name.endsWith('.ts') && !entry.name.endsWith('.test.ts')) {
+      out.push(rel);
+    }
+  }
+  return out;
+}
+
+describe('P2 — factory generators consume the pattern library', () => {
+  const files = collectTypeScriptFiles(STARTER_DIR);
+
+  it('produces a non-empty file list (sanity)', () => {
+    expect(files.length).toBeGreaterThan(0);
+  });
+
+  for (const relPath of files) {
+    const filename = relPath.split('/').pop()!;
+
+    if (EXEMPT_FILES.has(filename)) continue;
+    if (!MUST_IMPORT_FROM_RUNTIME(filename)) continue;
+
+    it(`${relPath} imports from @specverse/runtime/views/{core|tailwind}`, () => {
+      const content = readFileSync(join(STARTER_DIR, relPath), 'utf8');
+      const imports = RUNTIME_IMPORT_PATTERN.test(content);
+      if (!imports) {
+        throw new Error(
+          `${relPath} must import from @specverse/runtime/views/core or ` +
+          `@specverse/runtime/views/tailwind to satisfy invariant I5. ` +
+          `If it genuinely doesn't need pattern data, add it to the ` +
+          `EXEMPT_FILES set with a justification. Generators that emit ` +
+          `view-layout code inevitably use pattern constants (field ` +
+          `classification, atomic components) — sourcing those from ` +
+          `runtime is what keeps the three consumers in sync.`
+        );
+      }
+    });
+  }
+
+  it('every composer is covered by an explicit rule (no silent skips)', () => {
+    const composers = files.filter(f => f.endsWith('-body-composer.ts'));
+    expect(composers.length).toBeGreaterThanOrEqual(4); // list/detail/form/dashboard at minimum
+    for (const c of composers) {
+      const filename = c.split('/').pop()!;
+      expect(MUST_IMPORT_FROM_RUNTIME(filename)).toBe(true);
+      expect(EXEMPT_FILES.has(filename)).toBe(false);
+    }
+  });
+});