proteum 2.1.3-1 → 2.1.7

package/agents/project/client/pages/AGENTS.md

@@ -1,12 +1,19 @@
-# Page Files
+# Page Contract
 
-This file adds page-file local rules on top of the canonical framework contract:
+This is the canonical page-file contract for Proteum-based projects.
+Role: keep only page-file rules here.
+Keep here: `Router.page(...)` registration, SSR `setup` and `render` contracts, page payload shape, and page-local typing rules.
+Do not put here: generic component rules, server/service implementation details, or app-wide workflow already covered by broader AGENTS files.
 
-- framework repo: `agents/framework/AGENTS.md`
-- installed app: `./node_modules/proteum/agents/framework/AGENTS.md`
+Optimization source of truth: project-root `optimizations.md`.
+Diagnostics source of truth: project-root `diagnostics.md`.
+Coding style source of truth: project-root `CODING_STYLE.md`.
 
 ## Router.page Usage
 
+- Proteum scans page files for top-level `Router.page(...)` and `Router.error(...)` calls.
+- File path controls chunk identity and layout discovery; route path comes from the explicit `Router.page(...)` string.
+- Supported page signatures are `Router.page(path, render)`, `Router.page(path, setup, render)`, `Router.page(path, options, render)`, and `Router.page(path, options, setup, render)`.
 - Prefer `Router.page(path, setup, render)` for normal SSR pages.
 - Use `Router.page(path, options, setup, render)` when a separate route-options object makes the call clearer.
 - Keep the `Router.page(...)` call compact instead of exploding each outer argument onto its own line.
@@ -15,14 +22,15 @@ This file adds page-file local rules on top of the canonical framework contract:
 ## Setup And Render
 
 - `setup` returns one flat object.
-- `_`-prefixed keys are route options.
-- every other key is SSR data and should be consumed from `render`
-- if a page needs route data, return it from `setup` and read it in `render`
+- `_`-prefixed keys like `_auth`, `_layout`, `_static`, and `_redirectLogged` are route options.
+- Every other key is SSR data and should be consumed from `render`.
+- Controller fetchers and promises returned from `setup` resolve before render.
+- If a page needs route data, return it from `setup` and read it in `render`.
 
 ## Page Rules
 
-- Prefer generated page args or the app context hook. Do not import `.proteum` files directly.
-- Never use `api.fetch(...)` in page files.
+- Prefer generated page args or the app client context. Do not import `.proteum` implementation files directly.
+- Never use `api.fetch(...)` in page files for SSR loading.
 - Never import client service values from `@app`.
 - Keep page-local curated copy, option sets, and registries in `/client/catalogs/**`.
 - When shared Shadcn-based primitives exist, compose the page UI from them instead of redefining common controls inline.

package/agents/project/diagnostics.md

