@hyperfixi/server-bridge 2.0.0

package/src/__tests__/form-scanner.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest';
+import { extractFormFields, extractFormBodies } from '../scanner/form-scanner.js';
+
+describe('extractFormFields', () => {
+  it('extracts named input fields', () => {
+    const html = `
+      <input name="username" type="text" required>
+      <input name="email" type="email" required>
+      <input name="age" type="number">
+    `;
+    const fields = extractFormFields(html);
+    expect(fields).toHaveLength(3);
+    expect(fields[0]).toEqual({ name: 'username', type: 'string', required: true });
+    expect(fields[1]).toEqual({ name: 'email', type: 'string', required: true });
+    expect(fields[2]).toEqual({ name: 'age', type: 'number', required: false });
+  });
+
+  it('handles select and textarea', () => {
+    const html = `
+      <select name="country" required></select>
+      <textarea name="bio"></textarea>
+    `;
+    const fields = extractFormFields(html);
+    expect(fields).toHaveLength(2);
+    expect(fields[0]).toEqual({ name: 'country', type: 'string', required: true });
+    expect(fields[1]).toEqual({ name: 'bio', type: 'string', required: false });
+  });
+
+  it('maps checkbox to boolean and file to file', () => {
+    const html = `
+      <input name="agree" type="checkbox">
+      <input name="avatar" type="file">
+    `;
+    const fields = extractFormFields(html);
+    expect(fields[0].type).toBe('boolean');
+    expect(fields[1].type).toBe('file');
+  });
+
+  it('deduplicates by name', () => {
+    const html = `
+      <input name="q" type="text">
+      <input name="q" type="search">
+    `;
+    const fields = extractFormFields(html);
+    expect(fields).toHaveLength(1);
+  });
+
+  it('defaults to string for unknown type', () => {
+    const html = `<input name="data">`;
+    const fields = extractFormFields(html);
+    expect(fields[0].type).toBe('string');
+  });
+});
+
+describe('extractFormBodies', () => {
+  it('associates form fields with hx-post URL', () => {
+    const html = `
+      <form hx-post="/api/users">
+        <input name="name" type="text" required>
+        <input name="email" type="email" required>
+        <button type="submit">Create</button>
+      </form>
+    `;
+    const bodies = extractFormBodies(html);
+    expect(bodies.size).toBe(1);
+    const fields = bodies.get('/api/users');
+    expect(fields).toHaveLength(2);
+    expect(fields![0].name).toBe('name');
+    expect(fields![1].name).toBe('email');
+  });
+
+  it('handles fx-action forms', () => {
+    const html = `
+      <form fx-action="/api/search">
+        <input name="q" type="search">
+      </form>
+    `;
+    const bodies = extractFormBodies(html);
+    expect(bodies.has('/api/search')).toBe(true);
+  });
+
+  it('skips forms without route-implying attributes', () => {
+    const html = `
+      <form action="/submit">
+        <input name="data">
+      </form>
+    `;
+    const bodies = extractFormBodies(html);
+    expect(bodies.size).toBe(0);
+  });
+});

