@objectstack/runtime 3.2.0 → 3.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/runtime",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "license": "Apache-2.0",
   "description": "ObjectStack Core Runtime & Query Engine",
   "type": "module",
@@ -15,10 +15,10 @@
   },
   "dependencies": {
     "zod": "^4.3.6",
-    "@objectstack/core": "3.2.0",
-    "@objectstack/rest": "3.2.0",
-    "@objectstack/spec": "3.2.0",
-    "@objectstack/types": "3.2.0"
+    "@objectstack/core": "3.2.1",
+    "@objectstack/spec": "3.2.1",
+    "@objectstack/types": "3.2.1",
+    "@objectstack/rest": "3.2.1"
   },
   "devDependencies": {
     "typescript": "^5.0.0",

package/src/http-dispatcher.test.ts

@@ -305,6 +305,59 @@ describe('HttpDispatcher', () => {
             });
         });
 
+        describe('handleAuth mock fallback (MSW/test mode)', () => {
+            beforeEach(() => {
+                // No auth service, no broker — simulates MSW/mock mode
+                (kernel as any).getService = vi.fn().mockResolvedValue(null);
+                (kernel as any).services = new Map();
+                (kernel as any).broker = null;
+            });
+
+            it('should mock sign-up/email endpoint', async () => {
+                const result = await dispatcher.handleAuth('/sign-up/email', 'POST', { email: 'test@example.com', name: 'Test' }, { request: {} });
+                expect(result.handled).toBe(true);
+                expect(result.response?.status).toBe(200);
+                expect(result.response?.body.user).toBeDefined();
+                expect(result.response?.body.user.email).toBe('test@example.com');
+                expect(result.response?.body.session).toBeDefined();
+            });
+
+            it('should mock sign-in/email endpoint', async () => {
+                const result = await dispatcher.handleAuth('/sign-in/email', 'POST', { email: 'test@example.com' }, { request: {} });
+                expect(result.handled).toBe(true);
+                expect(result.response?.status).toBe(200);
+                expect(result.response?.body.user).toBeDefined();
+                expect(result.response?.body.session).toBeDefined();
+            });
+
+            it('should mock get-session endpoint', async () => {
+                const result = await dispatcher.handleAuth('/get-session', 'GET', {}, { request: {} });
+                expect(result.handled).toBe(true);
+                expect(result.response?.status).toBe(200);
+                expect(result.response?.body).toEqual({ session: null, user: null });
+            });
+
+            it('should mock sign-out endpoint', async () => {
+                const result = await dispatcher.handleAuth('/sign-out', 'POST', {}, { request: {} });
+                expect(result.handled).toBe(true);
+                expect(result.response?.status).toBe(200);
+                expect(result.response?.body).toEqual({ success: true });
+            });
+
+            it('should mock login fallback when broker unavailable', async () => {
+                const result = await dispatcher.handleAuth('/login', 'POST', { email: 'test@example.com' }, { request: {} });
+                expect(result.handled).toBe(true);
+                expect(result.response?.status).toBe(200);
+                expect(result.response?.body.user).toBeDefined();
+                expect(result.response?.body.session).toBeDefined();
+            });
+
+            it('should return unhandled for unknown auth path in mock mode', async () => {
+                const result = await dispatcher.handleAuth('/unknown', 'GET', {}, { request: {} });
+                expect(result.handled).toBe(false);
+            });
+        });
+
         describe('handleStorage with async service', () => {
             it('should resolve storage service from Promise', async () => {
                 const mockStorage = {
@@ -439,6 +492,108 @@ describe('HttpDispatcher', () => {
         });
     });
 
+    // ═══════════════════════════════════════════════════════════════
+    // getServiceAsync preferred path
+    // ═══════════════════════════════════════════════════════════════
+
+    describe('getServiceAsync preferred path', () => {
+        it('should prefer getServiceAsync over getService for analytics', async () => {
+            const asyncAnalytics = {
+                query: vi.fn().mockResolvedValue({ rows: [1], total: 1 }),
+            };
+            (kernel as any).getServiceAsync = vi.fn().mockResolvedValue(asyncAnalytics);
+            (kernel as any).getService = vi.fn().mockImplementation(() => {
+                throw new Error("Service 'analytics' is async - use await");
+            });
+
+            const result = await dispatcher.handleAnalytics('query', 'POST', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(asyncAnalytics.query).toHaveBeenCalled();
+            expect((kernel as any).getServiceAsync).toHaveBeenCalledWith('analytics');
+        });
+
+        it('should prefer getServiceAsync over getService for auth', async () => {
+            const asyncAuth = {
+                handler: vi.fn().mockResolvedValue({ user: { id: '1' } }),
+            };
+            (kernel as any).getServiceAsync = vi.fn().mockResolvedValue(asyncAuth);
+            (kernel as any).getService = vi.fn().mockImplementation(() => {
+                throw new Error("Service 'auth' is async - use await");
+            });
+
+            const result = await dispatcher.handleAuth('', 'POST', {}, { request: {}, response: {} });
+            expect(result.handled).toBe(true);
+            expect(asyncAuth.handler).toHaveBeenCalled();
+            expect((kernel as any).getServiceAsync).toHaveBeenCalledWith('auth');
+        });
+
+        it('should prefer getServiceAsync over getService for automation', async () => {
+            const asyncAuto = {
+                listFlows: vi.fn().mockResolvedValue(['flow_async']),
+            };
+            (kernel as any).getServiceAsync = vi.fn().mockResolvedValue(asyncAuto);
+
+            const result = await dispatcher.handleAutomation('', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.body?.data?.flows).toEqual(['flow_async']);
+            expect((kernel as any).getServiceAsync).toHaveBeenCalledWith('automation');
+        });
+
+        it('should prefer getServiceAsync over getService for file-storage', async () => {
+            const asyncStorage = {
+                upload: vi.fn().mockResolvedValue({ id: 'file_1', url: '/files/1' }),
+            };
+            (kernel as any).getServiceAsync = vi.fn().mockResolvedValue(asyncStorage);
+
+            const result = await dispatcher.handleStorage('/upload', 'POST', { name: 'test.txt' }, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect((kernel as any).getServiceAsync).toHaveBeenCalledWith('file-storage');
+        });
+
+        it('should resolve protocol service via getServiceAsync for handleMetadata', async () => {
+            const asyncProtocol = {
+                saveMetaItem: vi.fn().mockResolvedValue({ success: true }),
+            };
+            (kernel as any).getServiceAsync = vi.fn().mockImplementation((name: string) => {
+                if (name === 'protocol') return Promise.resolve(asyncProtocol);
+                return Promise.resolve(null);
+            });
+            // Remove context.getService to ensure getServiceAsync is used
+            (kernel as any).context = {};
+
+            const result = await dispatcher.handleMetadata('/objects/my_obj', { request: {} }, 'PUT', { label: 'Test' });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(asyncProtocol.saveMetaItem).toHaveBeenCalled();
+            expect((kernel as any).getServiceAsync).toHaveBeenCalledWith('protocol');
+        });
+
+        it('should fall through when getServiceAsync returns null', async () => {
+            (kernel as any).getServiceAsync = vi.fn().mockResolvedValue(null);
+            const syncAnalytics = {
+                query: vi.fn().mockResolvedValue({ rows: [], total: 0 }),
+            };
+            (kernel as any).services = new Map([['analytics', syncAnalytics]]);
+
+            const result = await dispatcher.handleAnalytics('query', 'POST', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(syncAnalytics.query).toHaveBeenCalled();
+        });
+
+        it('should fall through when getServiceAsync throws', async () => {
+            (kernel as any).getServiceAsync = vi.fn().mockRejectedValue(new Error('not found'));
+            const syncAnalytics = {
+                query: vi.fn().mockResolvedValue({ rows: [], total: 0 }),
+            };
+            (kernel as any).services = new Map([['analytics', syncAnalytics]]);
+
+            const result = await dispatcher.handleAnalytics('query', 'POST', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(syncAnalytics.query).toHaveBeenCalled();
+        });
+    });
+
     // ═══════════════════════════════════════════════════════════════
     // handleData — expand/populate parameter flow
     // ═══════════════════════════════════════════════════════════════
@@ -684,4 +839,119 @@ describe('HttpDispatcher', () => {
             );
         });
     });
+
+    // ═══════════════════════════════════════════════════════════════
+    // handleI18n — i18n route dispatching
+    // ═══════════════════════════════════════════════════════════════
+
+    describe('handleI18n', () => {
+        let mockI18nService: any;
+
+        beforeEach(() => {
+            mockI18nService = {
+                getLocales: vi.fn().mockReturnValue(['en', 'zh-CN', 'ja']),
+                getTranslations: vi.fn().mockReturnValue({ 'o.account.label': '客户', 'o.account.fields.name': '名称' }),
+                getFieldLabels: vi.fn().mockReturnValue({ name: '名称', industry: '行业' }),
+            };
+
+            (kernel as any).getService = vi.fn().mockImplementation((name: string) => {
+                if (name === 'i18n') return mockI18nService;
+                return null;
+            });
+        });
+
+        it('should list locales via GET /locales', async () => {
+            const result = await dispatcher.handleI18n('/locales', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.locales).toEqual(['en', 'zh-CN', 'ja']);
+            expect(mockI18nService.getLocales).toHaveBeenCalled();
+        });
+
+        it('should get translations via GET /translations/:locale', async () => {
+            const result = await dispatcher.handleI18n('/translations/zh-CN', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.locale).toBe('zh-CN');
+            expect(result.response?.body?.data?.translations).toEqual({ 'o.account.label': '客户', 'o.account.fields.name': '名称' });
+            expect(mockI18nService.getTranslations).toHaveBeenCalledWith('zh-CN');
+        });
+
+        it('should get translations via GET /translations?locale=zh-CN (query param)', async () => {
+            const result = await dispatcher.handleI18n('/translations', 'GET', { locale: 'zh-CN' }, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.locale).toBe('zh-CN');
+            expect(mockI18nService.getTranslations).toHaveBeenCalledWith('zh-CN');
+        });
+
+        it('should return 400 when translations requested without locale', async () => {
+            const result = await dispatcher.handleI18n('/translations', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(400);
+            expect(result.response?.body?.error?.message).toBe('Missing locale parameter');
+        });
+
+        it('should get field labels via GET /labels/:object/:locale', async () => {
+            const result = await dispatcher.handleI18n('/labels/account/zh-CN', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.object).toBe('account');
+            expect(result.response?.body?.data?.locale).toBe('zh-CN');
+            expect(result.response?.body?.data?.labels).toEqual({ name: '名称', industry: '行业' });
+            expect(mockI18nService.getFieldLabels).toHaveBeenCalledWith('account', 'zh-CN');
+        });
+
+        it('should get field labels via GET /labels/:object?locale=zh-CN (query param)', async () => {
+            const result = await dispatcher.handleI18n('/labels/account', 'GET', { locale: 'zh-CN' }, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.object).toBe('account');
+            expect(mockI18nService.getFieldLabels).toHaveBeenCalledWith('account', 'zh-CN');
+        });
+
+        it('should return 400 when labels requested without locale', async () => {
+            const result = await dispatcher.handleI18n('/labels/account', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(400);
+            expect(result.response?.body?.error?.message).toBe('Missing locale parameter');
+        });
+
+        it('should fallback to deriving labels from translations when getFieldLabels is missing', async () => {
+            delete mockI18nService.getFieldLabels;
+            mockI18nService.getTranslations.mockReturnValue({
+                'o.contact.fields.first_name': 'First Name',
+                'o.contact.fields.email': 'Email',
+                'o.contact.label': 'Contact',
+            });
+
+            const result = await dispatcher.handleI18n('/labels/contact/en', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.labels).toEqual({
+                first_name: 'First Name',
+                email: 'Email',
+            });
+        });
+
+        it('should return 501 when i18n service is not available', async () => {
+            (kernel as any).getService = vi.fn().mockResolvedValue(null);
+            (kernel as any).services = new Map();
+
+            const result = await dispatcher.handleI18n('/locales', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(501);
+        });
+
+        it('should return unhandled for non-GET methods', async () => {
+            const result = await dispatcher.handleI18n('/locales', 'POST', {}, { request: {} });
+            expect(result.handled).toBe(false);
+        });
+
+        it('should dispatch /i18n routes via dispatch()', async () => {
+            const result = await dispatcher.dispatch('GET', '/i18n/locales', undefined, {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.body?.data?.locales).toEqual(['en', 'zh-CN', 'ja']);
+        });
+    });
 });

package/src/http-dispatcher.ts

@@ -3,6 +3,18 @@
 import { ObjectKernel, getEnv } from '@objectstack/core';
 import { CoreServiceName } from '@objectstack/spec/system';
 
+/** Browser-safe UUID generator — prefers Web Crypto, falls back to RFC 4122 v4 */
+function randomUUID(): string {
+    if (globalThis.crypto && typeof globalThis.crypto.randomUUID === 'function') {
+        return globalThis.crypto.randomUUID();
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+
 export interface HttpProtocolContext {
     request: any;
     response?: any;
@@ -179,12 +191,80 @@ export class HttpDispatcher {
             return { handled: true, result: response };
         }
 
-        // 2. Legacy Login
+        // 2. Legacy Login via broker
         const normalizedPath = path.replace(/^\/+/, '');
         if (normalizedPath === 'login' && method.toUpperCase() === 'POST') {
-             const broker = this.ensureBroker();
-             const data = await broker.call('auth.login', body, { request: context.request });
-             return { handled: true, response: { status: 200, body: data } };
+            try {
+                const broker = this.ensureBroker();
+                const data = await broker.call('auth.login', body, { request: context.request });
+                return { handled: true, response: { status: 200, body: data } };
+            } catch (error: any) {
+                // Only fall through to mock when the broker is truly unavailable
+                // (ensureBroker throws statusCode 500 when kernel.broker is null)
+                const statusCode = error?.statusCode ?? error?.status;
+                if (statusCode !== 500 || !error?.message?.includes('Broker not available')) {
+                    throw error;
+                }
+            }
+        }
+
+        // 3. Mock fallback for MSW/test environments when no auth service is registered
+        return this.mockAuthFallback(normalizedPath, method, body);
+    }
+
+    /**
+     * Provides mock auth responses for core better-auth endpoints when
+     * AuthPlugin is not loaded (e.g. MSW/browser-only environments).
+     * This ensures registration/sign-in flows do not 404 in mock mode.
+     */
+    private mockAuthFallback(path: string, method: string, body: any): HttpDispatcherResult {
+        const m = method.toUpperCase();
+        const MOCK_SESSION_EXPIRY_MS = 86_400_000; // 24 hours
+
+        // POST sign-up/email
+        if ((path === 'sign-up/email' || path === 'register') && m === 'POST') {
+            const id = `mock_${randomUUID()}`;
+            return {
+                handled: true,
+                response: {
+                    status: 200,
+                    body: {
+                        user: { id, name: body?.name || 'Mock User', email: body?.email || 'mock@test.local', emailVerified: false, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString() },
+                        session: { id: `session_${id}`, userId: id, token: `mock_token_${id}`, expiresAt: new Date(Date.now() + MOCK_SESSION_EXPIRY_MS).toISOString() },
+                    },
+                },
+            };
+        }
+
+        // POST sign-in/email or login
+        if ((path === 'sign-in/email' || path === 'login') && m === 'POST') {
+            const id = `mock_${randomUUID()}`;
+            return {
+                handled: true,
+                response: {
+                    status: 200,
+                    body: {
+                        user: { id, name: 'Mock User', email: body?.email || 'mock@test.local', emailVerified: true, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString() },
+                        session: { id: `session_${id}`, userId: id, token: `mock_token_${id}`, expiresAt: new Date(Date.now() + MOCK_SESSION_EXPIRY_MS).toISOString() },
+                    },
+                },
+            };
+        }
+
+        // GET get-session
+        if (path === 'get-session' && m === 'GET') {
+            return {
+                handled: true,
+                response: { status: 200, body: { session: null, user: null } },
+            };
+        }
+
+        // POST sign-out
+        if (path === 'sign-out' && m === 'POST') {
+            return {
+                handled: true,
+                response: { status: 200, body: { success: true } },
+            };
         }
 
         return { handled: false };
@@ -202,7 +282,7 @@ export class HttpDispatcher {
         // GET /metadata/types
         if (parts[0] === 'types') {
             // Try protocol service for dynamic types
-            const protocol = this.kernel?.context?.getService ? await this.kernel.context.getService('protocol') : null;
+            const protocol = await this.resolveService('protocol');
             if (protocol && typeof protocol.getMetaTypes === 'function') {
                 const result = await protocol.getMetaTypes({});
                 return { handled: true, response: this.success(result) };
@@ -242,7 +322,7 @@ export class HttpDispatcher {
             // PUT /metadata/:type/:name (Save)
             if (method === 'PUT' && body) {
                 // Try to get the protocol service directly
-                const protocol = this.kernel?.context?.getService ? await this.kernel.context.getService('protocol') : null;
+                const protocol = await this.resolveService('protocol');
                 
                 if (protocol && typeof protocol.saveMetaItem === 'function') {
                     try {
@@ -275,7 +355,7 @@ export class HttpDispatcher {
                 const singularType = type.endsWith('s') ? type.slice(0, -1) : type;
                 
                 // Try Protocol Service First (Preferred)
-                const protocol = this.kernel?.context?.getService ? await this.kernel.context.getService('protocol') : null;
+                const protocol = await this.resolveService('protocol');
                 if (protocol && typeof protocol.getMetaItem === 'function') {
                      try {
                         const data = await protocol.getMetaItem({ type: singularType, name });
@@ -304,7 +384,7 @@ export class HttpDispatcher {
             const packageId = query?.package || undefined;
             
             // Try protocol service first for any type
-            const protocol = this.kernel?.context?.getService ? await this.kernel.context.getService('protocol') : null;
+            const protocol = await this.resolveService('protocol');
             if (protocol && typeof protocol.getMetaItems === 'function') {
                 try {
                     const data = await protocol.getMetaItems({ type: typeOrName, packageId });
@@ -343,7 +423,7 @@ export class HttpDispatcher {
         // GET /metadata — return available metadata types
         if (parts.length === 0) {
             // Try protocol service for dynamic types
-            const protocol = this.kernel?.context?.getService ? await this.kernel.context.getService('protocol') : null;
+            const protocol = await this.resolveService('protocol');
             if (protocol && typeof protocol.getMetaTypes === 'function') {
                 const result = await protocol.getMetaTypes({});
                 return { handled: true, response: this.success(result) };
@@ -475,6 +555,64 @@ export class HttpDispatcher {
         return { handled: false };
     }
 
+    /**
+     * Handles i18n requests
+     * path: sub-path after /i18n/
+     *
+     * Routes:
+     *   GET /locales                    → getLocales
+     *   GET /translations/:locale       → getTranslations (locale from path)
+     *   GET /translations?locale=xx     → getTranslations (locale from query)
+     *   GET /labels/:object/:locale     → getFieldLabels  (both from path)
+     *   GET /labels/:object?locale=xx   → getFieldLabels  (locale from query)
+     */
+    async handleI18n(path: string, method: string, query: any, _context: HttpProtocolContext): Promise<HttpDispatcherResult> {
+        const i18nService = await this.getService(CoreServiceName.enum.i18n);
+        if (!i18nService) return { handled: true, response: this.error('i18n service not available', 501) };
+
+        const m = method.toUpperCase();
+        const parts = path.replace(/^\/+/, '').split('/').filter(Boolean);
+
+        if (m !== 'GET') return { handled: false };
+
+        // GET /i18n/locales
+        if (parts[0] === 'locales' && parts.length === 1) {
+            const locales = i18nService.getLocales();
+            return { handled: true, response: this.success({ locales }) };
+        }
+
+        // GET /i18n/translations/:locale  OR  /i18n/translations?locale=xx
+        if (parts[0] === 'translations') {
+            const locale = parts[1] ? decodeURIComponent(parts[1]) : query?.locale;
+            if (!locale) return { handled: true, response: this.error('Missing locale parameter', 400) };
+            const translations = i18nService.getTranslations(locale);
+            return { handled: true, response: this.success({ locale, translations }) };
+        }
+
+        // GET /i18n/labels/:object/:locale  OR  /i18n/labels/:object?locale=xx
+        if (parts[0] === 'labels' && parts.length >= 2) {
+            const objectName = decodeURIComponent(parts[1]);
+            const locale = parts[2] ? decodeURIComponent(parts[2]) : query?.locale;
+            if (!locale) return { handled: true, response: this.error('Missing locale parameter', 400) };
+            if (typeof i18nService.getFieldLabels === 'function') {
+                const labels = i18nService.getFieldLabels(objectName, locale);
+                return { handled: true, response: this.success({ object: objectName, locale, labels }) };
+            }
+            // Fallback: derive field labels from full translation bundle
+            const translations = i18nService.getTranslations(locale);
+            const prefix = `o.${objectName}.fields.`;
+            const labels: Record<string, string> = {};
+            for (const [key, value] of Object.entries(translations)) {
+                if (key.startsWith(prefix)) {
+                    labels[key.substring(prefix.length)] = value as string;
+                }
+            }
+            return { handled: true, response: this.success({ object: objectName, locale, labels }) };
+        }
+
+        return { handled: false };
+    }
+
     /**
      * Handles Package Management requests
      * 
@@ -708,7 +846,7 @@ export class HttpDispatcher {
             // Support both path param /view/obj/list AND query param /view/obj?type=list
             const type = parts[2] || query?.type || 'list';
 
-            const protocol = this.kernel?.context?.getService ? await this.kernel.context.getService('protocol') : null;
+            const protocol = await this.resolveService('protocol');
             
             if (protocol && typeof protocol.getUiView === 'function') {
                 try {
@@ -852,35 +990,54 @@ export class HttpDispatcher {
     }
 
     private async getService(name: CoreServiceName) {
-        if (typeof this.kernel.getService === 'function') {
-            return await this.kernel.getService(name);
-        }
-        const services = this.getServicesMap();
-        return services[name];
+        return this.resolveService(name);
     }
 
     /**
-     * Get the ObjectQL service which provides access to SchemaRegistry.
-     * Tries multiple access patterns since kernel structure varies.
+     * Resolve any service by name, supporting async factories.
+     * Fallback chain: getServiceAsync → getService (sync) → context.getService → services map.
+     * Only returns when a non-null service is found; otherwise falls through to the next step.
      */
-    private async getObjectQLService(): Promise<any> {
-        // 1. Try via kernel.getService
+    private async resolveService(name: string) {
+        // Prefer async resolution to support factory-based services (e.g. auth, analytics, protocol)
+        if (typeof this.kernel.getServiceAsync === 'function') {
+            try {
+                const svc = await this.kernel.getServiceAsync(name);
+                if (svc != null) return svc;
+            } catch {
+                // Service not registered or async resolution failed — fall through
+            }
+        }
         if (typeof this.kernel.getService === 'function') {
             try {
-                const svc = await this.kernel.getService('objectql');
-                if (svc?.registry) return svc;
-            } catch { /* ignore */ }
+                const svc = await this.kernel.getService(name);
+                if (svc != null) return svc;
+            } catch {
+                // Service not registered or sync resolution threw "is async" — fall through
+            }
         }
-        // 2. Try via kernel context
         if (this.kernel?.context?.getService) {
             try {
-                const svc = await this.kernel.context.getService('objectql');
-                if (svc?.registry) return svc;
-            } catch { /* ignore */ }
+                const svc = await this.kernel.context.getService(name);
+                if (svc != null) return svc;
+            } catch {
+                // Service not registered — fall through
+            }
         }
-        // 3. Try via services map
         const services = this.getServicesMap();
-        if (services['objectql']?.registry) return services['objectql'];
+        return services[name];
+    }
+
+    /**
+     * Get the ObjectQL service which provides access to SchemaRegistry.
+     * Tries multiple access patterns since kernel structure varies.
+     */
+    private async getObjectQLService(): Promise<any> {
+        // 1. Try via resolveService (handles async factories, sync, context, and map)
+        try {
+            const svc = await this.resolveService('objectql');
+            if (svc?.registry) return svc;
+        } catch { /* service not available */ }
         return null;
     }
 
@@ -944,6 +1101,10 @@ export class HttpDispatcher {
              return this.handlePackages(cleanPath.substring(9), method, body, query, context);
         }
 
+        if (cleanPath.startsWith('/i18n')) {
+             return this.handleI18n(cleanPath.substring(5), method, query, context);
+        }
+
         // OpenAPI Specification
         if (cleanPath === '/openapi.json' && method === 'GET') {
              const broker = this.ensureBroker();