@@ -0,0 +1,52 @@
+# Diagnostics Rules
+
+This file is the canonical source of truth for diagnostics, temporary instrumentation, error solving, and verification method selection across Proteum-based projects.
+
+## Initial Triage
+
+- Start with machine-readable app state before reading large parts of the codebase: `./.proteum/manifest.json`, `npx proteum connect --json`, `npx proteum explain --json`, `npx proteum doctor --json`, and `npx proteum doctor --contracts --json` when generated artifacts or manifest-owned files may be stale.
+- When one app depends on another app's generated controllers, inspect `npx proteum connect --controllers`, `npx proteum explain --connected --controllers`, the producer `proteum.connected.json`, the consumer `proteum.config.ts` connected `source` value, and the producer `./.proteum/proteum.connected.d.ts` before assuming the contract is local.
+- Use `rg -n` first to narrow the exact code path, then read only the relevant files.
+- Inspect `./server/index.ts`, `./server/config/*.ts`, and the touched files under `./commands`, `./server/controllers`, `./server/services`, `./server/routes`, `./client/pages`, and `./tests`.
+- Distinguish real app failures from wrapper, transport, tooling, or environment failures as early as possible.
+
+## Runtime Diagnostics
+
+- For request-time issues in dev, start with `npx proteum diagnose <path> --port <port>` when you have a concrete failing route, page, controller path, or request target. It combines owner lookup, manifest diagnostics, contract diagnostics, matching trace data, and buffered server logs in one pass.
+- For connected-project failures, confirm the consumer app resolves the expected `connect.<Namespace>.source` and `connect.<Namespace>.urlInternal` values, the producer app exposes `GET /api/__proteum/connected/ping`, and the imported controller entries show `scope=connected` in `proteum explain`.
+- Use `npx proteum explain owner <query>` when you need a fast ownership graph for a route, controller path, source file, or generated artifact before reading code.
+- For performance issues or regressions in dev, use `npx proteum perf top --since <window>` to rank hot paths, `npx proteum perf request <requestId|path>` for one request waterfall, `npx proteum perf compare --baseline <window> --target <window>` for regressions, and `npx proteum perf memory --since <window>` for heap or RSS drift.
+- For request-time issues in dev, inspect traces before adding logs when the diagnose surface is still too coarse.
+- If a server is already running on the default port from `PORT` or `./.proteum/manifest.json`, inspect existing traces before reproducing the issue.
+- If existing traces are insufficient, arm `npx proteum trace arm --capture deep`, reproduce once, then inspect the new request with `npx proteum trace latest` or `npx proteum trace show <requestId>`.
+- Inspect browser console errors and warnings for frontend, SSR, hydration, and controller-call issues.
+- Inspect server startup and runtime errors.
+- For protected browser or API flows in dev, prefer `npx proteum session <email> --role <role>` over driving the login UI. Use the login UI only when auth UX itself is under test.
+
+## Temporary Instrumentation
+
+- When manifest inspection, trace data, browser console output, and server errors are still insufficient, add temporary targeted logs in the code to confirm control flow, payload shape, query shape, or branch selection.
+- Keep temporary logs narrow, contextual, and easy to remove. Do not leave broad debug noise in shared execution paths.
+- Re-run only the smallest relevant repro, request, or test after adding temporary instrumentation.
+- Temporary logs added in the code for diagnosis must be cleaned at the end of tests or the repro cycle and must never be committed.
+
+## Error Solving
+
+- Fix the contract boundary, not only the downstream symptom.
+- Prefer explicit typed schemas, adapters, query `select`s, and narrow response shapes over casts, broad payloads, or hidden fallbacks.
+- Keep patches narrow, then verify immediately at the failing layer before broadening the test surface.
+- Review the resulting diff to confirm the fix removed the cause instead of masking it.
+
+## Verification And Testing
+
+- Use the cheapest trustworthy verification that matches the failing layer.
+- After implementing a feature or behavior change, always verify it on a running app instead of stopping at static analysis or code review.
+- For compile-time or type-safety issues, start with the relevant typecheck or build command.
+- For request/runtime issues, verify through the real page, route, generated controller call, or command on a running app.
+- Start the smallest trustworthy runtime surface first: boot the server, run the relevant real URL, generated controller call, command, or `npx proteum diagnose <path> --port <port>`, then add targeted Playwright coverage when the change is browser-visible.
+- For browser regressions, prefer targeted Playwright coverage and inspect failure artifacts such as screenshots, videos, `error-context.md`, and Playwright traces.
+- Treat server startup failures, runtime errors, browser console errors or warnings, and Playwright failures as blocking unless they are clearly unrelated to the change.
+- When the touched surface can affect coding-style enforcement, run the smallest relevant project check such as `npx proteum lint` or `npx proteum check` before finishing.
+- Add `data-testid` when stable selectors are missing instead of relying on brittle text or DOM-shape selectors.
+- If an isolated test misses prerequisite state, run the smallest broader scope that reproduces the real setup.
+- After a fix, re-check traces, rendered HTML, browser console, and server output when those surfaces were part of the original failure.

