@noego/app 0.0.7 → 0.0.10

package/scripts/watch-harness.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chokidar from 'chokidar';
+import picomatch from 'picomatch';
+
+const PLAYGROUND_DIR = path.join(process.cwd(), '.watch-harness');
+const sharedPatterns = ['index.ts', 'hammer.config.yml'];
+const backendPatterns = [
+  'server/**/*.ts',
+  'middleware/**/*.ts',
+  'server/stitch.yaml',
+  'server/openapi/**/*.yaml',
+  'server/repo/**/*.sql'
+];
+const frontendPatterns = [
+  'ui/**/*.ts',
+  'ui/stitch.yaml',
+  'ui/openapi/**/*.yaml'
+];
+const allPatterns = [...sharedPatterns, ...backendPatterns, ...frontendPatterns];
+
+const seedFiles = {
+  'index.ts': '// root entry\n',
+  'hammer.config.yml': '# config\n',
+  'server/server.ts': '// server bootstrap\n',
+  'server/services/admin_service.ts': '// admin service seed\n',
+  'middleware/logger.ts': '// middleware seed\n',
+  'server/stitch.yaml': 'openapi: 3.0.0\n',
+  'server/openapi/routes.yaml': 'paths: {}\n',
+  'server/repo/example/query.sql': 'select 1;\n',
+  'ui/frontend.ts': '// frontend entry\n',
+  'ui/stitch.yaml': 'paths: {}\n',
+  'ui/openapi/page.yaml': 'paths: {}\n',
+  'ui/pages/home.ts': 'export const home = true;\n'
+};
+
+const changeSequence = [
+  { label: 'backend', file: 'server/services/admin_service.ts' },
+  { label: 'frontend', file: 'ui/pages/home.ts' },
+  { label: 'shared', file: 'hammer.config.yml' }
+];
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+let backendProc = null;
+let frontendProc = null;
+let watcher = null;
+let shuttingDown = false;
+let pendingRestart = false;
+let backendRestartCount = 0;
+let frontendRestartCount = 0;
+let readyHandled = false;
+
+async function preparePlayground() {
+  await fs.rm(PLAYGROUND_DIR, { recursive: true, force: true }).catch(() => {});
+  await fs.mkdir(PLAYGROUND_DIR, { recursive: true });
+  await Promise.all(
+    Object.entries(seedFiles).map(async ([relative, contents]) => {
+      const absolute = path.join(PLAYGROUND_DIR, relative);
+      await fs.mkdir(path.dirname(absolute), { recursive: true });
+      await fs.writeFile(absolute, contents);
+    })
+  );
+}
+
+function spawnChild(label) {
+  const child = spawn(process.execPath, ['-e', `
+    console.log('[${label}] booting (pid', process.pid, ')');
+    let counter = 0;
+    setInterval(() => {
+      counter += 1;
+      console.log('[${label}] heartbeat #' + counter);
+    }, 750);
+  `], {
+    stdio: ['ignore', 'inherit', 'inherit']
+  });
+  child.on('exit', (code, signal) => {
+    console.log(`[${label}] exited`, { code, signal });
+  });
+  return child;
+}
+
+function startBackend() {
+  backendRestartCount += 1;
+  console.log(`🚀 [backend restart #${backendRestartCount}] starting mock backend`);
+  backendProc = spawnChild('backend');
+}
+
+function startFrontend() {
+  frontendRestartCount += 1;
+  console.log(`🚀 [frontend restart #${frontendRestartCount}] starting mock frontend`);
+  frontendProc = spawnChild('frontend');
+}
+
+function stopProcess(proc, label) {
+  return new Promise((resolve) => {
+    if (!proc || proc.killed) {
+      return resolve();
+    }
+    const timeout = setTimeout(() => {
+      console.warn(`[${label}] did not exit in time, forcing SIGKILL`);
+      try {
+        proc.kill('SIGKILL');
+      } catch {}
+      resolve();
+    }, 2000);
+    proc.once('exit', () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+    try {
+      proc.kill('SIGTERM');
+    } catch {
+      clearTimeout(timeout);
+      resolve();
+    }
+  });
+}
+
+async function shutdown(exitCode = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log('[harness] shutting down...');
+  try {
+    if (watcher) {
+      await watcher.close();
+    }
+  } catch (error) {
+    console.error('[harness] watcher close error', error);
+  }
+  await stopProcess(backendProc, 'backend');
+  await stopProcess(frontendProc, 'frontend');
+  await fs.rm(PLAYGROUND_DIR, { recursive: true, force: true }).catch(() => {});
+  process.exit(exitCode);
+}
+
+async function handleFileChange(reason, relativePath, matchers) {
+  if (pendingRestart) return;
+  pendingRestart = true;
+  const normalized = relativePath.replace(/\\/g, '/');
+  const { sharedMatcher, backendMatcher, frontendMatcher } = matchers;
+  let restartBackend = false;
+  let restartFrontend = false;
+
+  if (sharedMatcher && sharedMatcher(normalized)) {
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`🔄 change detected (${reason}): ${normalized}`);
+    console.log('   type: SHARED -> restarting backend + frontend');
+    console.log(`${'='.repeat(60)}\n`);
+    restartBackend = true;
+    restartFrontend = true;
+  } else if (backendMatcher && backendMatcher(normalized)) {
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`🔄 change detected (${reason}): ${normalized}`);
+    console.log('   type: BACKEND -> restarting backend only');
+    console.log(`${'='.repeat(60)}\n`);
+    restartBackend = true;
+  } else if (frontendMatcher && frontendMatcher(normalized)) {
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`🔄 change detected (${reason}): ${normalized}`);
+    console.log('   type: FRONTEND -> restarting frontend only');
+    console.log(`${'='.repeat(60)}\n`);
+    restartFrontend = true;
+  } else {
+    console.log(`[harness] change ignored (no matcher): ${normalized}`);
+  }
+
+  if (restartBackend) {
+    await stopProcess(backendProc, 'backend');
+    startBackend();
+  }
+  if (restartFrontend) {
+    await stopProcess(frontendProc, 'frontend');
+    startFrontend();
+  }
+  if (restartBackend || restartFrontend) {
+    console.log('✅ restart sequence complete\n');
+  }
+  pendingRestart = false;
+}
+
+async function simulateChanges() {
+  for (const step of changeSequence) {
+    await delay(500);
+    const target = path.join(PLAYGROUND_DIR, step.file);
+    console.log(`[harness] simulating ${step.label} change: ${step.file}`);
+    await fs.appendFile(target, `\n// touched ${Date.now()}`);
+  }
+  console.log('[harness] change simulation complete');
+}
+
+async function runHarness() {
+  await preparePlayground();
+
+  const normalizePattern = (pattern) => pattern;
+  const sharedMatcher = picomatch(sharedPatterns.map(normalizePattern));
+  const backendMatcher = picomatch(backendPatterns.map(normalizePattern));
+  const frontendMatcher = picomatch(frontendPatterns.map(normalizePattern));
+
+  watcher = chokidar.watch(allPatterns, {
+    cwd: PLAYGROUND_DIR,
+    ignoreInitial: true
+  });
+
+  const autoTimeout = setTimeout(() => {
+    console.error('[harness] timeout waiting for restarts');
+    shutdown(1);
+  }, 15000);
+
+  watcher.on('ready', async () => {
+    if (readyHandled) {
+      return;
+    }
+    readyHandled = true;
+    console.log('[harness] watcher ready');
+    startBackend();
+    startFrontend();
+    await simulateChanges();
+    setTimeout(async () => {
+      clearTimeout(autoTimeout);
+      await shutdown(0);
+    }, 1500);
+  });
+
+  watcher.on('all', (event, file) => {
+    if (!['add', 'change', 'unlink'].includes(event)) {
+      return;
+    }
+    handleFileChange(event, file, { sharedMatcher, backendMatcher, frontendMatcher });
+  });
+
+  watcher.on('error', async (error) => {
+    console.error('[harness] watcher error', error);
+    await shutdown(1);
+  });
+}
+
+process.on('SIGINT', () => shutdown(0));
+process.on('SIGTERM', () => shutdown(0));
+
+runHarness().catch((error) => {
+  console.error('[harness] fatal error', error);
+  shutdown(1);
+});

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)

