proteum 2.1.9-8 → 2.2.0

package/client/services/router/index.tsx

@@ -28,7 +28,7 @@ import type { TRegisterPageArgs, TSsrUnresolvedRoute } from '@common/router/cont
 import { getLayout } from '@common/router/layouts';
 import { getRegisterPageArgs, buildRegex } from '@common/router/register';
 import { TFetcherList } from '@common/router/request/api';
-import type { TFrontRenderer, TPageSetup } from '@common/router/response/page';
+import type { TFrontRenderer, TPageDataProvider } from '@common/router/response/page';
 
 import App from '@client/app/component';
 import type ClientApplication from '@client/app';
@@ -241,32 +241,15 @@ export default class ClientRouter<
         return currentRoute;
     }
 
-    public page<TProvidedData extends {} = {}>(
-        path: string,
-        renderer: TFrontRenderer<TProvidedData>,
-    ): TClientPageRoute<this>;
-
-    public page<TProvidedData extends {} = {}>(
-        path: string,
-        setup: TPageSetup<TProvidedData>,
-        renderer: TFrontRenderer<TProvidedData>,
-    ): TClientPageRoute<this>;
-
-    public page<TProvidedData extends {} = {}>(
-        path: string,
-        options: Partial<TRouteOptions>,
-        renderer: TFrontRenderer<TProvidedData>,
-    ): TClientPageRoute<this>;
-
     public page<TProvidedData extends {} = {}>(
         path: string,
         options: Partial<TRouteOptions>,
-        setup: TPageSetup<TProvidedData>,
+        data: TPageDataProvider<TProvidedData> | null,
         renderer: TFrontRenderer<TProvidedData>,
     ): TClientPageRoute<this>;
 
     public page(...args: TRegisterPageArgs<any, TRouteOptions>): TClientPageRoute<this> {
-        const { path, options, setup, renderer, layout } = getRegisterPageArgs(...args);
+        const { path, options, data, renderer, layout } = getRegisterPageArgs(...args);
 
         // Page ids are injected by the generated route wrapper modules.
         const id = options.id;
@@ -279,7 +262,8 @@ export default class ClientRouter<
             path,
             regex,
             keys,
-            options: { ...defaultOptions, setup, ...options },
+            data,
+            options: { ...defaultOptions, ...options },
             controller: (context) => new ClientPage(route, renderer, context as any, layout),
         };
 
@@ -406,7 +390,7 @@ export default class ClientRouter<
 
         const response = await this.createResponse(route, request, apiData);
 