package/agents/project/optimizations.md

@@ -0,0 +1,48 @@
+# Optimization Rules
+
+This file is the canonical source of truth for bundle size, performance, SEO, and SSR page-size guidance across Proteum-based projects.
+
+## Priority Order
+
+When tradeoffs exist inside optimization work, optimize in this order:
+
+1. Reduce shipped client bundle size and unnecessary runtime code.
+2. Improve build-time, server-time, and browser-time performance.
+3. Improve SEO output and crawlable, semantic HTML.
+
+## Bundle Size And Runtime Cost
+
+- Reduce shipped client bundle size and unnecessary runtime code.
+- Before inventing a new helper, runtime, plugin, abstraction, primitive, parser, formatter, SDK wrapper, or build-time tool, first check whether the repo already depends on a suitable package.
+- If the repo does not already depend on one, search npm before writing a custom implementation.
+- Prefer established, flexible, well-typed, widely adopted, actively maintained packages.
+- Build custom or keep custom infrastructure only when packages would clearly hurt bundle size, SSR behavior, performance, typing quality, flexibility, licensing, explicit contracts, or long-term maintainability.
+- If you choose custom over a package, state briefly why.
+
+## SSR And Page Size
+
+- SSR page data belongs in page `setup`, not in `api.fetch(...)`.
+- Prefer `Router.page(path, setup, render)` for normal SSR pages.
+- `setup` returns one flat object.
+- `_`-prefixed keys are route options. Every other key is SSR data and should be consumed from `render`.
+- If a page needs route data, return it from `setup` and read it in `render`.
+- Controller fetchers and promises returned from `setup` resolve before render.
+- Never use `api.fetch(...)` in page files for SSR loading.
+- Synchronous or SSR data calls must return only the strictly necessary data for the current render path to minimize SSR payload size.
+- If an existing controller or data method returns a broader shape than the SSR path needs, create a dedicated proxy controller method with a narrower typed contract instead of reusing the oversized payload.
+- Keep Prisma runtime access inside services when possible and prefer explicit `select` or narrow `include` in database queries.
+
+## SEO And Crawlable Output
+
+- Improve SEO output and crawlable, semantic HTML.
+- For explicit crawl surfaces such as redirects, sitemap or RSS output, and public resources with custom semantics, prefer `server/routes/**` over generated controller actions when the endpoint is not a normal app API.
+
+## Validation
+
+- Do not stop at static analysis for SSR, routing, emitted assets, or rendered HTML.
+- After implementing a feature or change, verify that performance, load size, and SEO output did not materially regress before finishing.
+- When runtime cost, hot paths, or memory can change, use the relevant `npx proteum perf ...` command against the affected request or route and compare to the pre-change behavior when possible.
+- For browser or SSR changes, load the real page, inspect the rendered HTML, and confirm the change does not ship unnecessary client code or oversized SSR payloads.
+- Treat clearly worse bundle size, runtime cost, or crawlable HTML quality as regressions to fix or justify explicitly, not as optional follow-up cleanup.
+- Build-only checks are supplementary.
+- For SSR changes, load the real page and inspect the rendered HTML plus browser console.

package/agents/project/server/routes/AGENTS.md

@@ -1,12 +1,15 @@
-# Server Routes
+# Route Contract
 
-This file adds route-area local rules on top of the canonical framework contract:
+This is the canonical route-area contract for Proteum-based projects.
+Role: keep only manual-route rules here.
+Keep here: explicit HTTP route guidance, public/crawlable endpoint rules, absolute URL generation, and route-specific catalog placement.
+Do not put here: controller contracts, service-layer business logic, page SSR rules, or broad project workflow already defined elsewhere.
 
-- framework repo: `agents/framework/AGENTS.md`
-- installed app: `./node_modules/proteum/agents/framework/AGENTS.md`
+Optimization source of truth: project-root `optimizations.md`.
+Diagnostics source of truth: project-root `diagnostics.md`.
 
