@noego/app 0.0.9 → 0.0.10

package/.claude/settings.local.json

@@ -1,10 +1,17 @@
 {
   "permissions": {
     "allow": [
-      "Bash(cat:*)",
-      "Bash(curl:*)",
-      "Bash(noego dev)",
-      "WebSearch"
+      "Read(//Users/shavauhngabay/dev/noego/dinner/**)",
+      "Read(//Users/shavauhngabay/dev/ego/sqlstack/**)",
+      "Read(//Users/shavauhngabay/dev/ego/forge/**)",
+      "Read(//Users/shavauhngabay/dev/noblelaw/ui/**)",
+      "Read(//Users/shavauhngabay/dev/noblelaw/**)",
+      "mcp__chrome-devtools__take_screenshot",
+      "Bash(npm run build:ui:ssr:*)",
+      "mcp__chrome-devtools__navigate_page",
+      "Bash(node dist/hammer.js:*)",
+      "Bash(tee:*)",
+      "mcp__chrome-devtools__list_console_messages"
     ],
     "deny": [],
     "ask": []

package/docs/asset-serving-fix.md

@@ -0,0 +1,381 @@
+# Asset Serving Architecture Investigation
+
+**Status:** Under Investigation
+**Date:** 2025-01-11 (Updated)
+**Author:** Engineering Team
+**Context:** Deep dive after initial runtime.js fix revealed deeper Forge integration issue
+
+---
+
+## Investigation Summary
+
+After fixing the initial asset serving issue in `runtime.js` (mounting `.app` at root `/`), we discovered a **deeper architectural problem**: The browser is loading SSR components instead of client-bundled components, causing `effect_orphan` errors.
+
+---
+
+## What We Know FOR SURE (Confirmed via Code Review & Logs)
+
+### 1. Build Output Structure
+```
+dist/
+├── .app/
+│   ├── assets/              ← Client-bundled components (Vite output)
+│   │   ├── chunks/          ← Shared code chunks
+│   │   └── components/      ← Browser-ready .js files
+│   │       ├── layout/
+│   │       │   └── root.js  ← VITE-BUNDLED, imports from ../../chunks/
+│   │       └── views/
+│   │           └── home.js
+│   └── ssr/                 ← SSR components (server-side)
+│       ├── chunks/
+│       └── components/
+│           ├── layout/
+│           │   └── root.js  ← SSR VERSION, bare imports fail in browser
+│           └── views/
+│               └── home.js
+├── no_ego.js               ← Bootstrap config
+└── [compiled app files]
+```
+
+### 2. Generated Config Values (from `no_ego.js`)
+```javascript
+{
+  "component_dir": ".app/ssr/components",
+  "component_dir_ssr": ".app/ssr/components",
+  "component_dir_client": "/assets/components",
+  "component_base_path": "/assets",
+  "assets_build_dir": ".app/assets/components",
+  "component_suffix": "components"
+}
+```
+
+### 3. Express Static Mounts (4 total)
+
+**Mount 1** (`runtime.js` line 701-702):
+```javascript
+app.use('/client', express.static('/dist/.app/assets'))
+```
+
+**Mount 2** (`runtime.js` line 703-704):
+```javascript
+app.use('/chunks', express.static('/dist/.app/ssr/chunks'))
+```
+
+**Mount 3** (Forge `server.ts` via `client.js` assets):
+```javascript
+app.use('/', express.static('/dist/.app/assets'))
+app.use('/assets', express.static('/dist/.app/assets'))
+```
+
+**Mount 4** (Forge `server.ts` line 135-137):
+```javascript
+app.use('/.app/ssr/components', express.static('/dist/.app/ssr/components'))
+```
+
+### 4. Browser Behavior (Confirmed via Network Tab)
+```
+Browser requests: http://localhost:3050/.app/ssr/components/layout/root.js
+Server responds: 200 OK (serves SSR component file)
+Browser executes: SSR JavaScript with bare imports
+Result: Module not found errors + effect_orphan error
+```
+
+### 5. Forge's Component Directory Injection (Line 264)
+```typescript
+// express_server_adapter.ts:264
+const clientComponentDir = this.isProd ? this.componentDir : '/assets';
+
+// Line 281:
+window.__COMPONENT_DIR__ = ${JSON.stringify(clientComponentDir)}
+```
+
+**In production mode:**
+- `this.componentDir` = `".app/ssr/components"` (passed from hammer/client.js)
+- Therefore: `window.__COMPONENT_DIR__ = ".app/ssr/components"`
+- Browser constructs URLs: `/.app/ssr/components/layout/root.js`
+
+### 6. Forge's Single component_dir Design (Confirmed)
+**File:** `/Users/shavauhngabay/dev/forge/src/options/ServerOptions.ts`
+```typescript
+export interface ServerOptions {
+    component_dir?: string;  // SINGLE option for BOTH SSR and client
+    // NO component_dir_ssr
+    // NO component_dir_client
+}
+```
+
+**Usage in `server.ts` line 67:**
+```typescript
+const COMPONENT_DIR = !full_options.component_dir ? root : path.join(root, full_options.component_dir);
+```
+
+**Used for:**
+- SSR: `ProdComponentLoader(COMPONENT_DIR)` - loads components server-side
+- Client: Passed to `ExpressServerAdapter` → becomes `window.__COMPONENT_DIR__`
+- Static serving: `app.use(\`/\${component_dir}\`, express.static(COMPONENT_DIR))`
+
+---
+
+## The Core Problem
+
+### What's Happening
+1. **hammer/client.js** passes: `component_dir: '.app/ssr/components'`
+2. **Forge** uses this for EVERYTHING:
+   - SSR component loading ✅ (correct - Node.js can load SSR files)
+   - Client directory injection ❌ (wrong - browser gets SSR path)
+   - Static file serving ✅ (Mount 4 serves SSR files at `/.app/ssr/components`)
+3. **Browser** receives: `window.__COMPONENT_DIR__ = ".app/ssr/components"`
+4. **Browser** requests: `/.app/ssr/components/layout/root.js`
+5. **Express** serves SSR component (via Mount 4) ✅
+6. **Browser** executes SSR JavaScript:
+   - Contains bare imports: `import { onMount } from 'svelte'`
+   - Contains chunk imports: `await import("../../chunks/liveWebsocket-BL1FcyHq.js")`
+   - Resolves to: `.app/ssr/chunks/liveWebsocket-BL1FcyHq.js` ❌ (doesn't exist)
+7. **Result:** Module not found → `effect_orphan` error
+
+### Why SSR Components Fail in Browser
+SSR components are compiled for Node.js:
+- Use bare module imports (`'svelte'`, `'svelte/server'`)
+- Expect Node.js module resolution
+- Cannot run in browser environment
+
+Client components are Vite-bundled for browsers:
+- All imports are resolved and bundled
+- Chunks are properly linked
+- Can execute in browser
+
+---
+
+## What We're GUESSING / Hypothesizing
+
+### Hypothesis 1: We're Passing the Wrong Path
+**Theory:** We should pass `component_dir_client` to Forge instead of `component_dir_ssr`.
+
+**Problem:** If we pass `/assets/components`:
+- Browser would load client components ✅ (correct)
+- But SSR would try to load from `/dist/assets/components/` ❌
+- SSR files are actually at `/dist/.app/ssr/components/`
+- SSR would break
+
+**Conclusion:** Forge's single-path design doesn't support separate SSR/client directories.
+
+### Hypothesis 2: Build Output Should Match Forge's Expectations
+**Theory:** Maybe we should output components to a single directory that works for both SSR and client.
+
+**Problem:** SSR and client components are fundamentally different:
+- SSR: ES modules with bare imports (for Node.js)
+- Client: Vite-bundled with resolved imports (for browser)
+- They MUST be separate files
+
+**Conclusion:** We need two directories, not one.
+
+### Hypothesis 3: Forge Needs to Support Separate Paths
+**Theory:** Modify Forge to accept `component_dir_ssr` and `component_dir_client`.
+
+**Changes needed:**
+1. `ServerOptions.ts`: Add new optional fields
+2. `server.ts`: Calculate both paths
+3. `express_server_adapter.ts`: Use client path for `window.__COMPONENT_DIR__`
+4. `ProdComponentLoader`: Use SSR path for server-side loading
+
+**Status:** This seems like the correct solution, but requires Forge modifications.
+
+### Hypothesis 4: Pass Relative Path "components" to Forge
+**Theory:** The original hammer.config.yml specifies `componentDir: frontend/components`. Relative to `frontend/frontend.ts`, this is just `components`. Maybe we should pass just `"components"` to Forge?
+
+**Analysis:**
+- Forge would calculate: `COMPONENT_DIR = /dist/components`
+- Browser would request: `/components/layout/root.js`
+- But files don't exist at `/dist/components/` ❌
+- Files are at `/dist/.app/assets/components/` and `/dist/.app/ssr/components/`
+
+**Conclusion:** This doesn't match our current build structure.
+
+### Hypothesis 5: Change Build Structure
+**Theory:** Output components to `/dist/components/` (single location) instead of separate SSR/client dirs.
+
+**Problems:**
+- How would we differentiate SSR vs client builds?
+- Vite outputs to one location, SSR to another
+- Would require major build pipeline changes
+- Unclear if this is even possible with current tools
+
+**Status:** Needs more investigation into Vite's capabilities.
+
+---
+
+## Original Config Intent
+
+**From `hammer.config.yml`:**
+```yaml
+client:
+  main: frontend/frontend.ts          # UI root: /project/frontend/
+  componentDir: frontend/components   # Components: /project/frontend/components/
+```
+
+**Relative calculation:**
+- UI root: `frontend/`
+- Component dir: `frontend/components/`
+- Relative path: `components/` (just the subdirectory)
+
+**Bootstrap calculates:**
+- `component_dir_ssr`: `.app/ssr/components`
+- `component_dir_client`: `/assets/components`
+
+**The question:** Should Forge receive:
+- Option A: `.app/ssr/components` (full SSR path, current behavior)
+- Option B: `/assets/components` (full client path, breaks SSR)
+- Option C: `components` (relative path, no files at `/dist/components/`)
+- Option D: Both paths via new Forge API
+
+---
+
+## Potential Solutions
+
+### Solution 1: Modify Forge (Most Correct)
+**Pros:**
+- Clean separation of concerns
+- SSR and client use correct directories
+- No breaking changes to build pipeline
+
+**Cons:**
+- Requires Forge modifications
+- Need to update Forge across all projects
+
+**Files to change:**
+1. `forge/src/options/ServerOptions.ts` - Add `component_dir_ssr` and `component_dir_client`
+2. `forge/src/server/server.ts` - Calculate both paths
+3. `forge/src/routing/server_adapter/express_server_adapter.ts` - Use client path for injection
+4. `hammer/src/client.js` - Pass both paths
+
+### Solution 2: Change Hammer Build to Output Single Component Directory
+**Approach:** Build both SSR and client to same location, differentiate by filename suffix.
+
+**Example:**
+```
+dist/components/
+  ├── layout/
+  │   ├── root.ssr.js    # For server-side rendering
+  │   └── root.js        # For browser
+```
+
+**Pros:**
+- Works with Forge's current API
+- No Forge modifications needed
+
+**Cons:**
+- Major build pipeline changes
+- Unclear if Vite supports this pattern
+- May break component loader expectations
+- High risk of regressions
+
+### Solution 3: Pass Client Path to Forge, Handle SSR Separately
+**Approach:** Pass `/assets/components` to Forge, manually load SSR components elsewhere.
+
+**Problems:**
+- How would SSR loading work?
+- Would need to bypass Forge's component loader
+- Unclear if this is even possible
+- High complexity, fragile
+
+### Solution 4: Mount Client Components at SSR Path
+**Approach:** Add another Express mount that serves client components at `/.app/ssr/components`.
+
+**Example:**
+```javascript
+app.use('/.app/ssr/components', express.static('/dist/.app/assets/components'))
+```
+
+**Pros:**
+- No code changes to Forge
+- Quick fix
+
+**Cons:**
+- Conceptually wrong (SSR path serves client files)
+- Confusing for developers
+- SSR would still try to load from wrong location
+- Doesn't fix the root problem
+
+---
+
+## Open Questions
+
+1. **Can Vite output to a single component directory?**
+   - Can we build SSR and client to same location with different naming?
+   - Does this conflict with Vite's chunk optimization?
+
+2. **Does Forge's dev mode work correctly?**
+   - Dev mode uses Vite dev server
+   - Does it have the same SSR/client split issue?
+   - Line 264: `clientComponentDir = this.isProd ? this.componentDir : '/assets'`
+   - In dev: Always uses `/assets` - why does this work?
+
+3. **Is the `.app/` directory structure mandatory?**
+   - Could we output to `/dist/ssr/` and `/dist/assets/` instead?
+   - Would this simplify path calculations?
+
+4. **What did the original Forge design expect?**
+   - Was Forge designed for projects with separate SSR/client builds?
+   - Or was it designed for unified component directories?
+
+5. **Are there other projects using this stack successfully?**
+   - How do they structure their builds?
+   - Can we learn from existing patterns?
+
+---
+
+## Next Steps
+
+1. **Decide on solution approach:**
+   - Option 1: Modify Forge (cleanest, most correct)
+   - Option 2: Restructure build output (risky, high effort)
+   - Option 3: Quick mount hack (temporary workaround)
+
+2. **If Option 1 (Modify Forge):**
+   - Design the new API surface
+   - Write tests for dual-path support
+   - Implement changes in Forge
+   - Update hammer to use new API
+   - Test with markdown_view, liftlog, noblelaw
+
+3. **If Option 2 (Restructure Build):**
+   - Research Vite multi-output capabilities
+   - Design new directory structure
+   - Update build pipeline
+   - Test thoroughly across all projects
+
+4. **Validate the fix:**
+   - Run all 18 unit tests
+   - Test markdown_view in production mode
+   - Verify no `effect_orphan` errors
+   - Confirm browser loads correct (client) components
+   - Verify SSR still works
+
+---
+
+## Timeline Estimate
+
+- **Option 1 (Modify Forge):** 2-3 hours implementation + 1 hour testing
+- **Option 2 (Restructure Build):** 1-2 days research + 2-3 days implementation + 2 hours testing
+- **Option 3 (Quick Hack):** 30 minutes, but doesn't solve root cause
+
+---
+
+## Files Reference
+
+### Confirmed File Locations
+- `/Users/shavauhngabay/dev/hammer/src/client.js` - Passes component_dir to Forge
+- `/Users/shavauhngabay/dev/hammer/src/runtime/runtime.js` - Express static mounts
+- `/Users/shavauhngabay/dev/hammer/src/build/bootstrap.js` - Calculates component paths
+- `/Users/shavauhngabay/dev/forge/src/server/server.ts` - Forge server initialization
+- `/Users/shavauhngabay/dev/forge/src/options/ServerOptions.ts` - Forge options interface
+- `/Users/shavauhngabay/dev/forge/src/routing/server_adapter/express_server_adapter.ts` - Injects window.__COMPONENT_DIR__
+- `/Users/shavauhngabay/dev/forge/src/routing/component_loader/component_loader.ts` - ProdComponentLoader
+- `/Users/shavauhngabay/dev/markdown_view/hammer.config.yml` - Project configuration
+- `/Users/shavauhngabay/dev/markdown_view/dist/no_ego.js` - Generated runtime config
+
+---
+
+**END OF DOCUMENT**
+
+For questions or to proceed with implementation, contact the engineering team.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noego/app",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "Production build tool for Dinner/Forge apps.",
   "type": "module",
   "bin": {
@@ -29,8 +29,9 @@
   "license": "MIT",
   "author": "App Build CLI",
   "dependencies": {
-    "glob-parent": "^6.0.2",
     "deepmerge": "^4.3.1",
+    "glob-parent": "^6.0.2",
+    "http-proxy": "^1.18.1",
     "picomatch": "^2.3.1",
     "yaml": "^2.6.0"
   },

package/src/args.js

@@ -25,12 +25,13 @@ const FLAG_MAP = new Map([
   ['split-serve', 'splitServe'],
   ['frontend-cmd', 'frontendCmd'],
   ['mode', 'mode'],
+  ['verbose', 'verbose'],
   ['help', 'help'],
   ['version', 'version']
 ]);
 
 const MULTI_VALUE_FLAGS = new Set(['sqlGlob', 'assets', 'clientExclude', 'watchPath']);
-const BOOLEAN_FLAGS = new Set(['watch', 'splitServe']);
+const BOOLEAN_FLAGS = new Set(['watch', 'splitServe', 'verbose']);
 
 export function parseCliArgs(argv) {
   const result = {
@@ -158,6 +159,7 @@ Options (shared):
   --split-serve           Run frontend dev server in a separate process (watch mode only)
   --frontend-cmd <name>   Frontend command: currently supports 'vite' (default when split-serve)
   --mode <value>          Build mode forwarded to Vite (default: production)
+  --verbose               Enable verbose debug logging
   --help                  Show this message
   --version               Show App version
 

package/src/build/bootstrap.js

@@ -1,6 +1,104 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
+/**
+ * Calculate all component paths once based on project config.
+ * This is the SINGLE SOURCE OF TRUTH for path calculations.
+ *
+ * @param {object} config - Project config with mode, client.main_abs, client.componentDir_abs
+ * @returns {object} All calculated paths
+ */
+export async function calculateComponentPaths(config) {
+  const uiRootAbs = config.client?.main_abs ? path.dirname(config.client.main_abs) : config.rootDir || config.root;
+  const componentDirAbs = config.client?.componentDir_abs || uiRootAbs;
+  const relativeFromUiRoot = toPosix(path.relative(uiRootAbs, componentDirAbs) || '');
+  const uiRelFromRoot = toPosix(path.relative(config.rootDir || config.root, uiRootAbs) || '');
+  const distAbs = config.outDir_abs || config.outDir || path.resolve(config.rootDir || config.root, 'dist');
+
+  // Compute client filesystem base candidates
+  const clientCandidates = [
+    path.join(distAbs, '.app', 'assets'),
+    path.join(distAbs, 'client'),
+    uiRelFromRoot ? path.join(distAbs, uiRelFromRoot) : null
+  ].filter(Boolean);
+
+  const clientFsBase = await firstExistingDir(clientCandidates) || path.join(distAbs, '.app', 'assets');
+
+  // Determine client public base
+  let client_base_path = '/assets';
+  if (endsWithDir(clientFsBase, path.join(distAbs, uiRelFromRoot))) {
+    client_base_path = `/${uiRelFromRoot}`;
+  }
+  client_base_path = toPosix(client_base_path);
+
+  // Compute client component public base (append component suffix if present)
+  const component_suffix = relativeFromUiRoot || null;
+  const component_dir_client = component_suffix
+    ? toPosix(path.posix.join(client_base_path, component_suffix))
+    : client_base_path;
+
+  // Compute SSR filesystem base candidates
+  const ssrCandidates = [
+    path.join(distAbs, '.app', 'ssr', relativeFromUiRoot),
+    path.join(distAbs, '.app', 'ssr'),
+    path.join(distAbs, 'ssr', relativeFromUiRoot),
+    path.join(distAbs, 'ssr'),
+    uiRelFromRoot ? path.join(distAbs, uiRelFromRoot, relativeFromUiRoot) : null,
+    uiRelFromRoot ? path.join(distAbs, 'server', uiRelFromRoot, relativeFromUiRoot) : null
+  ].filter(Boolean);
+
+  const ssrFsBase = await firstExistingDir(ssrCandidates) || path.join(distAbs, '.app', 'ssr', relativeFromUiRoot || '');
+
+  // Resolve values relative to project root for serialization; generate relative-to-dist for Forge
+  const distRel = (abs) => toPosix(path.relative(distAbs, abs));
+  const rootRel = (abs) => toPosix(path.relative(config.rootDir || config.root, abs));
+
+  // Directories for runtime mounting and Forge consumption
+  const assets_build_root_rel = distRel(clientFsBase) || '.app/assets';
+  const component_dir_ssr = distRel(ssrFsBase) || '.app/ssr';
+
+  return {
+    // Forge SSR base directory (relative to dist root)
+    component_dir_ssr,
+    // Browser public base for component imports
+    component_dir_client,
+    // Browser public base for all assets (CSR root)
+    component_base_path: client_base_path,
+    // Filesystem directory (relative to dist root) that holds client bundle
+    assets_build_dir: assets_build_root_rel,
+    // Extra: absolute paths (resolved at runtime by bootstrap template)
+    assets_build_abs: rootRel(path.join(distAbs, assets_build_root_rel)),
+    ssr_build_abs: rootRel(path.join(distAbs, component_dir_ssr)),
+    component_suffix,
+    // Legacy aliases for backwards compatibility
+    component_dir: component_dir_ssr,
+    componentDir_abs: component_dir_ssr
+  };
+}
+
+async function firstExistingDir(candidates) {
+  for (const p of candidates) {
+    try {
+      const stat = await fs.stat(p);
+      if (stat.isDirectory()) return p;
+    } catch {}
+  }
+  return null;
+}
+
+function endsWithDir(child, parent) {
+  try {
+    const rel = path.relative(parent, child);
+    return rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+  } catch {
+    return false;
+  }
+}
+
+function toPosix(value) {
+  return String(value || '').split(path.sep).join('/');
+}
+
 /**
  * Generates a bootstrap wrapper (no_ego.js) that sets up the runtime environment
  * before importing the compiled application entry.
@@ -47,15 +145,19 @@ export async function generateBootstrap(context) {
       openapi: config.client?.openapi,
       openapi_abs: config.client?.openapi_abs ? './' + path.relative(config.rootDir, config.client.openapi_abs) : null,
       openapi_path: config.client?.openapi,
-      component_dir: config.client?.component_dir,
-      componentDir_abs: config.client?.componentDir_abs ? './' + path.relative(config.rootDir, config.client.componentDir_abs) : null,
-      assetDirs: config.client?.assetDirs || []
+      // Calculate ALL component paths ONCE - used by SSR, client, and Vite
+      // Philosophy: Calculate once in bootstrap, use everywhere without recalculation
+      ...(await calculateComponentPaths(config)),
+      assetDirs: config.client?.assetDirs ? config.client.assetDirs.map(assetDir => ({
+        mountPath: assetDir.mountPath,
+        // Convert absolute path to relative path from project root
+        absolutePath: './' + path.relative(config.rootDir, assetDir.absolutePath)
+      })) : []
     } : undefined,
     dev: {
       port: config.dev?.port || 3000,
       backendPort: config.dev?.backendPort || 3001
-    },
-    assets: []
+    }
   };
 
   // Compute relative path from outDir to compiled entry

package/src/build/html.js

@@ -19,8 +19,8 @@ export async function rewriteHtmlTemplate(context, clientArtifacts) {
     const pattern = new RegExp(`\\s*${escaped}\\s*`, 'g');
     html = html.replace(pattern, '');
   }
-  // Client bundle public base served at '/assets'
-  const clientBase = '/assets';
+  // Client bundle public base served at configured base
+  const clientBase = config.client?.component_base_path || '/assets';
   html = html.replace(/(href|src)=(['"])\/assets\//g, `$1=$2${clientBase}/`);
   // Remove inline dev loader blocks ( import('<whatever>/client.ts') ) and related comments
   html = html.replace(/\s*<!--[^>]*Development[^>]*-->\s*/gi, '');
@@ -56,6 +56,8 @@ export async function rewriteHtmlTemplate(context, clientArtifacts) {
   const scriptTag = `<script type="module" src="${makeClientPublicPath(entryFile)}"></script>`;
   html = injectBeforeClose(html, '</body>', scriptTag);
 
+  // Do not inject window.__COMPONENT_DIR__ here; Forge injects it at response time.
+
   await fs.mkdir(path.dirname(targetPath), { recursive: true });
   await fs.writeFile(targetPath, html, 'utf8');
 

package/src/build/runtime-manifest.js

@@ -27,7 +27,7 @@ export async function writeRuntimeManifest(context, artifacts) {
     client: artifacts.client ? {
       manifest: artifacts.client.manifestPath ? relativeToOut(config, artifacts.client.manifestPath) : null,
       entry: artifacts.client.entryGraph?.entry?.file
-        ? `/assets/${toPosix(artifacts.client.entryGraph.entry.file)}`
+        ? `${config.client?.component_base_path || '/assets'}/${toPosix(artifacts.client.entryGraph.entry.file)}`
         : null
     } : null,
     ssr: artifacts.ssr ? {

package/src/build/server.js

@@ -81,10 +81,12 @@ async function reorganizeServerOutputs(context) {
 
   // Mirror middleware directory into dist root for Dinner runtime lookup
   await fs.rm(middlewareOutDir, { recursive: true, force: true });
-  const middlewareRel = path.relative(config.rootDir, config.server.middlewareDir);
-  if (!middlewareRel.startsWith('..')) {
-    const compiledMiddleware = path.join(serverOutDir, middlewareRel);
-    await copyTree(compiledMiddleware, middlewareOutDir);
+  if (config.server.middlewareDir) {
+    const middlewareRel = path.relative(config.rootDir, config.server.middlewareDir);
+    if (!middlewareRel.startsWith('..')) {
+      const compiledMiddleware = path.join(serverOutDir, middlewareRel);
+      await copyTree(compiledMiddleware, middlewareOutDir);
+    }
   }
 
   logger.info('Server TypeScript output staged');
@@ -162,6 +164,14 @@ async function mirrorUiModules(context) {
   await fs.rm(destinationDir, { recursive: true, force: true }).catch(() => {});
 
   // Overlay compiled UI outputs from tsc emit so .ts becomes .js under mirrored UI root
+  if (config.verbose) {
+    console.log('[server] overlayUi called:', {
+      'config.ui': config.ui,
+      'config.ui.rootDir': config.ui?.rootDir,
+      'config.rootDir': config.rootDir
+    });
+  }
+
   const compiledUiDir = path.join(
     config.layout.serverOutDir,
     path.relative(config.rootDir, config.ui.rootDir)