@objectstack/nextjs 3.2.8 → 3.3.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @objectstack/nextjs@3.2.8 build /home/runner/work/spec/spec/packages/adapters/nextjs
+> @objectstack/nextjs@3.3.0 build /home/runner/work/spec/spec/packages/adapters/nextjs
 > tsup --config ../../../tsup.config.ts
 
 CLI Building entry: src/index.ts
@@ -12,11 +12,11 @@
 CJS Build start
 ESM dist/index.mjs     7.52 KB
 ESM dist/index.mjs.map 16.55 KB
-ESM ⚡️ Build success in 115ms
+ESM ⚡️ Build success in 79ms
 CJS dist/index.js     8.76 KB
 CJS dist/index.js.map 16.60 KB
-CJS ⚡️ Build success in 116ms
+CJS ⚡️ Build success in 79ms
 DTS Build start
-DTS ⚡️ Build success in 13439ms
+DTS ⚡️ Build success in 13754ms
 DTS dist/index.d.mts 2.63 KB
 DTS dist/index.d.ts  2.63 KB

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @objectstack/nextjs
 
+## 3.3.0
+
+### Patch Changes
+
+- @objectstack/runtime@3.3.0
+
+## 3.2.9
+
+### Patch Changes
+
+- @objectstack/runtime@3.2.9
+
 ## 3.2.8
 
 ### Patch Changes

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@objectstack/nextjs",
-  "version": "3.2.8",
+  "version": "3.3.0",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "peerDependencies": {
-    "next": "^16.1.7",
+    "next": "^16.2.1",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
-    "@objectstack/runtime": "^3.2.8"
+    "@objectstack/runtime": "^3.3.0"
   },
   "devDependencies": {
-    "next": "^16.1.7",
+    "next": "^16.2.1",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "typescript": "^5.0.0",
     "vitest": "^4.1.0",
-    "@objectstack/runtime": "3.2.8"
+    "@objectstack/runtime": "3.3.0"
   },
   "scripts": {
     "build": "tsup --config ../../../tsup.config.ts",

package/src/metadata-api.test.ts

@@ -19,6 +19,7 @@ const mockDispatcher = {
   handleMetadata: vi.fn().mockResolvedValue({ handled: true, response: { body: { success: true }, status: 200 } }),
   handleData: vi.fn().mockResolvedValue({ handled: true, response: { body: { records: [] }, status: 200 } }),
   handleStorage: vi.fn().mockResolvedValue({ handled: true, response: { body: {}, status: 200 } }),
+  dispatch: vi.fn().mockResolvedValue({ handled: true, response: { body: { success: true }, status: 200 } }),
 };
 
 vi.mock('@objectstack/runtime', () => {
@@ -106,8 +107,8 @@ describe('Next.js Metadata API Integration Tests', () => {
 
   describe('CRUD Operations', () => {
     describe('GET meta/objects — List all objects', () => {
-      it('dispatches to handleMetadata with correct path', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+      it('dispatches to dispatch with correct path', async () => {
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: {
@@ -125,18 +126,19 @@ describe('Next.js Metadata API Integration Tests', () => {
         const res = await handler(req, { params: { objectstack: ['meta', 'objects'] } });
         expect(res.status).toBe(200);
         expect(res.body.data).toHaveLength(2);
-        expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-          'objects',
-          expect.objectContaining({ request: expect.anything() }),
+        expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
           'GET',
+          '/meta/objects',
           undefined,
+          {},
+          expect.objectContaining({ request: expect.anything() }),
         );
       });
     });
 
     describe('GET meta/objects/account — Get single object', () => {
-      it('dispatches to handleMetadata with item-level path', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+      it('dispatches to dispatch with item-level path', async () => {
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: {
@@ -151,11 +153,12 @@ describe('Next.js Metadata API Integration Tests', () => {
         const res = await handler(req, { params: { objectstack: ['meta', 'objects', 'account'] } });
         expect(res.status).toBe(200);
         expect(res.body.data.name).toBe('account');
-        expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-          'objects/account',
-          expect.objectContaining({ request: expect.anything() }),
+        expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
           'GET',
+          '/meta/objects/account',
           undefined,
+          {},
+          expect.objectContaining({ request: expect.anything() }),
         );
       });
     });
@@ -168,7 +171,7 @@ describe('Next.js Metadata API Integration Tests', () => {
           data: { label: 'Project Task', fields: {} },
         };
 
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: { body: { success: true }, status: 201 },
         });
@@ -176,11 +179,12 @@ describe('Next.js Metadata API Integration Tests', () => {
         const req = makeReq('http://localhost/api/meta/objects', 'POST', body);
         const res = await handler(req, { params: { objectstack: ['meta', 'objects'] } });
         expect(res.status).toBe(201);
-        expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-          'objects',
-          expect.objectContaining({ request: expect.anything() }),
+        expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
           'POST',
+          '/meta/objects',
           body,
+          {},
+          expect.objectContaining({ request: expect.anything() }),
         );
       });
     });
@@ -189,7 +193,7 @@ describe('Next.js Metadata API Integration Tests', () => {
       it('dispatches PUT with JSON body', async () => {
         const body = { label: 'Updated Account' };
 
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: { body: { success: true }, status: 200 },
         });
@@ -197,18 +201,19 @@ describe('Next.js Metadata API Integration Tests', () => {
         const req = makeReq('http://localhost/api/meta/objects/account', 'PUT', body);
         const res = await handler(req, { params: { objectstack: ['meta', 'objects', 'account'] } });
         expect(res.status).toBe(200);
-        expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-          'objects/account',
-          expect.objectContaining({ request: expect.anything() }),
+        expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
           'PUT',
+          '/meta/objects/account',
           body,
+          {},
+          expect.objectContaining({ request: expect.anything() }),
         );
       });
     });
 
     describe('DELETE meta/objects/old_entity — Delete metadata', () => {
-      it('dispatches DELETE to handleMetadata', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+      it('dispatches DELETE to dispatch', async () => {
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: { success: true, data: { type: 'object', name: 'old_entity' } },
@@ -227,33 +232,36 @@ describe('Next.js Metadata API Integration Tests', () => {
       it('dispatches for views', async () => {
         const req = makeReq('http://localhost/api/meta/views');
         await handler(req, { params: { objectstack: ['meta', 'views'] } });
-        expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-          'views',
-          expect.objectContaining({ request: expect.anything() }),
+        expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
           'GET',
+          '/meta/views',
           undefined,
+          {},
+          expect.objectContaining({ request: expect.anything() }),
         );
       });
 
       it('dispatches for flows', async () => {
         const req = makeReq('http://localhost/api/meta/flows');
         await handler(req, { params: { objectstack: ['meta', 'flows'] } });
-        expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-          'flows',
-          expect.objectContaining({ request: expect.anything() }),
+        expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
           'GET',
+          '/meta/flows',
           undefined,
+          {},
+          expect.objectContaining({ request: expect.anything() }),
         );
       });
 
       it('dispatches for agents', async () => {
         const req = makeReq('http://localhost/api/meta/agents');
         await handler(req, { params: { objectstack: ['meta', 'agents'] } });
-        expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-          'agents',
-          expect.objectContaining({ request: expect.anything() }),
+        expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
           'GET',
+          '/meta/agents',
           undefined,
+          {},
+          expect.objectContaining({ request: expect.anything() }),
         );
       });
     });
@@ -273,7 +281,7 @@ describe('Next.js Metadata API Integration Tests', () => {
           pageSize: 25,
         };
 
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: {
@@ -305,7 +313,7 @@ describe('Next.js Metadata API Integration Tests', () => {
   describe('Bulk Operations', () => {
     describe('POST meta/bulk/register — Bulk register', () => {
       it('dispatches bulk register', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: { success: true, data: { total: 2, succeeded: 2, failed: 0 } },
@@ -328,7 +336,7 @@ describe('Next.js Metadata API Integration Tests', () => {
 
     describe('POST meta/bulk/unregister — Bulk unregister', () => {
       it('dispatches bulk unregister', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: { success: true, data: { total: 2, succeeded: 2, failed: 0 } },
@@ -348,7 +356,7 @@ describe('Next.js Metadata API Integration Tests', () => {
 
     describe('Bulk operation with partial failures', () => {
       it('returns error details', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: {
@@ -387,7 +395,7 @@ describe('Next.js Metadata API Integration Tests', () => {
   describe('Overlay / Customization', () => {
     describe('GET meta/objects/account/overlay — Get overlay', () => {
       it('dispatches overlay retrieval', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: {
@@ -413,7 +421,7 @@ describe('Next.js Metadata API Integration Tests', () => {
 
     describe('PUT meta/objects/account/overlay — Save overlay', () => {
       it('dispatches overlay save', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: { body: { success: true }, status: 200 },
         });
@@ -431,7 +439,7 @@ describe('Next.js Metadata API Integration Tests', () => {
 
     describe('GET meta/objects/account/effective — Get effective metadata', () => {
       it('dispatches effective metadata retrieval', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: {
@@ -457,7 +465,7 @@ describe('Next.js Metadata API Integration Tests', () => {
   describe('Import / Export', () => {
     describe('POST meta/export — Export metadata', () => {
       it('dispatches export request', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: { success: true, data: { version: '1.0', objects: {} } },
@@ -474,7 +482,7 @@ describe('Next.js Metadata API Integration Tests', () => {
 
     describe('POST meta/import — Import metadata', () => {
       it('dispatches import request', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: { success: true, data: { total: 3, imported: 3, skipped: 0, failed: 0 } },
@@ -500,7 +508,7 @@ describe('Next.js Metadata API Integration Tests', () => {
   describe('Validation', () => {
     describe('POST meta/validate — Validate metadata', () => {
       it('dispatches validation', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: { success: true, data: { valid: true } },
@@ -515,7 +523,7 @@ describe('Next.js Metadata API Integration Tests', () => {
       });
 
       it('returns errors for invalid metadata', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: {
@@ -544,7 +552,7 @@ describe('Next.js Metadata API Integration Tests', () => {
   describe('Type Registry', () => {
     describe('GET meta/types — List types', () => {
       it('returns all registered types', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: { success: true, data: ['object', 'view', 'flow', 'agent'] },
@@ -561,7 +569,7 @@ describe('Next.js Metadata API Integration Tests', () => {
 
     describe('GET meta/types/object — Get type info', () => {
       it('returns type metadata', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: {
@@ -593,7 +601,7 @@ describe('Next.js Metadata API Integration Tests', () => {
   describe('Dependency Tracking', () => {
     describe('GET meta/objects/account/dependencies — Get dependencies', () => {
       it('returns dependencies', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: {
@@ -619,7 +627,7 @@ describe('Next.js Metadata API Integration Tests', () => {
 
     describe('GET meta/objects/account/dependents — Get dependents', () => {
       it('returns dependents', async () => {
-        mockDispatcher.handleMetadata.mockResolvedValueOnce({
+        mockDispatcher.dispatch.mockResolvedValueOnce({
           handled: true,
           response: {
             body: {
@@ -647,7 +655,7 @@ describe('Next.js Metadata API Integration Tests', () => {
 
   describe('Error Handling', () => {
     it('returns 404 when metadata not found', async () => {
-      mockDispatcher.handleMetadata.mockResolvedValueOnce({ handled: false });
+      mockDispatcher.dispatch.mockResolvedValueOnce({ handled: false });
 
       const req = makeReq('http://localhost/api/meta/objects/nonexistent');
       const res = await handler(req, { params: { objectstack: ['meta', 'objects', 'nonexistent'] } });
@@ -655,7 +663,7 @@ describe('Next.js Metadata API Integration Tests', () => {
     });
 
     it('returns 500 on dispatcher exception', async () => {
-      mockDispatcher.handleMetadata.mockRejectedValueOnce(new Error('Internal error'));
+      mockDispatcher.dispatch.mockRejectedValueOnce(new Error('Internal error'));
 
       const req = makeReq('http://localhost/api/meta/objects');
       const res = await handler(req, { params: { objectstack: ['meta', 'objects'] } });
@@ -664,7 +672,7 @@ describe('Next.js Metadata API Integration Tests', () => {
     });
 
     it('returns custom status code from error', async () => {
-      mockDispatcher.handleMetadata.mockRejectedValueOnce(
+      mockDispatcher.dispatch.mockRejectedValueOnce(
         Object.assign(new Error('Forbidden'), { statusCode: 403 }),
       );
 
@@ -682,11 +690,12 @@ describe('Next.js Metadata API Integration Tests', () => {
     it('correctly joins nested segments', async () => {
       const req = makeReq('http://localhost/api/meta/objects/account/fields/name');
       await handler(req, { params: { objectstack: ['meta', 'objects', 'account', 'fields', 'name'] } });
-      expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-        'objects/account/fields/name',
-        expect.any(Object),
+      expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
         'GET',
+        '/meta/objects/account/fields/name',
         undefined,
+        {},
+        expect.objectContaining({ request: expect.anything() }),
       );
     });
 
@@ -694,11 +703,12 @@ describe('Next.js Metadata API Integration Tests', () => {
       const req = makeReq('http://localhost/api/meta');
       // With just ['meta'], subPath becomes empty after slice(1)
       await handler(req, { params: { objectstack: ['meta'] } });
-      expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-        '',
-        expect.any(Object),
+      expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
         'GET',
+        '/meta',
         undefined,
+        {},
+        expect.objectContaining({ request: expect.anything() }),
       );
     });
   });

package/src/nextjs.test.ts

@@ -10,6 +10,7 @@ const mockDispatcher = {
   handleMetadata: vi.fn().mockResolvedValue({ handled: true, response: { body: { objects: [] }, status: 200 } }),
   handleData: vi.fn().mockResolvedValue({ handled: true, response: { body: { records: [] }, status: 200 } }),
   handleStorage: vi.fn().mockResolvedValue({ handled: true, response: { body: {}, status: 200 } }),
+  dispatch: vi.fn().mockResolvedValue({ handled: true, response: { body: { success: true }, status: 200 } }),
 };
 
 vi.mock('@objectstack/runtime', () => {
@@ -272,17 +273,17 @@ describe('createRouteHandler', () => {
   });
 
   describe('Metadata Endpoint', () => {
-    it('GET meta/objects calls handleMetadata', async () => {
+    it('GET meta/objects delegates to dispatch()', async () => {
       const handler = createRouteHandler({ kernel: mockKernel });
       const req = makeReq('http://localhost/api/meta/objects', 'GET');
       const res = await handler(req, { params: { objectstack: ['meta', 'objects'] } });
       expect(res.status).toBe(200);
-      expect(res.body).toEqual({ objects: [] });
-      expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-        'objects',
-        expect.objectContaining({ request: expect.anything() }),
+      expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
         'GET',
+        '/meta/objects',
         undefined,
+        expect.any(Object),
+        expect.objectContaining({ request: expect.anything() }),
       );
     });
 
@@ -292,11 +293,12 @@ describe('createRouteHandler', () => {
       const req = makeReq('http://localhost/api/meta/objects', 'PUT', body);
       const res = await handler(req, { params: { objectstack: ['meta', 'objects'] } });
       expect(res.status).toBe(200);
-      expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-        'objects',
-        expect.objectContaining({ request: expect.anything() }),
+      expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
         'PUT',
+        '/meta/objects',
         body,
+        expect.any(Object),
+        expect.objectContaining({ request: expect.anything() }),
       );
     });
 
@@ -306,26 +308,26 @@ describe('createRouteHandler', () => {
       const req = makeReq('http://localhost/api/meta/objects', 'POST', body);
       const res = await handler(req, { params: { objectstack: ['meta', 'objects'] } });
       expect(res.status).toBe(200);
-      expect(mockDispatcher.handleMetadata).toHaveBeenCalledWith(
-        'objects',
-        expect.objectContaining({ request: expect.anything() }),
+      expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
         'POST',
+        '/meta/objects',
         body,
+        expect.any(Object),
+        expect.objectContaining({ request: expect.anything() }),
       );
     });
   });
 
   describe('Data Endpoint', () => {
-    it('GET data/account calls handleData', async () => {
+    it('GET data/account delegates to dispatch()', async () => {
       const handler = createRouteHandler({ kernel: mockKernel });
       const req = makeReq('http://localhost/api/data/account', 'GET');
       const res = await handler(req, { params: { objectstack: ['data', 'account'] } });
       expect(res.status).toBe(200);
-      expect(res.body).toEqual({ records: [] });
-      expect(mockDispatcher.handleData).toHaveBeenCalledWith(
-        'account',
+      expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
         'GET',
-        {},
+        '/data/account',
+        undefined,
         expect.any(Object),
         expect.objectContaining({ request: expect.anything() }),
       );
@@ -337,9 +339,9 @@ describe('createRouteHandler', () => {
       const req = makeReq('http://localhost/api/data/account', 'POST', body);
       const res = await handler(req, { params: { objectstack: ['data', 'account'] } });
       expect(res.status).toBe(200);
-      expect(mockDispatcher.handleData).toHaveBeenCalledWith(
-        'account',
+      expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
         'POST',
+        '/data/account',
         body,
         expect.any(Object),
         expect.objectContaining({ request: expect.anything() }),
@@ -352,9 +354,9 @@ describe('createRouteHandler', () => {
       const req = makeReq('http://localhost/api/data/account', 'PATCH', body);
       const res = await handler(req, { params: { objectstack: ['data', 'account'] } });
       expect(res.status).toBe(200);
-      expect(mockDispatcher.handleData).toHaveBeenCalledWith(
-        'account',
+      expect(mockDispatcher.dispatch).toHaveBeenCalledWith(
         'PATCH',
+        '/data/account',
         body,
         expect.any(Object),
         expect.objectContaining({ request: expect.anything() }),
@@ -362,7 +364,7 @@ describe('createRouteHandler', () => {
     });
 
     it('returns 404 when result is not handled', async () => {
-      mockDispatcher.handleData.mockResolvedValueOnce({ handled: false });
+      mockDispatcher.dispatch.mockResolvedValueOnce({ handled: false });
       const handler = createRouteHandler({ kernel: mockKernel });
       const req = makeReq('http://localhost/api/data/missing', 'GET');
       const res = await handler(req, { params: { objectstack: ['data', 'missing'] } });
@@ -401,6 +403,7 @@ describe('createRouteHandler', () => {
 
   describe('Error Handling', () => {
     it('returns 404 for unknown route segments', async () => {
+      mockDispatcher.dispatch.mockResolvedValueOnce({ handled: false });
       const handler = createRouteHandler({ kernel: mockKernel });
       const req = makeReq('http://localhost/api/unknown/path', 'GET');
       const res = await handler(req, { params: { objectstack: ['unknown', 'path'] } });
@@ -410,7 +413,7 @@ describe('createRouteHandler', () => {
     });
 
     it('returns 500 with default message on generic error', async () => {
-      mockDispatcher.handleData.mockRejectedValueOnce(new Error());
+      mockDispatcher.dispatch.mockRejectedValueOnce(new Error());
       const handler = createRouteHandler({ kernel: mockKernel });
       const req = makeReq('http://localhost/api/data/account', 'GET');
       const res = await handler(req, { params: { objectstack: ['data', 'account'] } });
@@ -419,7 +422,7 @@ describe('createRouteHandler', () => {
     });
 
     it('uses custom statusCode from error', async () => {
-      mockDispatcher.handleData.mockRejectedValueOnce(
+      mockDispatcher.dispatch.mockRejectedValueOnce(
         Object.assign(new Error('Forbidden'), { statusCode: 403 }),
       );
       const handler = createRouteHandler({ kernel: mockKernel });
@@ -432,7 +435,7 @@ describe('createRouteHandler', () => {
 
   describe('toResponse', () => {
     it('handles redirect result', async () => {
-      mockDispatcher.handleData.mockResolvedValueOnce({
+      mockDispatcher.dispatch.mockResolvedValueOnce({
         handled: true,
         result: { type: 'redirect', url: 'https://example.com' },
       });
@@ -444,7 +447,7 @@ describe('createRouteHandler', () => {
 
     it('handles stream result', async () => {
       const stream = 'mock-stream';
-      mockDispatcher.handleData.mockResolvedValueOnce({
+      mockDispatcher.dispatch.mockResolvedValueOnce({
         handled: true,
         result: { type: 'stream', stream, headers: { 'Content-Type': 'text/plain' } },
       });
@@ -457,7 +460,7 @@ describe('createRouteHandler', () => {
 
     it('returns raw result when handled but no response/redirect/stream', async () => {
       const rawResult = { type: 'custom', data: 'test' };
-      mockDispatcher.handleData.mockResolvedValueOnce({
+      mockDispatcher.dispatch.mockResolvedValueOnce({
         handled: true,
         result: rawResult,
       });