-- Use `/server/routes/**` only for explicit custom HTTP behavior that should not be generated from controllers.
-- If the endpoint is just a normal app API, prefer `/server/controllers/**/*.ts`.
+- Use `server/routes/**` only for explicit HTTP behavior that should not be generated from controllers.
+- If the endpoint is a normal app API, prefer `server/controllers/**/*.ts`.
 - Good fits include redirects, resources, OAuth callbacks, webhooks, sitemap-like output, and custom public endpoints.
 - If a route needs a curated registry, keep server-only data in `/server/catalogs/**` and shared data in `/common/catalogs/**`.
 

package/agents/project/server/services/AGENTS.md

@@ -1,20 +1,24 @@
-# Server Services
+# Service Contract
 
-This file adds service-area local rules on top of the canonical framework contract:
+This is the canonical service-area contract for Proteum-based projects.
+Role: keep only service-layer rules here.
+Keep here: service placement, service responsibilities, model access, query-shaping, return-type guidance, and service error-handling rules.
+Do not put here: request parsing, page/render rules, controller transport details, or broad project workflow already defined in higher-level AGENTS files.
 
-- framework repo: `agents/framework/AGENTS.md`
-- installed app: `./node_modules/proteum/agents/framework/AGENTS.md`
+Optimization source of truth: project-root `optimizations.md`.
+Diagnostics source of truth: project-root `diagnostics.md`.
 
 ## Placement
 
 - Root business services live in `/server/services/<Feature>/index.ts`.
-- Root-service metadata lives in `/server/services/<Feature>/service.json`.
 - Root-service config lives in `/server/config/*.ts` when the service needs config.
 - Companion client-callable entrypoints live in `/server/controllers/**`.
 
-## Local Service Rules
+## Service Rules
 
+- Business logic belongs in classes that extend `Service` and use `this.services`, `this.models`, and `this.app`.
 - Keep business logic in services and keep request/auth/input handling in controllers.
+- Normal service methods should not read request-scoped state directly.
 - If a feature grows several coherent domains, split it into explicit subservices.
 - Server-only catalogs live in `/server/catalogs/**`.
 - Shared cross-runtime catalogs live in `/common/catalogs/**`.

package/agents/project/tests/AGENTS.md

@@ -1,12 +1,18 @@
-# E2E Tests
+# Test Contract
 
-This file adds test-area local rules on top of the canonical framework contract:
+This is the canonical test-area contract for Proteum-based projects.
+Role: keep only test-area rules here.
+Keep here: runtime verification guidance, selector strategy, test-specific reuse rules, and authenticated test-flow expectations.
+Do not put here: production implementation rules, page/service architecture contracts, or duplicated project workflow that belongs in broader AGENTS files.
 
-- framework repo: `agents/framework/AGENTS.md`
-- installed app: `./node_modules/proteum/agents/framework/AGENTS.md`
+Diagnostics source of truth: project-root `diagnostics.md`.
 
 - Understand the real user flow and the main feature branches before writing tests.
-- Test the current controller/page runtime model, not legacy `@Route` or `api.fetch` behavior.
+- Test the current controller/page runtime model, not legacy `@Route` or `api.fetch(...)` behavior.
+- Verify routing, controllers, SSR, and router plugins against a running app when behavior depends on real request handling.
+- After implementing a browser-visible feature or change, run targeted Playwright coverage or a real browser repro against a running app before finishing; this verification is required, not optional cleanup.
+- Exercise real URLs, generated controller calls, or real browser flows instead of re-deriving framework internals in tests.
 - Locate elements with `data-testid`.
 - Add `data-testid` where needed instead of relying on brittle selectors.
 - Reuse root catalog files from `/client/catalogs/**`, `/server/catalogs/**`, or `/common/catalogs/**` instead of duplicating catalog constants in tests.