package/src/__tests__/generate.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { mkdtemp, writeFile, rm, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { generate } from '../generate.js';
+
+describe('generate()', () => {
+  const dirs: string[] = [];
+
+  async function makeTempDir(): Promise<string> {
+    const dir = await mkdtemp(join(tmpdir(), 'sb-gen-'));
+    dirs.push(dir);
+    return dir;
+  }
+
+  afterEach(async () => {
+    for (const dir of dirs) {
+      await rm(dir, { recursive: true, force: true }).catch(() => {});
+    }
+    dirs.length = 0;
+  });
+
+  it('returns routes and generated files from HTML with fetch', async () => {
+    const dir = await makeTempDir();
+    await writeFile(
+      join(dir, 'index.html'),
+      `<button _="on click fetch /api/users as json">Load</button>`
+    );
+
+    const result = await generate({ dir });
+    expect(result.routes.length).toBeGreaterThanOrEqual(1);
+    expect(result.routes[0].path).toBe('/api/users');
+    expect(result.generated.files.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('returns empty results for empty directory', async () => {
+    const dir = await makeTempDir();
+    const result = await generate({ dir });
+    expect(result.routes).toEqual([]);
+    expect(result.generated.files).toHaveLength(0);
+  });
+
+  it('selects the correct generator framework', async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, 'page.html'), `<div hx-get="/api/data">Load</div>`);
+
+    const frameworks = ['express', 'hono', 'openapi', 'django', 'fastapi'] as const;
+    for (const framework of frameworks) {
+      const result = await generate({ dir, framework });
+      expect(result.routes).toHaveLength(1);
+      expect(result.generated.files.length).toBeGreaterThanOrEqual(1);
+    }
+  });
+
+  it('respects include/exclude patterns', async () => {
+    const dir = await makeTempDir();
+    await mkdir(join(dir, 'src'), { recursive: true });
+    await mkdir(join(dir, 'vendor'), { recursive: true });
+
+    await writeFile(join(dir, 'src', 'app.html'), `<div hx-get="/api/users">Load</div>`);
+    await writeFile(join(dir, 'vendor', 'lib.html'), `<div hx-get="/api/external">Load</div>`);
+
+    const result = await generate({
+      dir,
+      include: ['src/**/*.html'],
+      exclude: ['vendor/**'],
+    });
+
+    expect(result.routes).toHaveLength(1);
+    expect(result.routes[0].path).toBe('/api/users');
+  });
+
+  it('respects ignore patterns for URLs', async () => {
+    const dir = await makeTempDir();
+    await writeFile(
+      join(dir, 'page.html'),
+      `<div hx-get="/api/users">Load</div>
+       <div hx-get="/external/api/data">Load</div>`
+    );
+
+    const result = await generate({
+      dir,
+      ignore: ['/external/**'],
+    });
+
+    expect(result.routes).toHaveLength(1);
+    expect(result.routes[0].path).toBe('/api/users');
+  });
+});

package/src/__tests__/hono-generator.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from 'vitest';
+import { HonoGenerator } from '../generators/hono-generator.js';
+import type { RouteDescriptor } from '../types.js';
+
+function makeRoute(overrides: Partial<RouteDescriptor> = {}): RouteDescriptor {
+  return {
+    path: '/api/users',
+    method: 'GET',
+    responseFormat: 'json',
+    source: { file: 'test.html', kind: 'fetch', raw: 'fetch /api/users' },
+    pathParams: [],
+    handlerName: 'getApiUsers',
+    notes: [],
+    ...overrides,
+  };
+}
+
+describe('HonoGenerator', () => {
+  const gen = new HonoGenerator();
+
+  it('has correct framework name', () => {
+    expect(gen.framework).toBe('hono');
+  });
+
+  it('generates route files for a GET endpoint', () => {
+    const result = gen.generate([makeRoute()], { outputDir: '/out' });
+    expect(result.files.length).toBeGreaterThanOrEqual(2);
+    const routeFile = result.files.find(f => f.path.includes('api-users'));
+    expect(routeFile).toBeDefined();
+    expect(routeFile!.content).toContain("app.get('/api/users'");
+    expect(routeFile!.content).toContain("import { Hono } from 'hono'");
+    expect(routeFile!.content).toContain("return c.json({ message: 'Not implemented' })");
+  });
+
+  it('generates POST route with body parsing', () => {
+    const route = makeRoute({
+      method: 'POST',
+      handlerName: 'postApiUsers',
+      requestBody: [
+        { name: 'name', type: 'string', required: true },
+        { name: 'email', type: 'string', required: true },
+      ],
+    });
+    const result = gen.generate([route], { outputDir: '/out' });
+    const routeFile = result.files.find(f => f.path.includes('api-users'));
+    expect(routeFile!.content).toContain("app.post('/api/users'");
+    expect(routeFile!.content).toContain('const body = await c.req.json()');
+    expect(routeFile!.content).toContain('const { name, email } = body');
+  });
+
+  it('generates route with path params', () => {
+    const route = makeRoute({
+      path: '/api/users/:id',
+      pathParams: ['id'],
+    });
+    const result = gen.generate([route], { outputDir: '/out' });
+    const routeFile = result.files.find(f => f.path.includes('api-users'));
+    expect(routeFile!.content).toContain("const id = c.req.param('id')");
+  });
+
+  it('generates html response for html format', () => {
+    const route = makeRoute({ responseFormat: 'html' });
+    const result = gen.generate([route], { outputDir: '/out' });
+    const routeFile = result.files.find(f => f.path.includes('api-users'));
+    expect(routeFile!.content).toContain("return c.html('<div>Not implemented</div>')");
+  });
+
+  it('generates query param extraction', () => {
+    const route = makeRoute({
+      path: '/api/search',
+      handlerName: 'getApiSearch',
+      queryParams: [{ name: 'q', type: 'string', required: true }],
+    });
+    const result = gen.generate([route], { outputDir: '/out' });
+    const routeFile = result.files.find(f => f.path.includes('api-search'));
+    expect(routeFile!.content).toContain("const q = c.req.query('q')");
+  });
+
+  it('generates index file that composes route apps', () => {
+    const routes = [
+      makeRoute({ path: '/api/users' }),
+      makeRoute({ path: '/api/products', handlerName: 'getApiProducts' }),
+    ];
+    const result = gen.generate(routes, { outputDir: '/out' });
+    const indexFile = result.files.find(f => f.path.endsWith('index.ts'));
+    expect(indexFile).toBeDefined();
+    expect(indexFile!.content).toContain("import apiUsersRoutes from './api-users.js'");
+    expect(indexFile!.content).toContain("app.route('/', apiUsersRoutes)");
+  });
+});

package/src/__tests__/htmx-extractor.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import { extractHtmxRoutes } from '../scanner/htmx-extractor.js';
+
+const FILE = 'test.html';
+
+describe('extractHtmxRoutes', () => {
+  it('extracts hx-get', () => {
+    const html = `<div hx-get="/api/users" hx-target="#list">`;
+    const routes = extractHtmxRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+    expect(routes[0].path).toBe('/api/users');
+    expect(routes[0].method).toBe('GET');
+  });
+
+  it('extracts hx-post', () => {
+    const html = `<form hx-post="/api/users" hx-target="#result">`;
+    const routes = extractHtmxRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+    expect(routes[0].method).toBe('POST');
+  });
+
+  it('extracts hx-delete', () => {
+    const html = `<button hx-delete="/api/users/:id">`;
+    const routes = extractHtmxRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+    expect(routes[0].method).toBe('DELETE');
+    expect(routes[0].pathParams).toEqual(['id']);
+  });
+
+  it('defaults to html response format for htmx', () => {
+    const html = `<div hx-get="/api/users">`;
+    const routes = extractHtmxRoutes(html, { file: FILE });
+    expect(routes[0].responseFormat).toBe('html');
+  });
+
+  it('extracts fx-action with fx-method', () => {
+    const html = `<button fx-action="/api/search" fx-method="GET" fx-target="#results">`;
+    const routes = extractHtmxRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+    expect(routes[0].path).toBe('/api/search');
+    expect(routes[0].method).toBe('GET');
+    expect(routes[0].source.kind).toBe('fx-attr');
+  });
+
+  it('extracts fx-action without fx-method (defaults to GET)', () => {
+    const html = `<button fx-action="/api/data">`;
+    const routes = extractHtmxRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+    expect(routes[0].method).toBe('GET');
+  });
+
+  it('extracts multiple htmx routes from one file', () => {
+    const html = `
+      <div hx-get="/api/users" hx-target="#users">
+      <form hx-post="/api/users" hx-target="#result">
+      <button hx-delete="/api/users/:id">
+    `;
+    const routes = extractHtmxRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(3);
+  });
+
+  it('skips external URLs', () => {
+    const html = `<div hx-get="https://external.com/api/data">`;
+    const routes = extractHtmxRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(0);
+  });
+
+  it('deduplicates same method+path', () => {
+    const html = `
+      <button hx-get="/api/users">Load</button>
+      <div hx-get="/api/users">Refresh</div>
+    `;
+    const routes = extractHtmxRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+  });
+
+  it('records source information', () => {
+    const html = `\n<button hx-post="/api/submit">`;
+    const routes = extractHtmxRoutes(html, { file: FILE });
+    expect(routes[0].source.file).toBe(FILE);
+    expect(routes[0].source.kind).toBe('hx-attr');
+    expect(routes[0].source.raw).toBe('hx-post="/api/submit"');
+  });
+});

package/src/__tests__/hyperscript-extractor.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest';
+import { extractHyperscriptRoutes } from '../scanner/hyperscript-extractor.js';
+
+const FILE = 'test.html';
+
+describe('extractHyperscriptRoutes', () => {
+  it('extracts fetch with URL and response type', () => {
+    const html = `<button _="on click fetch /api/users as json then put it into #list">`;
+    const routes = extractHyperscriptRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+    expect(routes[0].path).toBe('/api/users');
+    expect(routes[0].method).toBe('GET');
+    expect(routes[0].responseFormat).toBe('json');
+  });
+
+  it('extracts fetch with html response type', () => {
+    const html = `<div _="on load fetch /partials/header as html then put it into me">`;
+    const routes = extractHyperscriptRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+    expect(routes[0].responseFormat).toBe('html');
+  });
+
+  it('extracts fetch with explicit method via keyword', () => {
+    const html = `<button _="on click fetch /api/users via POST">`;
+    const routes = extractHyperscriptRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+    expect(routes[0].method).toBe('POST');
+  });
+
+  it('extracts URL with path parameters', () => {
+    const html = `<button _="on click fetch /api/users/:id as json">`;
+    const routes = extractHyperscriptRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+    expect(routes[0].pathParams).toEqual(['id']);
+  });
+
+  it('extracts multiple fetch commands from different attributes', () => {
+    const html = `
+      <ul _="on load fetch /api/users as json then put it into me">
+      <button _="on click fetch /api/users/:id as json then put it into #detail">
+    `;
+    const routes = extractHyperscriptRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(2);
+    expect(routes[0].path).toBe('/api/users');
+    expect(routes[1].path).toBe('/api/users/:id');
+  });
+
+  it('extracts "send form to" as POST', () => {
+    const html = `<form _="on submit send form to /api/users as json">`;
+    const routes = extractHyperscriptRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+    expect(routes[0].method).toBe('POST');
+    expect(routes[0].path).toBe('/api/users');
+  });
+
+  it('extracts from script type=text/hyperscript blocks', () => {
+    const html = `
+      <script type="text/hyperscript">
+        on load fetch /api/config as json
+      </script>
+    `;
+    const routes = extractHyperscriptRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+    expect(routes[0].path).toBe('/api/config');
+  });
+
+  it('skips external URLs', () => {
+    const html = `<button _="on click fetch https://api.stripe.com/v1/charges as json">`;
+    const routes = extractHyperscriptRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(0);
+  });
+
+  it('deduplicates identical routes', () => {
+    const html = `
+      <button _="on click fetch /api/users as json">
+      <div _="on load fetch /api/users as json">
+    `;
+    const routes = extractHyperscriptRoutes(html, { file: FILE });
+    expect(routes).toHaveLength(1);
+  });
+
+  it('records source information', () => {
+    const html = `\n\n<button _="on click fetch /api/data as json">`;
+    const routes = extractHyperscriptRoutes(html, { file: FILE });
+    expect(routes[0].source.file).toBe(FILE);
+    expect(routes[0].source.kind).toBe('fetch');
+    expect(routes[0].source.line).toBe(3);
+  });
+});

package/src/__tests__/integration.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect } from 'vitest';
+import { scanRoutes } from '../scanner/route-scanner.js';
+import { ExpressGenerator } from '../generators/express-generator.js';
+import { HonoGenerator } from '../generators/hono-generator.js';
+
+const SAMPLE_HTML = `
+<!DOCTYPE html>
+<html>
+<body>
+  <h1>User Management</h1>
+
+  <!-- Hyperscript fetch -->
+  <div _="on load fetch /api/users as json then put it into me">
+    Loading users...
+  </div>
+
+  <!-- htmx GET -->
+  <button hx-get="/api/users/:id" hx-target="#detail">
+    View Details
+  </button>
+
+  <!-- htmx POST with form -->
+  <form hx-post="/api/users" hx-target="#result">
+    <input name="name" type="text" required>
+    <input name="email" type="email" required>
+    <input name="age" type="number">
+    <button type="submit">Create User</button>
+  </form>
+
+  <!-- htmx DELETE -->
+  <button hx-delete="/api/users/:id" hx-target="#user-row">
+    Delete User
+  </button>
+
+  <!-- fixi -->
+  <button fx-action="/api/search" fx-method="GET" fx-target="#results">
+    Search
+  </button>
+
+  <div id="detail"></div>
+  <div id="result"></div>
+  <div id="results"></div>
+</body>
+</html>
+`;
+
+describe('integration: full pipeline', () => {
+  it('extracts all routes from a realistic HTML page', () => {
+    const routes = scanRoutes(SAMPLE_HTML, 'users.html');
+
+    // Should find: GET /api/users, GET /api/users/:id, POST /api/users,
+    // DELETE /api/users/:id, GET /api/search
+    expect(routes.length).toBeGreaterThanOrEqual(4);
+
+    const paths = routes.map(r => `${r.method} ${r.path}`);
+    expect(paths).toContain('GET /api/users');
+    expect(paths).toContain('POST /api/users');
+    expect(paths).toContain('DELETE /api/users/:id');
+    expect(paths).toContain('GET /api/search');
+
+    // POST route should have form body fields
+    const postRoute = routes.find(r => r.method === 'POST' && r.path === '/api/users');
+    expect(postRoute?.requestBody).toBeDefined();
+    expect(postRoute!.requestBody!.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('generates valid Express routes from extracted routes', () => {
+    const routes = scanRoutes(SAMPLE_HTML, 'users.html');
+    const gen = new ExpressGenerator();
+    const result = gen.generate(routes, { outputDir: '/out' });
+
+    expect(result.files.length).toBeGreaterThanOrEqual(2);
+
+    // All route files should contain Express Router setup
+    const routeFiles = result.files.filter(f => !f.path.endsWith('index.ts'));
+    for (const file of routeFiles) {
+      expect(file.content).toContain('import { Router');
+      expect(file.content).toContain('const router = Router()');
+      expect(file.content).toContain('export default router');
+    }
+
+    // Index file should import and wire all routers
+    const indexFile = result.files.find(f => f.path.endsWith('index.ts'));
+    expect(indexFile).toBeDefined();
+    expect(indexFile!.content).toContain('router.use(');
+  });
+
+  it('generates valid Hono routes from extracted routes', () => {
+    const routes = scanRoutes(SAMPLE_HTML, 'users.html');
+    const gen = new HonoGenerator();
+    const result = gen.generate(routes, { outputDir: '/out' });
+
+    expect(result.files.length).toBeGreaterThanOrEqual(2);
+
+    const routeFiles = result.files.filter(f => !f.path.endsWith('index.ts'));
+    for (const file of routeFiles) {
+      expect(file.content).toContain("import { Hono } from 'hono'");
+      expect(file.content).toContain('const app = new Hono()');
+      expect(file.content).toContain('export default app');
+    }
+  });
+});

package/src/__tests__/manifest.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect } from 'vitest';
+import { hashRoute, createManifest, extractUserCode, diffRoutes } from '../generators/manifest.js';
+import type { RouteDescriptor } from '../types.js';
+
+function makeRoute(overrides: Partial<RouteDescriptor> = {}): RouteDescriptor {
+  return {
+    path: '/api/users',
+    method: 'GET',
+    responseFormat: 'json',
+    source: { file: 'test.html', kind: 'fetch', raw: 'fetch /api/users' },
+    pathParams: [],
+    handlerName: 'getApiUsers',
+    notes: [],
+    ...overrides,
+  };
+}
+
+describe('hashRoute', () => {
+  it('produces consistent hashes', () => {
+    const route = makeRoute();
+    expect(hashRoute(route)).toBe(hashRoute(route));
+  });
+
+  it('changes hash when route changes', () => {
+    const a = makeRoute({ method: 'GET' });
+    const b = makeRoute({ method: 'POST' });
+    expect(hashRoute(a)).not.toBe(hashRoute(b));
+  });
+});
+
+describe('createManifest', () => {
+  it('creates manifest from routes', () => {
+    const routes = [
+      makeRoute(),
+      makeRoute({ path: '/api/users/:id', handlerName: 'getApiUsersById', pathParams: ['id'] }),
+    ];
+    const manifest = createManifest(routes);
+    expect(manifest.version).toBe(1);
+    expect(Object.keys(manifest.routes)).toHaveLength(2);
+    expect(manifest.routes['GET:/api/users']).toBeDefined();
+    expect(manifest.routes['GET:/api/users/:id']).toBeDefined();
+  });
+});
+
+describe('extractUserCode', () => {
+  it('extracts user code between markers', () => {
+    const content = `
+// @serverbridge-route: GET /api/users
+router.get('/api/users', async (req, res) => {
+  // @serverbridge-user-start
+  const users = await db.query('SELECT * FROM users');
+  res.json(users);
+  // @serverbridge-user-end
+});
+`;
+    const userCode = extractUserCode(content);
+    expect(userCode.size).toBe(1);
+    expect(userCode.get('GET:/api/users')).toContain('db.query');
+  });
+
+  it('ignores TODO stubs', () => {
+    const content = `
+// @serverbridge-route: GET /api/users
+router.get('/api/users', async (req, res) => {
+  // @serverbridge-user-start
+  // TODO: Implement GET /api/users
+  res.json([]);
+  // @serverbridge-user-end
+});
+`;
+    const userCode = extractUserCode(content);
+    expect(userCode.size).toBe(0);
+  });
+
+  it('handles multiple routes in one file', () => {
+    const content = `
+// @serverbridge-route: GET /api/users
+router.get('/api/users', async (req, res) => {
+  // @serverbridge-user-start
+  res.json(await getUsers());
+  // @serverbridge-user-end
+});
+
+// @serverbridge-route: POST /api/users
+router.post('/api/users', async (req, res) => {
+  // @serverbridge-user-start
+  // TODO: Implement POST /api/users
+  res.json({});
+  // @serverbridge-user-end
+});
+`;
+    const userCode = extractUserCode(content);
+    // Only GET has real user code; POST still has TODO
+    expect(userCode.size).toBe(1);
+    expect(userCode.has('GET:/api/users')).toBe(true);
+    expect(userCode.has('POST:/api/users')).toBe(false);
+  });
+});
+
+describe('diffRoutes', () => {
+  it('detects added routes', () => {
+    const newRoutes = [makeRoute()];
+    const diff = diffRoutes(null, newRoutes);
+    expect(diff.added).toHaveLength(1);
+    expect(diff.removed).toHaveLength(0);
+    expect(diff.changed).toHaveLength(0);
+  });
+
+  it('detects removed routes', () => {
+    const oldManifest = createManifest([makeRoute()]);
+    const diff = diffRoutes(oldManifest, []);
+    expect(diff.removed).toHaveLength(1);
+    expect(diff.added).toHaveLength(0);
+  });
+
+  it('detects changed routes', () => {
+    const oldRoute = makeRoute({ responseFormat: 'json' });
+    const oldManifest = createManifest([oldRoute]);
+    const newRoute = makeRoute({ responseFormat: 'html' });
+    const diff = diffRoutes(oldManifest, [newRoute]);
+    expect(diff.changed).toHaveLength(1);
+    expect(diff.unchanged).toHaveLength(0);
+  });
+
+  it('identifies unchanged routes', () => {
+    const route = makeRoute();
+    const oldManifest = createManifest([route]);
+    const diff = diffRoutes(oldManifest, [route]);
+    expect(diff.unchanged).toHaveLength(1);
+    expect(diff.added).toHaveLength(0);
+    expect(diff.changed).toHaveLength(0);
+  });
+});