package/src/build/ssr.js

@@ -57,20 +57,53 @@ export async function buildSsr(context, discovery) {
   const manifestPath = path.join(config.layout.ssrOutDir, 'manifest.json');
   await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 
-  // Overlay SSR compiled modules into the mirrored UI root so runtime imports
-  // like component_path.replace('.svelte', '.js') resolve without loaders.
-  try {
-    await fs.mkdir(config.layout.uiOutDir, { recursive: true });
-    await fs.cp(config.layout.ssrOutDir, config.layout.uiOutDir, { recursive: true, force: true });
-  } catch (err) {
-    // non-fatal; report via console for visibility
-    console.warn('Failed to overlay SSR output into UI root:', err?.message || err);
+  // No overlay needed - Forge loads components directly from .app/ssr/
+  // Write entry-ssr.js to where components actually are (preserving full relative path)
+  const relativeComponentDir = config.client?.component_dir ? (() => {
+    const uiRoot = path.dirname(config.client.main_abs);
+    return path.relative(uiRoot, config.client.componentDir_abs);
+  })() : null;
+
+  const ssrComponentsDir = relativeComponentDir
+    ? path.join(config.layout.ssrOutDir, relativeComponentDir)
+    : config.layout.ssrOutDir;
+
+  // Copy RecursiveRender.js to components subdirectory if needed
+  if (relativeComponentDir && await pathExists(path.join(config.layout.ssrOutDir, 'RecursiveRender.js'))) {
+    await fs.mkdir(ssrComponentsDir, { recursive: true });
+    await fs.copyFile(
+      path.join(config.layout.ssrOutDir, 'RecursiveRender.js'),
+      path.join(ssrComponentsDir, 'RecursiveRender.js')
+    );
   }
 
-  await writeSsrEntryModule(context, resolution.components).catch((err) => {
+  await writeSsrEntryModule(context, resolution.components, ssrComponentsDir).catch((err) => {
     logger.warn(`Failed to generate SSR entry module: ${err?.message || err}`);
   });
 
+  // Minimal SSR parity fix: copy compiled loader files (*.load.js) from mirrored UI output
+  // into the SSR components directory so Forge can resolve loaders adjacent to SSR modules.
+  await copySsrLoaders(context, {
+    uiOutDir: config.layout.uiOutDir,
+    relativeComponentDir,
+    ssrComponentsDir
+  }).catch((err) => {
+    logger.warn(`Failed to copy SSR loaders: ${err?.message || err}`);
+  });
+
+  // Also copy UI support modules used by loaders via relative paths (e.g., '../../utils').
+  // This ensures SSR loader imports like '../../utils/api.js' resolve under SSR base.
+  const uiUtilsDir = path.join(config.layout.uiOutDir, 'utils');
+  const ssrUtilsDir = path.join(config.layout.ssrOutDir, 'utils');
+  if (await pathExists(uiUtilsDir)) {
+    try {
+      await fs.mkdir(path.dirname(ssrUtilsDir), { recursive: true });
+      await fs.cp(uiUtilsDir, ssrUtilsDir, { recursive: true, force: true });
+    } catch (e) {
+      logger.warn(`Failed to copy SSR utils directory: ${e?.message || e}`);
+    }
+  }
+
   return {
     manifestPath,
     manifest
@@ -132,10 +165,10 @@ async function buildForgeRecursiveRenderer(context) {
   }
 }
 
-async function writeSsrEntryModule(context, componentList = []) {
+async function writeSsrEntryModule(context, componentList = [], targetDir = null) {
   const { config } = context;
-  const uiOutDir = config.layout.uiOutDir;
-  const entryPath = path.join(uiOutDir, 'entry-ssr.js');
+  const outputDir = targetDir || config.layout.uiOutDir;
+  const entryPath = path.join(outputDir, 'entry-ssr.js');
 
   const uniqueComponents = Array.from(
     new Set(
@@ -151,7 +184,7 @@ async function writeSsrEntryModule(context, componentList = []) {
 
   for (const component of uniqueComponents) {
     const jsPathRelative = toPosix(component.replace(/\.svelte$/, '.js'));
-    const absoluteJsPath = path.join(uiOutDir, jsPathRelative);
+    const absoluteJsPath = path.join(outputDir, jsPathRelative);
     try {
       await fs.access(absoluteJsPath);
     } catch {
@@ -184,6 +217,81 @@ function toPosix(value) {
   return value.split(path.sep).join('/');
 }
 
+async function copySsrLoaders(context, { uiOutDir, relativeComponentDir, ssrComponentsDir }) {
+  const { requireFromRoot } = context;
+  if (!uiOutDir || !ssrComponentsDir) return;
+
+  const sourceRoot = relativeComponentDir
+    ? path.join(uiOutDir, relativeComponentDir)
+    : uiOutDir;
+
+  let glob;
+  try {
+    const globModule = requireFromRoot('glob');
+    glob = typeof globModule === 'function' ? globModule : globModule.glob.bind(globModule);
+  } catch {
+    glob = null;
+  }
+
+  // If glob is unavailable, do a shallow fallback copy of known locations
+  if (!glob) {
+    await copyLoaderTree(sourceRoot, ssrComponentsDir);
+    return;
+  }
+
+  const patterns = [
+    '**/*.load.js'
+  ];
+
+  for (const pattern of patterns) {
+    // eslint-disable-next-line no-await-in-loop
+    const matches = await glob(pattern, {
+      cwd: sourceRoot,
+      absolute: false,
+      nodir: true,
+      dot: true
+    });
+    for (const rel of matches) {
+      const from = path.join(sourceRoot, rel);
+      const to = path.join(ssrComponentsDir, rel);
+      // eslint-disable-next-line no-await-in-loop
+      await fs.mkdir(path.dirname(to), { recursive: true });
+      // eslint-disable-next-line no-await-in-loop
+      await fs.copyFile(from, to).catch(() => {});
+    }
+  }
+}
+
+async function copyLoaderTree(source, destination) {
+  try {
+    const entries = await fs.readdir(source, { withFileTypes: true });
+    for (const entry of entries) {
+      const from = path.join(source, entry.name);
+      const to = path.join(destination, entry.name);
+      if (entry.isDirectory()) {
+        // eslint-disable-next-line no-await-in-loop
+        await copyLoaderTree(from, to);
+      } else if (entry.isFile() && /\.load\.js$/.test(entry.name)) {
+        // eslint-disable-next-line no-await-in-loop
+        await fs.mkdir(path.dirname(to), { recursive: true });
+        // eslint-disable-next-line no-await-in-loop
+        await fs.copyFile(from, to).catch(() => {});
+      }
+    }
+  } catch {
+    // ignore
+  }
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function loadSveltePluginModule(context, searchRoots = []) {
   const attempted = new Set();
   for (const root of searchRoots.filter(Boolean)) {
@@ -243,6 +351,15 @@ function buildSsrManifest(config, discovery) {
 }
 
 function componentToSsrPath(componentPath, config) {
+  if (config.verbose) {
+    console.log('[ssr] componentToSsrPath called:', {
+      componentPath,
+      'config.ui': config.ui,
+      'config.ui.rootDir': config.ui?.rootDir,
+      'config.rootDir': config.rootDir
+    });
+  }
+
   const relative = componentPath.startsWith('.')
     ? path.normalize(componentPath)
     : componentPath;

package/src/build/ui-common.js

@@ -62,9 +62,15 @@ export async function createUiBuildConfig(context, options) {
   if (entryResolved) inputSet.add(entryResolved);
 
   for (const relative of componentRelatives) {
-    const absolute = path.resolve(config.ui.rootDir, relative);
+    const absFromUi = config.ui.rootDir ? path.resolve(config.ui.rootDir, relative) : null;
+    const absFromComp = config.client?.componentDir_abs ? path.resolve(config.client.componentDir_abs, relative) : null;
+    let absolute = absFromUi;
     // eslint-disable-next-line no-await-in-loop
-    if (await fileExists(absolute)) {
+    if (absFromComp && await fileExists(absFromComp)) {
+      absolute = absFromComp;
+    }
+    // eslint-disable-next-line no-await-in-loop
+    if (absolute && await fileExists(absolute)) {
       presentComponents.push(relative);
       inputSet.add(absolute);
     } else {
@@ -83,6 +89,11 @@ export async function createUiBuildConfig(context, options) {
     configFile,
     mode: config.mode,
     root: config.ui.rootDir,
+    // Use precalculated base path from bootstrap config
+    // Bootstrap determines this based on project structure
+    // SSR: undefined (Node doesn't need base path)
+    // Client: configured public base for assets (e.g., '/assets' or '/frontend')
+    base: ssr ? undefined : (config.client?.component_base_path || '/assets'),
     plugins: [
       clientExcludePlugin(config.ui.clientExclude, { projectRoot: config.rootDir })
     ],
@@ -166,6 +177,12 @@ function createEntryFileNames(context, entryResolved) {
       if (!relToUi.startsWith('..')) {
         return toOutputPath(relToUi);
       }
+      if (config.client?.componentDir_abs) {
+        const relToComp = path.relative(config.client.componentDir_abs, facade);
+        if (!relToComp.startsWith('..')) {
+          return toOutputPath(relToComp);
+        }
+      }
       const relToRoot = path.relative(config.rootDir, facade);
       if (!relToRoot.startsWith('..')) {
         return toOutputPath(relToRoot);