+- For protected dev flows, prefer `npx proteum session <email> --role <role>` over automating login unless the login flow itself is under test.

package/cli/app/config.ts

@@ -2,12 +2,8 @@
 - DEPENDANCES
 ----------------------------------*/
 
-// Npm
-import fs from 'fs-extra';
-import yaml from 'yaml';
-
-// Types
 import { parseProteumEnvConfig, type TProteumLoadedEnvConfig } from '../../common/env/proteumEnv';
+import { loadApplicationIdentityConfig, loadApplicationSetupConfig } from '../../common/applicationConfigLoader';
 import { logVerbose } from '../runtime/verbose';
 
 /*----------------------------------
@@ -20,25 +16,28 @@ export default class ConfigParser {
         public routerPortOverride?: number,
     ) {}
 
-    private loadYaml(filepath: string) {
-        logVerbose(`Loading config ${filepath}`);
-        const rawConfig = fs.readFileSync(filepath, 'utf-8');
-        return yaml.parse(rawConfig);
-    }
-
     public env(): TProteumLoadedEnvConfig {
         logVerbose('[app] Loading Proteum env vars from process.env');
+        const setup = this.setup();
         return {
             ...parseProteumEnvConfig({
                 appDir: this.appDir,
+                connectedProjects: setup.connect,
                 routerPortOverride: this.routerPortOverride,
             }),
             version: 'CLI',
         };
     }
 
-    public identity() {
-        const identityFile = this.appDir + '/identity.yaml';
-        return this.loadYaml(identityFile);
+    public identity(): Config.Identity {
+        const identityFile = this.appDir + '/identity.config.ts';
+        logVerbose(`Loading config ${identityFile}`);
+        return loadApplicationIdentityConfig(this.appDir);
+    }
+
+    public setup(): Config.Setup {
+        const setupFile = this.appDir + '/proteum.config.ts';
+        logVerbose(`Loading config ${setupFile}`);
+        return loadApplicationSetupConfig(this.appDir);
     }
 }

package/cli/app/index.ts

@@ -11,6 +11,8 @@ import fs from 'fs-extra';
 import cli from '..';
 
 // Specific
+import { normalizeTranspileConfig } from '../../common/applicationConfig';
+import { normalizeConnectedProjectsConfig } from '../../common/connectedProjects';
 import ConfigParser from './config';
 import type { TEnvConfig } from '../../server/app/container/config';
 
@@ -32,6 +34,30 @@ const parseRouterPortOverride = (rawPort: string | boolean | string[] | undefine
     return port;
 };
 
+const normalizeModulePath = (value: string) => value.replace(/\\/g, '/').replace(/\/$/, '');
+
+const resolveTranspileModuleDirectories = ({
+    moduleNames,
+    searchRoots,
+}: {
+    moduleNames: string[];
+    searchRoots: string[];
+}) => {
+    const directories = new Set<string>();
+
+    for (const moduleName of moduleNames) {
+        for (const searchRoot of searchRoots) {
+            const candidate = normalizeModulePath(path.join(searchRoot, 'node_modules', moduleName));
+            if (!fs.existsSync(candidate)) continue;
+
+            directories.add(candidate);
+            directories.add(normalizeModulePath(fs.realpathSync(candidate)));
+        }
+    }
+
+    return [...directories];
+};
+
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
@@ -40,6 +66,7 @@ export class App {
     // WARNING: High level config files (env and services) shouldn't be loaded from the CLI
     //  The CLI will be run on CircleCI, and no env file should be sent to this service
     public identity: Config.Identity;
+    public setup: Config.Setup;
 
     public env: TEnvConfig;
 
@@ -77,6 +104,7 @@ export class App {
         //'Services',
         'Environment',
         'Identity',
+        'Setup',
         /*'Application',
         'Path',
         'Event'*/
@@ -88,6 +116,7 @@ export class App {
 
         const configParser = new ConfigParser(cli.paths.appRoot, undefined, this.routerPortOverride);
         this.identity = configParser.identity();
+        this.setup = configParser.setup();
         this.env = configParser.env();
         this.packageJson = this.loadPkg();
     }