-        ReactDOM.hydrate(<App context={response.context as AppPropsContext} />, document.body, () => {
+        ReactDOM.hydrate(<App context={response.context as unknown as AppPropsContext} />, document.body, () => {
             console.log(`Render complete`);
             withProfiler((runtime) => runtime.markInitialHydrated({ chunkId: response.chunkId, title: response.title }));
 

package/common/dev/console.ts

@@ -9,6 +9,7 @@ export type TDevConsoleLogLevel = 'silly' | 'log' | 'info' | 'warn' | 'error';
 export type TDevConsoleLogChannel = {
     channelType: 'cron' | 'master' | 'request' | 'socket';
     channelId?: string;
+    silentLogs?: boolean;
     method?: string;
     path?: string;
     user?: string;

package/common/dev/diagnostics.ts

@@ -72,11 +72,11 @@ const formatRouteTarget = (route: TProteumManifestRoute) => {
 
 const formatRouteItem = (manifest: TProteumManifest, route: TProteumManifestRoute) => {
     const chunk = route.chunkId ? ` chunk=${route.chunkId}` : '';
-    const setup = route.hasSetup ? ' setup=yes' : ' setup=no';
+    const data = route.hasData ? ' data=yes' : ' data=no';
     const options = route.normalizedOptionKeys.length > 0 ? ` options=${route.normalizedOptionKeys.join(',')}` : '';
     const resolution = route.targetResolution !== 'literal' ? ` resolution=${route.targetResolution}` : '';
 
-    return `${route.kind} ${route.methodName} ${formatRouteTarget(route)} [${route.scope}]${chunk}${setup}${options}${resolution} source=${formatManifestFilepath(manifest, route.filepath)}${formatManifestLocation(route.sourceLocation.line, route.sourceLocation.column)}`;
+    return `${route.kind} ${route.methodName} ${formatRouteTarget(route)} [${route.scope}]${chunk}${data}${options}${resolution} source=${formatManifestFilepath(manifest, route.filepath)}${formatManifestLocation(route.sourceLocation.line, route.sourceLocation.column)}`;
 };
 
 const formatLayoutItem = (manifest: TProteumManifest, layout: TProteumManifestLayout) =>
@@ -155,8 +155,8 @@ export const buildExplainBlocks = (manifest: TProteumManifest, sectionNames: TEx
             blocks.push({
                 title: 'Conventions',
                 items: [
-                    `routeSetupOptionKeys=${manifest.conventions.routeSetupOptionKeys.join(', ')}`,
-                    `reservedRouteSetupKeys=${manifest.conventions.reservedRouteSetupKeys.join(', ')}`,
+                    `routeOptionKeys=${manifest.conventions.routeOptionKeys.join(', ')}`,
+                    `reservedRouteOptionKeys=${manifest.conventions.reservedRouteOptionKeys.join(', ')}`,
                 ],
             });
             continue;

package/common/dev/inspection.ts

@@ -358,7 +358,7 @@ const createRouteEntry = (manifest: TProteumManifest, route: TProteumManifestRou
             `${route.kind} ${route.methodName}`,
             ...(route.path ? [`path=${route.path}`] : []),
             ...(route.chunkId ? [`chunk=${route.chunkId}`] : []),
-            `setup=${route.hasSetup ? 'yes' : 'no'}`,
+            `data=${route.hasData ? 'yes' : 'no'}`,
         ],
         kind: 'route',
         label: route.path || route.pathRaw || route.chunkId || route.filepath,

package/common/dev/proteumManifest.ts

@@ -87,7 +87,7 @@ export type TProteumManifestRoute = {
     invalidOptionKeys: string[];
     reservedOptionKeys: string[];
     optionsRaw?: string;
-    hasSetup: boolean;
+    hasData: boolean;
     chunkId?: string;
     chunkFilepath?: string;
     scope: TProteumManifestScope;
@@ -102,7 +102,7 @@ export type TProteumManifestLayout = {
 };
 
 export type TProteumManifest = {
-    version: 9;
+    version: 10;
     app: {
         root: string;
         coreRoot: string;
@@ -126,8 +126,8 @@ export type TProteumManifest = {
         };
     };
     conventions: {
-        routeSetupOptionKeys: string[];
-        reservedRouteSetupKeys: string[];
+        routeOptionKeys: string[];
+        reservedRouteOptionKeys: string[];
     };
     env: {
         source: string;

package/common/dev/requestTrace.ts

@@ -28,7 +28,6 @@ export const traceEventTypes = [
     'resolve.not-found',
     'controller.start',
     'controller.result',
-    'setup.options',
     'context.create',
     'page.data',
     'ssr.payload',

package/common/router/contracts.ts

@@ -3,24 +3,21 @@
 ----------------------------------*/
 
 // Core
-import type { TFrontRenderer, TPageSetup } from './response/page';
+import type { TFrontRenderer, TPageDataProvider } from './response/page';
 import type { TRouteOptions } from '.';
 
 /*----------------------------------
 - PUBLIC API
 ----------------------------------*/
 
-// Supported `Router.page(...)` registration signatures shared by client and compiler code.
+// Supported `Router.page(...)` registration signature shared by client and compiler code.
 export type TRegisterPageArgs<TProvidedData extends {} = {}, TPageOptions extends {} = TRouteOptions> =
-    | [path: string, renderer: TFrontRenderer<TProvidedData>]
-    | [path: string, setup: TPageSetup<TProvidedData>, renderer: TFrontRenderer<TProvidedData>]
-    | [path: string, options: Partial<TPageOptions>, renderer: TFrontRenderer<TProvidedData>]
-    | [
-          path: string,
-          options: Partial<TPageOptions>,
-          setup: TPageSetup<TProvidedData>,
-          renderer: TFrontRenderer<TProvidedData>,
-      ];
+    [
+        path: string,
+        options: Partial<TPageOptions>,
+        data: TPageDataProvider<TProvidedData> | null,
+        renderer: TFrontRenderer<TProvidedData>,
+    ];
 
 // Serialized SSR route description exchanged between build output and runtime.
 export type TSsrUnresolvedRoute<TKey = number | string> = { chunk: string } & (

package/common/router/index.ts

@@ -18,7 +18,7 @@ import type { TAuthCheckInput, TAuthTrackingContext } from '@server/services/aut
 import type { TAppArrowFunction } from '@common/app';
 
 // Specfic
-import type { default as Page, TFrontRenderer, TPageSetup } from './response/page';
+import type { default as Page, TFrontRenderer, TPageDataProvider } from './response/page';
 
 /*----------------------------------
 - TYPES: ROUTES
@@ -40,6 +40,7 @@ type TRouteBase<RouterContext = unknown, TResult = any> = {
 
     // Execute
     schema?: zod.ZodSchema;
+    data?: TPageDataProvider | null;
     controller: TRouteController<RouterContext, TResult>;
     options: TRouteOptions;
 };
@@ -76,7 +77,6 @@ export type TRouteOptions = {
     id?: string;
     filepath?: string;
     sourceLocation?: { line: number; column: number };
-    setup?: TPageSetup;
 
     // Indexing
     bodyId?: string;

package/common/router/pageData.ts

@@ -0,0 +1,72 @@
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+import type { TAnyRoute, TRouteOptions } from '.';
+
+export const routeOptionKeys = [
+    'bodyId',
+    'priority',
+    'preload',
+    'domain',
+    'accept',
+    'raw',
+    'auth',
+    'authTracking',
+    'redirectLogged',
+    'static',
+    'whenStatic',
+    'canonicalParams',
+    'layout',
+    'TESTING',
+    'logging',
+] as const satisfies (keyof TRouteOptions)[];
+
+export const reservedRouteOptionKeys = ['id', 'filepath', 'sourceLocation', 'data'] as const;
+
+const routeOptionKeysSet = new Set<string>(routeOptionKeys);
+const reservedRouteOptionKeysSet = new Set<string>(reservedRouteOptionKeys);
+const reservedPageDataKeys = new Set<string>([
+    ...routeOptionKeys,
+    ...reservedRouteOptionKeys,
+    ...routeOptionKeys.map((key) => `_${key}`),
+    ...reservedRouteOptionKeys.map((key) => `_${key}`),
+]);
+
+const formatRouteTarget = (route: TAnyRoute) => ('code' in route ? String(route.code) : route.path || '(unknown route)');
+
+const formatRouteSource = (route: TAnyRoute) => {
+    const filepath = route.options.filepath || 'unknown file';
+    const line = route.options.sourceLocation?.line;
+    const column = route.options.sourceLocation?.column;
+
+    if (!line) return filepath;
+    if (!column) return `${filepath}:${line}`;
+    return `${filepath}:${line}:${column}`;
+};
+
+export const getRouteOptionKey = (key: string) => {
+    if (reservedRouteOptionKeysSet.has(key)) throw new Error(`"${key}" is a reserved Router.page option key.`);
+
+    return routeOptionKeysSet.has(key) ? (key as keyof TRouteOptions) : null;
+};
+
+export const validatePageDataResult = (route: TAnyRoute, result: unknown) => {
+    if (!result || typeof result !== 'object' || Array.isArray(result)) {
+        throw new Error(
+            `Router.page data for ${formatRouteTarget(route)} in ${formatRouteSource(route)} must return an object. ` +
+                `If the page has no data loader, pass null as the third argument.`,
+        );
+    }
+
+    for (const key of Object.keys(result)) {
+        if (!reservedPageDataKeys.has(key)) continue;
+
+        throw new Error(
+            `Router.page data for ${formatRouteTarget(route)} in ${formatRouteSource(route)} cannot return reserved key "${key}". ` +
+                `Move route behavior into the explicit Router.page(path, options, data, render) options argument.`,
+        );
+    }
+
+    return result as TObjetDonnees;
+};

package/common/router/register.ts

@@ -11,65 +11,29 @@ import type { TRegisterPageArgs } from './contracts';
 
 // types
 import type { TRouteOptions } from '.';
-import type { TFrontRenderer, TPageSetup } from './response/page';
+import type { TPageDataProvider } from './response/page';
 
 /*----------------------------------
 - UTILS
 ----------------------------------*/
 
 export const getRegisterPageArgs = (...args: TRegisterPageArgs<any, TRouteOptions>) => {
-    let path: string;
-    let options: Partial<TRouteOptions> = {};
-    let setup: TPageSetup | undefined;
-    let renderer: TFrontRenderer;
+    const [path, options, data, renderer] = args;
 
-    if (args.length === 2) {
-        [path, renderer] = args;
-    } else if (args.length === 3) {
-        const [pathArg, optionsOrSetupArg, rendererArg] = args;
-        path = pathArg;
-        renderer = rendererArg;
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new Error(`Router.page(${JSON.stringify(path)}) requires an explicit options object as its second argument.`);
+    }
 
-        if (typeof optionsOrSetupArg === 'function') setup = optionsOrSetupArg;
-        else options = optionsOrSetupArg;
-    } else {
-        const [pathArg, optionsArg, setupArg, rendererArg] = args;
-        path = pathArg;
-        options = optionsArg;
-        setup = setupArg;
-        renderer = rendererArg;
+    if (data !== null && typeof data !== 'function') {
+        throw new Error(
+            `Router.page(${JSON.stringify(path)}) requires a data function or null as its third argument.`,
+        );
     }
 
     // Automatic layout form the nearest _layout folder using static options only.
     const layout = getLayout(path, options);
 
-    return { path, options, setup, renderer, layout };
-};
-
-export const getRegisterPageOptions = (...args: TRegisterPageArgs<any, TRouteOptions>) => {
-    let path: string;
-    let options: Partial<TRouteOptions> = {};
-    let setup: TPageSetup | undefined;
-    let renderer: TFrontRenderer;
-
-    if (args.length === 2) {
-        [path, renderer] = args;
-    } else if (args.length === 3) {
-        const [pathArg, optionsOrSetupArg, rendererArg] = args;
-        path = pathArg;
-        renderer = rendererArg;
-
-        if (typeof optionsOrSetupArg === 'function') setup = optionsOrSetupArg;
-        else options = optionsOrSetupArg;
-    } else {
-        const [pathArg, optionsArg, setupArg, rendererArg] = args;
-        path = pathArg;
-        options = optionsArg;
-        setup = setupArg;
-        renderer = rendererArg;
-    }
-
-    return { path, options, setup, renderer };
+    return { path, options, data: data as TPageDataProvider | null, renderer, layout };
 };
 
 export const buildRegex = (path: string) => {

package/common/router/response/page.ts

@@ -8,27 +8,38 @@ import type { Thing } from 'schema-dts';
 
 // Core libs
 import type { ClientContext } from '@/client/context';
-import { ClientOrServerRouter, TErrorRoute, TPageErrorRoute, TPageRoute, TRoute } from '@common/router';
+import { ClientOrServerRouter, TErrorRoute, TPageErrorRoute, TPageRoute, TRoute, TRouteOptions } from '@common/router';
 import type { TFetcher, TFetcherList } from '@common/router/request/api';
-import { splitRouteSetupResult } from '@common/router/pageSetup';
+import { validatePageDataResult } from '@common/router/pageData';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-export type TPageSetupContext = ClientContext;
+export type TPageDataContext = ClientContext;
 
 export type TPageRenderContext = With<ClientContext, 'page'>;
 
+type TPageResponseContext = {
+    route: { options: Partial<TRouteOptions> };
+    request: {
+        url: string;
+        data: TObjetDonnees;
+        api: {
+            fetchSync(fetchers: TFetcherList, alreadyLoadedData: {}): Promise<TObjetDonnees>;
+        };
+    };
+};
+
 export type TResolvedPageData<TProvidedData extends {} = {}> = {
     [Property in keyof TProvidedData]: TProvidedData[Property] extends TFetcher<infer TData>
         ? TData
         : Awaited<TProvidedData[Property]>;
 };
 
-// The function that prepares route config and SSR data before rendering.
-export type TPageSetup<TProvidedData extends {} = {}> = (
-    context: TPageSetupContext & {
+// The function that prepares SSR data before rendering.
+export type TPageDataProvider<TProvidedData extends {} = {}> = (
+    context: TPageDataContext & {
         // URL query parameters
         // TODO: typings
         data: { [key: string]: string | number };
@@ -36,7 +47,7 @@ export type TPageSetup<TProvidedData extends {} = {}> = (
 ) => TProvidedData;
 
 export type TDataProvider<TProvidedData extends {} = TFetcherList> = (
-    context: TPageSetupContext & { data: { [key: string]: PrimitiveValue } },
+    context: TPageDataContext & { data: { [key: string]: PrimitiveValue } },
 ) => TProvidedData;
 
 // The function that renders routes
@@ -68,7 +79,7 @@ const debug = false;
 export default abstract class PageResponse<
     TRouter extends ClientOrServerRouter = ClientOrServerRouter,
     TRouteLike extends TRoute | TErrorRoute = TPageRoute | TPageErrorRoute,
-    TContext extends TPageRenderContext = TPageRenderContext,
+    TContext extends TPageResponseContext = TPageResponseContext,
 > {
     // Metadata
     public chunkId?: string;
@@ -100,18 +111,19 @@ export default abstract class PageResponse<
         this.url = context.request.url;
     }
 
-    private resolveSetup() {
-        const setup = this.route.options.setup;
-        if (!setup) return { options: {}, data: {} };
+    private resolveDataProviderResult() {
+        const dataProvider = 'data' in this.route ? this.route.data : undefined;
+        if (!dataProvider) return {};
 
-        const setupContext = { ...this.context, data: this.context.request.data } as Parameters<typeof setup>[0];
+        const dataContext = { ...this.context, data: this.context.request.data } as unknown as Parameters<
+            typeof dataProvider
+        >[0];
 
-        return splitRouteSetupResult(setup(setupContext) || {});
+        return validatePageDataResult(this.route, dataProvider(dataContext));
     }
 
     private createFetchers() {
-        const { options, data } = this.resolveSetup();
-        this.route.options = { ...this.route.options, ...options };
+        const data = this.resolveDataProviderResult();
         this.chunkId = this.route.options.id;
 
         return data as TFetcherList;
@@ -126,7 +138,7 @@ export default abstract class PageResponse<
             const layoutContext = {
                 ...this.context,
                 data: this.context.request.data,
-            } as Parameters<typeof this.layout.data>[0];
+            } as unknown as Parameters<typeof this.layout.data>[0];
             const fetchers = this.layout.data(layoutContext);
             this.fetchers = { ...this.fetchers, ...fetchers };
         }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "proteum",
 	"description": "LLM-first Opinionated Typescript Framework for web applications.",
-	"version": "2.1.9-8",
+	"version": "2.2.0",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/proteum.git",
 	"license": "MIT",
@@ -16,6 +16,10 @@
 		"proteum": "cli/bin.js"
 	},
 	"dependencies": {
+		"@babel/generator": "^7.29.0",
+		"@babel/parser": "^7.29.0",
+		"@babel/traverse": "^7.29.0",
+		"@babel/types": "^7.29.0",
 		"@inkjs/ui": "^2.0.0",
 		"@prisma/adapter-mariadb": "7.2.0",
 		"@prisma/client": "7.2.0",

package/server/services/router/index.ts

@@ -222,6 +222,7 @@ export default class ServerRouter<
             const methodName = match ? match[2] : '<anonymous>';*/
 
             const contextData = context.getStore() || { channelType: 'master' };
+            if (contextData.silentLogs) return;
 
             const requestPrefix =
                 contextData.channelType === 'request'
@@ -273,21 +274,18 @@ export default class ServerRouter<
 
     public async renderStatic(url: string, options: TRouteOptions['static'], rendered?: any) {
         // Wildcard: tell that the newly rendered pages should be cached
-        if (url === '*' || !url) return;
-
-        if (!rendered) {
-            console.log('[router] renderStatic: url', url);
+        if (url === '*' || !url) throw new Error(`Unable to cache a dynamic or empty URL.`);
 
+        if (rendered === undefined) {
             const fullUrl = this.url(url, {}, true);
             const response = await got(fullUrl, {
                 method: 'GET',
-                headers: { Accept: 'text/html', bypasscache: '1' },
+                headers: { Accept: 'text/html', bypasscache: '1', 'x-proteum-static-warmup': '1' },
                 throwHttpErrors: false,
             });
 
             if (response.statusCode !== 200) {
-                console.error('[router] renderStatic: page returned code', response.statusCode, fullUrl);
-                return;
+                throw new Error(`Static render returned ${response.statusCode} for ${fullUrl}`);
             }
 
             rendered = response.body;
@@ -302,17 +300,50 @@ export default class ServerRouter<
 
     private initStaticRoutes() {
         this.clearStaticRoutesRefreshInterval();
+        const staticEntries: Array<{ routePath: string; url: string; options: TRouteOptions['static'] }> = [];
+        const seenStaticUrls = new Set<string>();
 
         for (const route of this.routes) {
+            if (route.method !== 'GET' || route.options.accept !== 'html') continue;
+
             if (!route.options.static) continue;
 
             // Add to static pages
             // Should be a GET oage that don't take any parameter
             for (const url of route.options.static.urls) {
-                this.renderStatic(url, route.options.static);
+                if (!url || url === '*' || seenStaticUrls.has(url)) continue;
+
+                staticEntries.push({
+                    routePath: route.path || '(unknown route)',
+                    url,
+                    options: route.options.static,
+                });
+                seenStaticUrls.add(url);
             }
         }
 
+        void (async () => {
+            const warmedUrls: string[] = [];
+            let failedCount = 0;
+
+            for (const entry of staticEntries) {
+                try {
+                    await this.renderStatic(entry.url, entry.options);
+                    warmedUrls.push(entry.url);
+                } catch (error) {
+                    failedCount += 1;
+                    console.error('[router] Static warmup failed', entry.url, `route=${entry.routePath}`, error);
+                }
+            }
+
+            console.log(
+                '[router] Static warmup finished',
+                `warmed=${warmedUrls.length}`,
+                `failed=${failedCount}`,
+                `urls=${warmedUrls.length > 0 ? warmedUrls.join(', ') : 'none'}`,
+            );
+        })();
+
         // Every hours, refresh static pages
         this.staticRoutesRefreshInterval = setInterval(
             () => {
@@ -328,7 +359,9 @@ export default class ServerRouter<
         for (const pageUrl in this.cache) {
             const page = this.cache[pageUrl];
             if (page.expire && page.expire < Date.now()) {
-                this.renderStatic(pageUrl, page.options);
+                void this.renderStatic(pageUrl, page.options).catch((error) => {
+                    console.error('[router] Static refresh failed', pageUrl, error);
+                });
             }
         }
     }
@@ -383,7 +416,7 @@ export default class ServerRouter<
     ----------------------------------*/
 
     public page(...args: TRegisterPageArgs<any, TRouteOptions>) {
-        const { path, options, setup, renderer, layout } = getRegisterPageArgs(...args);
+        const { path, options, data, renderer, layout } = getRegisterPageArgs(...args);
 
         const { regex, keys } = buildRegex(path);
 
@@ -392,10 +425,10 @@ export default class ServerRouter<
             path,
             regex,
             keys,
+            data,
             controller: (context: TRouterContext<this>) => new Page(route, renderer, context, layout),
             options: this.buildRouteOptions({
                 accept: 'html', // Les pages retournent forcémment du html
-                setup,
                 ...options,
             }),
         };
@@ -756,6 +789,7 @@ export default class ServerRouter<
                     // This is for debugging
                     channelType: 'request',
                     channelId: request.id,
+                    silentLogs: request.headers['x-proteum-static-warmup'] === '1',
                     method: request.method,
                     path: request.path,
                     connectedNamespace: request.headers[profilerConnectedNamespaceHeader] || undefined,
@@ -940,8 +974,6 @@ export default class ServerRouter<
         });
 
     private async resolvedRoute(route: TMatchedRoute, response: ServerResponse<this>, timeStart: number) {
-        route = await response.resolveRouteOptions(route);
-
         this.app.container.Trace.record(
             response.request.id,
             'resolve.route-match',
@@ -984,7 +1016,9 @@ export default class ServerRouter<
                     staticUrl,
                     route.options.static,
                     staticUrl === response.request.path ? response.data : undefined,
-                );
+                ).catch((error) => {
+                    console.error('[router] Static cache write failed', staticUrl, error);
+                });
             }
         }
 

package/server/services/router/request/api.ts

@@ -107,7 +107,7 @@ export default class ApiClientRequest extends RequestService implements ApiClien
             throw new Error(
                 `Proteum connected boundary mismatch: "${connected.namespace}" is not registered on ${this.request.router.app.identity.identifier}. ` +
                     `Likely fix: declare connect.${connected.namespace} in proteum.config.ts for the consumer app or stop using that connected controller accessor here. ` +
-                    `Re-check both SSR and client navigation if this fetcher is used from a page setup or render path.`,
+                    `Re-check both SSR and client navigation if this fetcher is used from a page data or render path.`,
             );
         }