@celsian/vura-cli 0.5.14 → 0.6.1

package/dist/commands/build.js

@@ -11,9 +11,11 @@
  * 8. Write manifest.json
  * 9. Emit hot deploy templates (Dockerfile, fly.toml, package.json) when hot routes present
  */
-import { buildManifest, build, renderStaticPages, generateClientPageEntry } from '@celsian/vura-core';
+import { buildManifest, build, renderStaticPages, generateClientPageEntry, vuraBrowserResolvePlugin } from '@celsian/vura-core';
 import { createRequire } from 'node:module';
-import { Buffer } from 'node:buffer';
+import { existsSync, readFileSync } from 'node:fs';
+import { join as pathJoin, resolve as pathResolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { loadConfig } from '../config-loader.js';
 // ---------------------------------------------------------------------------
 // Deploy template strings — inlined so they survive tsc compilation (tsc does
@@ -60,23 +62,32 @@ kill_timeout = "30s"
   min_machines_running = 1
 `;
 const nativeImport = (specifier) => import(/* @vite-ignore */ specifier);
-const moduleSourceToDataUrl = (source) => `data:text/javascript;base64,${Buffer.from(source).toString('base64')}`;
 /**
- * Emit Dockerfile and fly.toml into dist/ when the project has hot routes.
- * Also writes/merges dist/package.json so that `npm install --omit=dev` in the
- * Docker build pulls the right runtime deps (ws when WS routes are present).
+ * Write dist/package.json.
+ *
+ * `npm install --omit=dev` inside the Docker build resolves against this file,
+ * so it has to list every bare specifier the emitted bundles still import at
+ * runtime. Two do:
+ *
+ *   - `what-framework`, because API and page route modules are bundled with it
+ *     kept external (see bundleRouteModule's `keepWhatFwExternal`). Without the
+ *     dependency the container starts and dies on the first request to any API
+ *     route with `ERR_MODULE_NOT_FOUND: what-framework/server`. It was only ever
+ *     absent from this file, never from the imports.
+ *   - `ws`, when the project has WebSocket routes.
+ *
+ * It is pinned to the version the project actually resolved, so the container
+ * runs the What the app was built and tested against rather than whatever
+ * `latest` is on deploy day.
+ *
+ * This runs for EVERY build. It used to run only for projects with hot routes,
+ * which is unrelated to whether the bundles import anything.
  */
-async function emitHotDeployTemplates(distDir, appName, hasWsRoutes) {
+async function emitDeployPackageJson(distDir, projectRoot, hasWsRoutes) {
     const { writeFile, readFile, mkdir } = await import('node:fs/promises');
     const { existsSync } = await import('node:fs');
     const { join } = await import('node:path');
     await mkdir(distDir, { recursive: true });
-    // Dockerfile
-    await writeFile(join(distDir, 'Dockerfile'), DOCKERFILE_HOT, 'utf8');
-    // fly.toml — replace {{APP_NAME}} placeholder
-    const flyToml = FLY_TOML_TMPL.replace('{{APP_NAME}}', appName);
-    await writeFile(join(distDir, 'fly.toml'), flyToml, 'utf8');
-    // dist/package.json — create or merge
     const pkgPath = join(distDir, 'package.json');
     let existing = {};
     if (existsSync(pkgPath)) {
@@ -87,13 +98,66 @@ async function emitHotDeployTemplates(distDir, appName, hasWsRoutes) {
             console.warn('  Warning: dist/package.json is malformed JSON — regenerating from scratch.');
         }
     }
-    const merged = { ...existing, type: 'module' };
-    if (hasWsRoutes) {
-        const existingDeps = existing.dependencies ?? {};
-        merged.dependencies = { ...existingDeps, ws: '8.18.0' };
+    const deps = { ...(existing.dependencies ?? {}) };
+    const whatVersion = resolveWhatFrameworkVersion(projectRoot);
+    if (whatVersion) {
+        deps['what-framework'] = whatVersion;
     }
+    else {
+        console.warn('  Warning: could not resolve what-framework in this project, so dist/package.json ' +
+            'does not declare it. A container build will fail to resolve `what-framework/server` ' +
+            'from the emitted API route bundles.');
+    }
+    if (hasWsRoutes)
+        deps.ws = '8.18.0';
+    const merged = { ...existing, type: 'module' };
+    if (Object.keys(deps).length > 0)
+        merged.dependencies = deps;
     await writeFile(pkgPath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
 }
+/** The exact what-framework version installed in the project, or null. */
+function resolveWhatFrameworkVersion(projectRoot) {
+    // Read the installed package.json off disk instead of resolving the
+    // specifier. `require('what-framework/package.json')` looks like the obvious
+    // way to do this and cannot work: what-framework's `exports` map lists `.`,
+    // `./server`, `./router` and friends, and Node refuses any subpath an
+    // exports map does not name — including './package.json'. Every real install
+    // therefore threw ERR_PACKAGE_PATH_NOT_EXPORTED, the version came back null,
+    // and dist/package.json shipped without the dependency the container needs.
+    let dir = projectRoot;
+    for (let depth = 0; depth < 10; depth++) {
+        const candidate = pathJoin(dir, 'node_modules', 'what-framework', 'package.json');
+        if (existsSync(candidate)) {
+            try {
+                const manifest = JSON.parse(readFileSync(candidate, 'utf8'));
+                if (typeof manifest.version === 'string')
+                    return manifest.version;
+            }
+            catch {
+                return null;
+            }
+            return null;
+        }
+        const parent = pathResolve(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Emit Dockerfile and fly.toml into dist/ when the project has hot routes.
+ */
+async function emitHotDeployTemplates(distDir, appName) {
+    const { writeFile, mkdir } = await import('node:fs/promises');
+    const { join } = await import('node:path');
+    await mkdir(distDir, { recursive: true });
+    // Dockerfile
+    await writeFile(join(distDir, 'Dockerfile'), DOCKERFILE_HOT, 'utf8');
+    // fly.toml — replace {{APP_NAME}} placeholder
+    const flyToml = FLY_TOML_TMPL.replace('{{APP_NAME}}', appName);
+    await writeFile(join(distDir, 'fly.toml'), flyToml, 'utf8');
+}
 export async function buildCommand(_args) {
     const startTime = Date.now();
     const projectRoot = process.cwd();
@@ -113,8 +177,9 @@ export async function buildCommand(_args) {
     // Shared esbuild helpers
     const { build: esbuild } = await import('esbuild');
     const { join, resolve } = await import('node:path');
-    const { mkdir } = await import('node:fs/promises');
+    const { mkdir, readFile, rename } = await import('node:fs/promises');
     const { existsSync } = await import('node:fs');
+    const { createHash } = await import('node:crypto');
     const cliRequire = createRequire(import.meta.url);
     const projectRequire = createRequire(join(root, 'package.json'));
     // Determine JSX import source from the user's project, not from the CLI's own
@@ -282,10 +347,19 @@ export async function buildCommand(_args) {
                 outfile: outPath,
                 jsx: 'automatic',
                 jsxImportSource,
-                plugins: [esmResolvePlugin],
+                // Browser-resolve first: a page that imports `@celsian/vura-core` for
+                // useLoaderData must get the pure client module here, not the package
+                // root, which reaches node:fs and cannot be bundled for a browser.
+                plugins: [vuraBrowserResolvePlugin(), esmResolvePlugin],
                 external: [],
             });
-            const scriptPath = `/_then/pages/${outFile.replace(/\\/g, '/')}`;
+            const bundleHash = createHash('sha256')
+                .update(await readFile(outPath))
+                .digest('hex')
+                .slice(0, 12);
+            const hashedOutFile = outFile.replace(/\.js$/, `.${bundleHash}.js`);
+            await rename(outPath, join(clientPagesDir, hashedOutFile));
+            const scriptPath = `/_then/pages/${hashedOutFile.replace(/\\/g, '/')}`;
             clientScripts[page.filePath] = scriptPath;
             console.log(`    ◇ ${page.urlPattern} → dist/static${scriptPath}`);
         }
@@ -304,23 +378,44 @@ export async function buildCommand(_args) {
         console.log(`  Rendering ${staticPages.length} build-time pages...`);
         const tmpDir = join(root, 'dist', '.page-tmp');
         await mkdir(tmpDir, { recursive: true });
+        // A build-time page is imported into THIS process and rendered by core's
+        // own `renderToString`. Two rules follow, and breaking either one produces
+        // a failure that looks like a framework bug rather than a bundling one:
+        //
+        //  1. `what-framework` and `@celsian/vura-core` stay external. Inlining
+        //     them gives the page a second copy of the framework, with its own
+        //     "currently rendering component" and its own context registry — so
+        //     every hook the page calls, `useLoaderData` included, reads a
+        //     registry that the renderer never wrote to and reports being called
+        //     outside a render.
+        //  2. The bundle is written to a real file rather than imported as a
+        //     `data:` URL. A data: module has no parent path, so it cannot resolve
+        //     the bare specifiers rule 1 just created, and anything it does inline
+        //     that calls `fileURLToPath(import.meta.url)` at module scope throws
+        //     "The URL must be of scheme file".
+        const sharedRuntimeExternals = [
+            'what-framework',
+            'what-framework/*',
+            '@celsian/vura-core',
+            '@celsian/vura-core/*',
+        ];
+        let pageModuleSeq = 0;
         const loadModule = async (filePath) => {
             const absPath = resolve(root, filePath);
-            const result = await esbuild({
+            const tmpFile = join(tmpDir, `page-${pageModuleSeq++}.mjs`);
+            await esbuild({
                 entryPoints: [absPath],
                 bundle: true,
                 format: 'esm',
                 target: 'es2022',
                 platform: 'node',
-                write: false,
-                outfile: 'page.mjs',
+                outfile: tmpFile,
                 jsx: 'automatic',
                 jsxImportSource,
                 plugins: [esmResolvePlugin],
-                external: [],
+                external: sharedRuntimeExternals,
             });
-            const bundledSource = result.outputFiles[0].text;
-            return nativeImport(moduleSourceToDataUrl(bundledSource));
+            return nativeImport(pathToFileURL(tmpFile).href);
         };
         const outDir = join(root, 'dist');
         const rendered = await renderStaticPages(staticPages, loadModule, outDir, { clientScripts });
@@ -353,15 +448,18 @@ export async function buildCommand(_args) {
     }
     // 9. Emit hot deploy templates when the project has hot routes
     const hotRoutes = manifest.api.filter(r => r.kind === 'hot');
+    const hasWsRoutes = hotRoutes.some(r => r.hasWebsocket === true);
+    const distDir = join(root, 'dist');
+    // Always: the emitted bundles import `what-framework` at runtime whether or
+    // not the project has hot routes.
+    await emitDeployPackageJson(distDir, root, hasWsRoutes);
     if (hotRoutes.length > 0) {
         const { basename } = await import('node:path');
         const rawName = basename(root);
         // sanitize to lowercase [a-z0-9-], truncate to Fly's ~30-char DNS label limit,
         // then strip any trailing dashes introduced by truncation
         const appName = rawName.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 30).replace(/-+$/, '') || 'vura-app';
-        const hasWsRoutes = hotRoutes.some(r => r.hasWebsocket === true);
-        const distDir = join(root, 'dist');
-        await emitHotDeployTemplates(distDir, appName, hasWsRoutes);
+        await emitHotDeployTemplates(distDir, appName);
         console.log(`  Emitted dist/Dockerfile, dist/fly.toml, dist/package.json (app: ${appName}${hasWsRoutes ? ', ws: true' : ''})`);
     }
     const elapsed = Date.now() - startTime;

package/dist/commands/dev.js

@@ -14,7 +14,7 @@
  */
 import { renderToString as builtinRenderToString } from 'what-framework/server';
 import { importRouteModule } from './shared.js';
-import { buildManifest, compilePageRoutes, matchPageRoute, compileRoutes, matchApiPath, getLogger, wrapDocument, escapeHtml, parseNodeBody, reportError, getMimeType, runTaskOnce, buildTaskEnvelope, createApiApp, createWsUpgradeHandler, createNoServerWebSocketServer, GLOBAL_HOOKS_FILENAMES, nodeToWebRequest, writeWebResponse, generateClientPageEntry, } from '@celsian/vura-core';
+import { buildManifest, compilePageRoutes, matchPageRoute, compileRoutes, matchApiPath, getLogger, wrapDocument, escapeHtml, parseNodeBody, reportError, getMimeType, runTaskOnce, buildTaskEnvelope, createApiApp, createWsUpgradeHandler, createNoServerWebSocketServer, GLOBAL_HOOKS_FILENAMES, nodeToWebRequest, writeWebResponse, generateClientPageEntry, vuraBrowserResolvePlugin, } from '@celsian/vura-core';
 export function parseDevOptions(args, projectRoot = process.cwd()) {
     const portArg = args.find((_, i) => args[i - 1] === '--port');
     const hostArg = args.find((_, i) => args[i - 1] === '--host');
@@ -276,6 +276,9 @@ export async function startStandaloneServer(manifest, opts) {
             outfile: 'page.js',
             jsx: 'automatic',
             jsxImportSource,
+            // Same redirect the production build applies: `@celsian/vura-core` in a
+            // browser bundle resolves to the pure client module.
+            plugins: [vuraBrowserResolvePlugin()],
             nodePaths: [join(opts.projectRoot, 'node_modules')],
         });
         const text = result.outputFiles[0].text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celsian/vura-cli",
-  "version": "0.5.14",
+  "version": "0.6.1",
   "description": "Vura CLI — build and deploy full-stack apps",
   "type": "module",
   "bin": {
@@ -15,12 +15,12 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@celsian/vura-core": "0.5.14",
+    "@celsian/vura-core": "0.6.1",
     "esbuild": "^0.28.1",
-    "what-framework": "^0.11.1"
+    "what-framework": "^0.13.2"
   },
   "peerDependencies": {
-    "@celsian/vura-adapter-vura": "0.5.14",
+    "@celsian/vura-adapter-vura": "0.6.1",
     "ws": "^8.0.0"
   },
   "peerDependenciesMeta": {
@@ -32,7 +32,7 @@
     }
   },
   "devDependencies": {
-    "@celsian/vura-adapter-vura": "0.5.14",
+    "@celsian/vura-adapter-vura": "0.6.1",
     "@types/ws": "^8.18.1",
     "ws": "^8.21.0"
   },