@@ -96,6 +125,35 @@ export class App {
         return target === 'dev' ? this.paths.dev : this.paths.bin;
     }
 
+    public get transpile() {
+        return normalizeTranspileConfig(this.setup.transpile);
+    }
+
+    public get connectedProjects() {
+        return normalizeConnectedProjectsConfig(this.setup.connect);
+    }
+
+    public get transpileModuleDirectories() {
+        return resolveTranspileModuleDirectories({
+            moduleNames: this.transpile,
+            searchRoots: [this.paths.root, cli.paths.core.root],
+        });
+    }
+
+    public isTranspileModuleFile(filepath: string) {
+        const normalizedFilepath = normalizeModulePath(path.resolve(filepath));
+
+        return this.transpileModuleDirectories.some(
+            (directory) => normalizedFilepath === directory || normalizedFilepath.startsWith(directory + '/'),
+        );
+    }
+
+    public isTranspileModuleRequest(request: string) {
+        if (path.isAbsolute(request)) return this.isTranspileModuleFile(request);
+
+        return this.transpile.some((moduleName) => request === moduleName || request.startsWith(moduleName + '/'));
+    }
+
     /*----------------------------------
     - ALIAS
     ----------------------------------*/

package/cli/commands/connect.ts

@@ -0,0 +1,45 @@
+import cli from '..';
+import Compiler from '../compiler';
+import { readProteumManifest } from '../compiler/common/proteumManifest';
+import { buildConnectResponse, renderConnectHuman } from '@common/dev/connect';
+
+const allowedConnectArgs = new Set(['controllers', 'json', 'strict']);
+
+const validateConnectArgs = () => {
+    const enabledArgs = Object.entries(cli.args)
+        .filter(([name, value]) => name !== 'workdir' && name !== 'verbose' && value === true)
+        .map(([name]) => name);
+
+    const invalidArgs = enabledArgs.filter((arg) => !allowedConnectArgs.has(arg));
+
+    if (invalidArgs.length > 0) {
+        throw new Error(
+            `Unknown connect argument(s): ${invalidArgs.join(', ')}. Allowed values: ${[...allowedConnectArgs].join(', ')}.`,
+        );
+    }
+};
+
+export const run = async (): Promise<void> => {
+    validateConnectArgs();
+
+    const compiler = new Compiler('dev');
+    await compiler.refreshGeneratedTypings();
+
+    const manifest = readProteumManifest(cli.paths.appRoot);
+    const response = buildConnectResponse(manifest, {
+        includeControllers: cli.args.controllers === true,
+        strict: cli.args.strict === true,
+    });
+
+    if (cli.args.json === true) {
+        console.log(JSON.stringify(response, null, 2));
+    } else {
+        console.log(renderConnectHuman(manifest, response));
+    }
+
+    if (cli.args.strict === true && response.diagnostics.length > 0) {
+        throw new Error(
+            `Proteum connect failed in strict mode with ${response.summary.errors} errors and ${response.summary.warnings} warnings.`,
+        );
+    }
+};

package/cli/commands/dev.ts

@@ -33,7 +33,7 @@ import { app, App } from '../app';
 ----------------------------------*/
 
 // Watch rules shared by the dev compiler and hot reload gate.
-const ignoredWatchPathPatterns = /(node_modules\/(?!proteum\/))|(\.generated\/)|(\.cache\/)|(\.proteum\/)|(\/var\/traces\/)/;
+const ignoredWatchPathPatterns = /(\.generated\/)|(\.cache\/)|(\.proteum\/)|(\/var\/traces\/)/;
 const hotReloadableServerPathPatterns = [
     /^client\/pages\//,
     /^client\/components\//,
@@ -102,14 +102,26 @@ const waitForChildExit = async (child: ChildProcess, timeoutMs: number) =>
         child.once('close', onClose);
     });
 
-const escapeForRegExp = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-const createIgnoredWatchPattern = (outputPaths: string[]) =>
-    new RegExp(
-        [
-            ignoredWatchPathPatterns.source,
-            ...outputPaths.map((outputPath) => `(?:^${escapeForRegExp(outputPath)}(?:/|$))`),
-        ].join('|'),
-    );
+const shouldIgnoreNodeModulesWatchPath = (watchPath: string) => {
+    if (!watchPath.includes('/node_modules/')) return false;
+    if (watchPath.includes('/node_modules/proteum/') && !watchPath.includes('/node_modules/proteum/node_modules/')) {
+        return false;
+    }
+
+    return !app.isTranspileModuleFile(watchPath);
+};
+
+const createIgnoredWatchMatcher = (outputPaths: string[]) => (watchPath: string) => {
+    const normalizedWatchPath = normalizeWatchPath(watchPath);
+
+    if (outputPaths.some((outputPath) => normalizedWatchPath === outputPath || normalizedWatchPath.startsWith(outputPath + '/'))) {
+        return true;
+    }
+
+    if (shouldIgnoreNodeModulesWatchPath(normalizedWatchPath)) return true;
+
+    return ignoredWatchPathPatterns.test(normalizedWatchPath);
+};
 const getDevAppName = (app: App) =>
     app.identity.web?.fullTitle || app.identity.web?.title || app.identity.name || app.packageJson.name || app.paths.root;
 
@@ -162,17 +174,27 @@ async function startApp(app: App) {
         });
 
         const child = cp;
+        let childReady = false;
+
+        child.on('exit', (code, signal) => {
+            const isCurrentChild = cp === child;
+            if (isCurrentChild) cp = undefined;
+            if (!isCurrentChild || devSessionStopping || childReady) return;
 
-        child.on('exit', () => {
-            if (cp === child) cp = undefined;
+            console.error(
+                `Proteum dev server exited before reporting ready.${code !== null ? ` Exit code: ${code}.` : ''}${signal ? ` Signal: ${signal}.` : ''}`,
+            );
+            process.exit(code && code !== 0 ? code : 1);
         });
 
         child.on('message', (message: unknown) => {
             if (isServerReadyMessage(message)) {
+                childReady = true;
                 void (async () => {
                     console.info(
                         await renderServerReadyBanner({
                             appName: getDevAppName(app),
+                            connectedProjectsCount: Object.keys(app.env.connectedProjects).length,
                             publicUrl: message.publicUrl,
                             routerPort: app.env.router.port,
                         }),
@@ -342,8 +364,10 @@ export const run = async () => {
         await renderDevSession({
             appName: getDevAppName(app),
             appRoot: app.paths.root === process.cwd() ? '.' : app.paths.root,
+            connectedProjects: Object.values(app.env.connectedProjects),
             routerPort: app.env.router.port,
             devEventPort: devEventServer.port,
+            proteumVersion: String(cli.packageJson.version || ''),
         }),
     );
 
@@ -364,7 +388,7 @@ export const run = async () => {
 
     const multiCompiler = await compiler.create();
     const ignoredOutputPaths = [app.paths.bin, app.paths.dev].map(normalizeWatchPath);
-    const ignoredWatchPattern = createIgnoredWatchPattern(ignoredOutputPaths);
+    const ignoredWatchMatcher = createIgnoredWatchMatcher(ignoredOutputPaths);
 
     const watching = multiCompiler.watch(
         {
@@ -377,7 +401,7 @@ export const run = async () => {
             // - Node modules except 5HTP core (framework dev mode)
             // - Generated files during runtime (cause infinite loop. Ex: models.d.ts)
             // - Webpack output folders (`./dev`, legacy `./bin`)
-            ignored: ignoredWatchPattern,
+            ignored: ignoredWatchMatcher,
 
             //aggregateTimeout: 1000,
         },