meno-core 1.0.53 → 1.1.0

package/lib/server/routes/pages.ts

@@ -3,15 +3,14 @@
  * Handles page route requests with SSR, i18n, and CMS support
  */
 
-import { randomBytes } from 'crypto';
+import { randomBytes } from 'node:crypto';
 import type { RouteContext } from './index';
 import { generateSSRHTML, type SSRHTMLResult } from '../ssrRenderer';
 import { getStaticFilePath } from '../../shared/pathUtils';
 import { parseJSON, loadI18nConfig } from '../jsonLoader';
-import { packagePaths, projectPaths } from '../projectContext';
+import { packagePaths } from '../projectContext';
 import { parseLocaleFromPath } from '../../shared/i18n';
 import { buildSlugIndex, resolveSlugToPageId } from '../../shared/slugTranslator';
-import type { CMSItem } from '../../shared/types';
 import { generateErrorPage } from '../ssr/errorOverlay';
 import { cacheScript, hashContent } from '../scriptCache';
 import { readTextFile, fileExists, serveFile } from '../runtime';
@@ -40,11 +39,7 @@ function generateCspNonce(): string {
 /**
  * Handle page route requests
  */
-export async function handlePageRoute(
-  url: URL,
-  context: RouteContext,
-  req?: Request
-): Promise<Response | undefined> {
+export async function handlePageRoute(url: URL, context: RouteContext, req?: Request): Promise<Response | undefined> {
   const { pageService, componentService, cmsService, injectLiveReload, isEditor, serverPort } = context;
   const pagePath = url.pathname;
   // Editor selection attributes (data-element-path, data-cms-context, ...).
@@ -88,17 +83,26 @@ export async function handlePageRoute(
           cmsMatch.item = draft;
         }
       }
-      // Load template page content by file path
-      const templatePageContent = await loadPageByFilePath(cmsMatch.pagePath);
+      // Load the CMS template page. PageService caches it at `/templates/<collection>`
+      // already converted to JSON — for astro projects the provider parses the
+      // `[slug].astro` dialect file into the JSON model there. Reading the raw file
+      // (loadPageByFilePath) only yields JSON in JSON-format projects; in astro
+      // projects it would hand parseJSON() raw `.astro` source and throw
+      // ("Content that should be valid JSON couldn't be parsed"). Fall back to the raw
+      // read for JSON-project edge cases (template filename ≠ collection id) / a cold cache.
+      const templatePageContent =
+        pageService.getPage(`/templates/${cmsMatch.collection}`) ?? (await loadPageByFilePath(cmsMatch.pagePath));
 
       if (templatePageContent) {
-        // Convert absolute template path to URL path for client-side hydration
-        // e.g., /Users/.../templates/posts.json -> /templates/posts
-        const templatesDir = projectPaths.templates();
-        const cmsTemplatePath = '/templates' + cmsMatch.pagePath
-          .replace(templatesDir, '')    // Remove templates directory prefix
-          .replace(/\\/g, '/')          // Normalize Windows backslashes
-          .replace(/\.json$/, '');      // Remove .json extension
+        // The editor page-path of the CMS template — `/templates/<collectionId>` — which
+        // is also the PageCache key for both formats (JSON provider scans templates/ to
+        // /templates/<stem>; AstroPageProvider maps [slug].astro to /templates/<cms.id>).
+        // The client (window.__MENO_CMS__.templatePath) reloads this on HMR, so it MUST be
+        // the cache key. Deriving it from cmsMatch.pagePath via string-stripping only works
+        // for JSON (a templates/<id>.json file); in astro pagePath is the absolute
+        // src/pages/<col>/[slug].astro, so stripping produced a bogus path → the canvas
+        // rendered the SSR'd page then 404'd on its first HMR/mount reload.
+        const cmsTemplatePath = `/templates/${cmsMatch.collection}`;
 
         try {
           // Parse page JSON
@@ -113,7 +117,7 @@ export async function handlePageRoute(
 
           // SSR preview mode: use external JS file (same pattern as static build)
           if (injectLiveReload) {
-            const result = await generateSSRHTML({
+            const result = (await generateSSRHTML({
               pageData: typedPageData,
               globalComponents: globalComponentsRecord,
               pagePath,
@@ -125,14 +129,14 @@ export async function handlePageRoute(
               cmsService,
               cmsTemplatePath,
               pageLibraries: typedPageData.meta?.libraries,
-            pageCustomCode: typedPageData.meta?.customCode,
+              pageCustomCode: typedPageData.meta?.customCode,
               injectLiveReload,
               injectEditorAttrs,
               isEditor,
               serverPort,
               returnSeparateJS: true,
               cspNonce,
-            }) as SSRHTMLResult;
+            })) as SSRHTMLResult;
 
             let finalHtml = result.html;
             if (result.javascript) {
@@ -145,8 +149,8 @@ export async function handlePageRoute(
               headers: {
                 'Content-Type': 'text/html; charset=utf-8',
                 'Cache-Control': 'no-store, max-age=0',
-                'Pragma': 'no-cache',
-                'Expires': '0',
+                Pragma: 'no-cache',
+                Expires: '0',
                 [CSP_NONCE_HEADER]: cspNonce,
               },
             });
@@ -175,8 +179,8 @@ export async function handlePageRoute(
             headers: {
               'Content-Type': 'text/html; charset=utf-8',
               'Cache-Control': 'no-store, max-age=0',
-              'Pragma': 'no-cache',
-              'Expires': '0',
+              Pragma: 'no-cache',
+              Expires: '0',
               [CSP_NONCE_HEADER]: cspNonce,
             },
           });
@@ -245,7 +249,7 @@ export async function handlePageRoute(
 
       // SSR preview mode: use external JS file (same pattern as static build)
       if (injectLiveReload) {
-        const result = await generateSSRHTML({
+        const result = (await generateSSRHTML({
           pageData,
           globalComponents: globalComponentsRecord,
           pagePath,
@@ -255,14 +259,14 @@ export async function handlePageRoute(
           slugMappings,
           cmsService,
           pageLibraries: pageData.meta?.libraries,
-        pageCustomCode: pageData.meta?.customCode,
+          pageCustomCode: pageData.meta?.customCode,
           injectLiveReload,
           injectEditorAttrs,
           isEditor,
           serverPort,
           returnSeparateJS: true,
           cspNonce,
-        }) as SSRHTMLResult;
+        })) as SSRHTMLResult;
 
         let finalHtml = result.html;
         if (result.javascript) {
@@ -275,8 +279,8 @@ export async function handlePageRoute(
           headers: {
             'Content-Type': 'text/html; charset=utf-8',
             'Cache-Control': 'no-store, max-age=0',
-            'Pragma': 'no-cache',
-            'Expires': '0',
+            Pragma: 'no-cache',
+            Expires: '0',
             [CSP_NONCE_HEADER]: cspNonce,
           },
         });
@@ -303,8 +307,8 @@ export async function handlePageRoute(
         headers: {
           'Content-Type': 'text/html; charset=utf-8',
           'Cache-Control': 'no-store, max-age=0',
-          'Pragma': 'no-cache',
-          'Expires': '0',
+          Pragma: 'no-cache',
+          Expires: '0',
           [CSP_NONCE_HEADER]: cspNonce,
         },
       });

package/lib/server/routes/static.ts

@@ -3,17 +3,22 @@
  * Serves static files and handles TypeScript/TSX file requests
  */
 
-import { join } from 'path';
-import { resolveProjectPath, resolvePackagePath, packagePaths, getProjectRoot, getPackageRoot } from '../projectContext';
+import {
+  resolveProjectPath,
+  resolvePackagePath,
+  packagePaths,
+  getProjectRoot,
+  getPackageRoot,
+} from '../projectContext';
 import { isPathWithinRoot } from '../../shared/pathSecurity';
 import { fileExists, serveFile, bundleFile } from '../runtime';
 
-export async function handleStaticRoute(url: URL, req?: Request): Promise<Response | undefined> {
+export async function handleStaticRoute(url: URL, _req?: Request): Promise<Response | undefined> {
   // Handle client-router requests (both .js and .tsx)
   if (url.pathname === '/client-router.js' || url.pathname === '/client-router.tsx') {
     // Check for pre-bundled version first (Electron packaged mode)
     const preBundledPath = packagePaths.clientRouter().replace(/\.tsx$/, '.js');
-    if (preBundledPath !== packagePaths.clientRouter() && await fileExists(preBundledPath)) {
+    if (preBundledPath !== packagePaths.clientRouter() && (await fileExists(preBundledPath))) {
       return serveFile(preBundledPath, {
         'Content-Type': 'application/javascript',
         'Cache-Control': 'no-cache, no-store, must-revalidate',
@@ -71,7 +76,14 @@ export async function handleStaticRoute(url: URL, req?: Request): Promise<Respon
   // Other static files (editor assets) resolve relative to package root
   let filePath: string;
   let rootPath: string;
-  if (decodedPathname.startsWith('/fonts/') || decodedPathname.startsWith('/images/') || decodedPathname.startsWith('/icons/') || decodedPathname.startsWith('/assets/') || decodedPathname.startsWith('/libraries/') || decodedPathname.startsWith('/videos/')) {
+  if (
+    decodedPathname.startsWith('/fonts/') ||
+    decodedPathname.startsWith('/images/') ||
+    decodedPathname.startsWith('/icons/') ||
+    decodedPathname.startsWith('/assets/') ||
+    decodedPathname.startsWith('/libraries/') ||
+    decodedPathname.startsWith('/videos/')
+  ) {
     rootPath = getProjectRoot();
     filePath = resolveProjectPath(decodedPathname.slice(1)); // Remove leading /
   } else {
@@ -93,4 +105,3 @@ export async function handleStaticRoute(url: URL, req?: Request): Promise<Respon
 
   return undefined;
 }
-

package/lib/server/runtime/bundler.ts

@@ -20,14 +20,31 @@ export interface BundleOptions {
   throw?: boolean;
 }
 
+/** The fields we read from a Bun build-log entry (`Bun.build` result `logs`). */
+interface BunBuildLog {
+  message?: string;
+  position?: { file?: string; line?: number; column?: number; lineText?: string };
+}
+
+/** The fields we read from an esbuild diagnostic message (`error.errors[]`). */
+interface EsbuildMessage {
+  text?: string;
+  location?: { file?: string; line?: number; column?: number; lineText?: string };
+}
+
+/** Structural shape of a thrown build error — Bun exposes `logs`, esbuild `errors`. */
+interface BuildErrorLike {
+  logs?: BunBuildLog[];
+  errors?: EsbuildMessage[];
+  message?: string;
+  stack?: string;
+}
+
 /**
  * Bundle a file entry point.
  * Returns the bundled code as a string.
  */
-export async function bundleFile(
-  entrypoint: string,
-  opts: BundleOptions = {},
-): Promise<BundleResult> {
+export async function bundleFile(entrypoint: string, opts: BundleOptions = {}): Promise<BundleResult> {
   if (isBun) {
     return bundleWithBun(entrypoint, opts);
   }
@@ -61,17 +78,14 @@ export async function validateJS(code: string): Promise<string | null> {
 
 // ── Bun implementations ──────────────────────────────────────────────
 
-async function bundleWithBun(
-  entrypoint: string,
-  opts: BundleOptions,
-): Promise<BundleResult> {
+async function bundleWithBun(entrypoint: string, opts: BundleOptions): Promise<BundleResult> {
   try {
     const result = await Bun.build({
       entrypoints: [entrypoint],
       target: opts.target || 'browser',
       format: opts.format || 'esm',
       minify: opts.minify ?? false,
-      sourcemap: opts.sourcemap === true ? 'inline' : (opts.sourcemap || 'none'),
+      sourcemap: opts.sourcemap === true ? 'inline' : opts.sourcemap || 'none',
       throw: opts.throw ?? false,
     });
 
@@ -80,7 +94,7 @@ async function bundleWithBun(
       return { code, success: true, errors: [] };
     }
 
-    const errors = (result.logs || []).map((log: any) => {
+    const errors = (result.logs || []).map((log) => {
       const parts: string[] = [];
       if (log.position?.file) parts.push(`File: ${log.position.file}`);
       if (log.position?.line) parts.push(`Line ${log.position.line}:${log.position.column || 0}`);
@@ -90,12 +104,13 @@ async function bundleWithBun(
     });
 
     return { code: '', success: false, errors };
-  } catch (err: any) {
+  } catch (err) {
+    const be = err as BuildErrorLike;
     if (opts.throw) throw err;
 
     const errors: string[] = [];
-    if (err.logs && Array.isArray(err.logs)) {
-      for (const log of err.logs) {
+    if (be.logs && Array.isArray(be.logs)) {
+      for (const log of be.logs) {
         const parts: string[] = [];
         if (log.position?.line) parts.push(`Line ${log.position.line}:${log.position.column || 0}`);
         if (log.position?.lineText) parts.push(log.position.lineText);
@@ -103,7 +118,7 @@ async function bundleWithBun(
         errors.push(parts.length > 0 ? parts.join('\n') : String(log));
       }
     } else {
-      errors.push(err.message || String(err));
+      errors.push(be.message || String(err));
     }
 
     return { code: '', success: false, errors };
@@ -111,8 +126,8 @@ async function bundleWithBun(
 }
 
 async function minifyWithBun(code: string): Promise<BundleResult> {
-  const { writeFile, rm } = await import('fs/promises');
-  const { join } = await import('path');
+  const { writeFile, rm: _rm } = await import('node:fs/promises');
+  const { join } = await import('node:path');
   const tempFile = join('/tmp', `meno-minify-${Date.now()}.js`);
 
   try {
@@ -124,36 +139,47 @@ async function minifyWithBun(code: string): Promise<BundleResult> {
       throw: true,
     });
 
-    if (result.outputs.length > 0) {
-      const minified = await result.outputs[0].text();
+    const firstOutput = result.outputs[0];
+    if (firstOutput) {
+      const minified = await firstOutput.text();
       return { code: minified, success: true, errors: [] };
     }
 
     return { code: '', success: false, errors: ['Minification produced no output'] };
-  } catch (err: any) {
+  } catch (err) {
+    const be = err as BuildErrorLike;
     const { inspect } = await import('./fs');
     let details = '';
-    if (err.logs && Array.isArray(err.logs)) {
-      details = err.logs.map((log: any) => {
-        const parts: string[] = [];
-        if (log.position?.line) parts.push(`Line ${log.position.line}:${log.position.column || 0}`);
-        if (log.position?.lineText) parts.push(log.position.lineText);
-        if (log.message) parts.push(log.message);
-        return parts.length > 0 ? parts.join('\n') : String(log);
-      }).join('\n\n');
+    if (be.logs && Array.isArray(be.logs)) {
+      details = be.logs
+        .map((log: BunBuildLog) => {
+          const parts: string[] = [];
+          if (log.position?.line) parts.push(`Line ${log.position.line}:${log.position.column || 0}`);
+          if (log.position?.lineText) parts.push(log.position.lineText);
+          if (log.message) parts.push(log.message);
+          return parts.length > 0 ? parts.join('\n') : String(log);
+        })
+        .join('\n\n');
     }
     if (!details) {
-      try { details = inspect(err); } catch { details = err.stack || err.message || String(err); }
+      try {
+        details = inspect(err);
+      } catch {
+        details = be.stack || be.message || String(err);
+      }
     }
     return { code: '', success: false, errors: [details] };
   } finally {
-    try { const { rm } = await import('fs/promises'); await rm(tempFile, { force: true }); } catch {}
+    try {
+      const { rm } = await import('node:fs/promises');
+      await rm(tempFile, { force: true });
+    } catch {}
   }
 }
 
 async function validateWithBun(code: string): Promise<string | null> {
-  const { writeFile, rm } = await import('fs/promises');
-  const { join } = await import('path');
+  const { writeFile, rm } = await import('node:fs/promises');
+  const { join } = await import('node:path');
   const tempFile = join('/tmp', `meno-validate-${Date.now()}-${Math.random().toString(36).slice(2)}.js`);
 
   try {
@@ -164,24 +190,33 @@ async function validateWithBun(code: string): Promise<string | null> {
       throw: true,
     });
     return null; // Valid
-  } catch (err: any) {
+  } catch (err) {
+    const be = err as BuildErrorLike;
     const { inspect } = await import('./fs');
     let details = '';
-    if (err.logs && Array.isArray(err.logs)) {
-      details = err.logs.map((log: any) => {
-        const parts: string[] = [];
-        if (log.position?.line) parts.push(`Line ${log.position.line}:${log.position.column || 0}`);
-        if (log.position?.lineText) parts.push(log.position.lineText);
-        if (log.message) parts.push(log.message);
-        return parts.length > 0 ? parts.join('\n') : String(log);
-      }).join('\n\n');
+    if (be.logs && Array.isArray(be.logs)) {
+      details = be.logs
+        .map((log: BunBuildLog) => {
+          const parts: string[] = [];
+          if (log.position?.line) parts.push(`Line ${log.position.line}:${log.position.column || 0}`);
+          if (log.position?.lineText) parts.push(log.position.lineText);
+          if (log.message) parts.push(log.message);
+          return parts.length > 0 ? parts.join('\n') : String(log);
+        })
+        .join('\n\n');
     }
     if (!details) {
-      try { details = inspect(err); } catch { details = err.stack || err.message || String(err); }
+      try {
+        details = inspect(err);
+      } catch {
+        details = be.stack || be.message || String(err);
+      }
     }
     return details || 'Unknown JavaScript error';
   } finally {
-    try { await rm(tempFile, { force: true }); } catch {}
+    try {
+      await rm(tempFile, { force: true });
+    } catch {}
   }
 }
 
@@ -191,10 +226,7 @@ async function getEsbuild() {
   return await import('esbuild');
 }
 
-async function bundleWithEsbuild(
-  entrypoint: string,
-  opts: BundleOptions,
-): Promise<BundleResult> {
+async function bundleWithEsbuild(entrypoint: string, opts: BundleOptions): Promise<BundleResult> {
   const esbuild = await getEsbuild();
 
   try {
@@ -205,23 +237,26 @@ async function bundleWithEsbuild(
       platform: opts.target === 'node' ? 'node' : 'browser',
       format: opts.format || 'esm',
       minify: opts.minify ?? false,
-      sourcemap: opts.sourcemap === true ? 'inline' : (opts.sourcemap === 'inline' ? 'inline' : opts.sourcemap === 'external' ? true : false),
+      sourcemap:
+        opts.sourcemap === true ? 'inline' : opts.sourcemap === 'inline' ? 'inline' : opts.sourcemap === 'external',
       jsx: 'automatic',
       jsxImportSource: 'react',
       logLevel: 'silent',
     });
 
-    if (result.outputFiles && result.outputFiles.length > 0) {
-      return { code: result.outputFiles[0].text, success: true, errors: [] };
+    const firstOutputFile = result.outputFiles?.[0];
+    if (firstOutputFile) {
+      return { code: firstOutputFile.text, success: true, errors: [] };
     }
 
     return { code: '', success: false, errors: ['Build produced no output'] };
-  } catch (err: any) {
+  } catch (err) {
+    const be = err as BuildErrorLike;
     if (opts.throw) throw err;
 
     const errors: string[] = [];
-    if (err.errors && Array.isArray(err.errors)) {
-      for (const e of err.errors) {
+    if (be.errors && Array.isArray(be.errors)) {
+      for (const e of be.errors) {
         const parts: string[] = [];
         if (e.location?.file) parts.push(`File: ${e.location.file}`);
         if (e.location?.line) parts.push(`Line ${e.location.line}:${e.location.column || 0}`);
@@ -230,7 +265,7 @@ async function bundleWithEsbuild(
         errors.push(parts.length > 0 ? parts.join('\n') : String(e));
       }
     } else {
-      errors.push(err.message || String(err));
+      errors.push(be.message || String(err));
     }
 
     return { code: '', success: false, errors };
@@ -247,10 +282,11 @@ async function minifyWithEsbuild(code: string): Promise<BundleResult> {
     });
 
     return { code: result.code, success: true, errors: [] };
-  } catch (err: any) {
+  } catch (err) {
+    const be = err as BuildErrorLike;
     const errors: string[] = [];
-    if (err.errors && Array.isArray(err.errors)) {
-      for (const e of err.errors) {
+    if (be.errors && Array.isArray(be.errors)) {
+      for (const e of be.errors) {
         const parts: string[] = [];
         if (e.location?.line) parts.push(`Line ${e.location.line}:${e.location.column || 0}`);
         if (e.location?.lineText) parts.push(e.location.lineText);
@@ -258,7 +294,7 @@ async function minifyWithEsbuild(code: string): Promise<BundleResult> {
         errors.push(parts.length > 0 ? parts.join('\n') : String(e));
       }
     } else {
-      errors.push(err.message || String(err));
+      errors.push(be.message || String(err));
     }
 
     return { code: '', success: false, errors };
@@ -271,10 +307,11 @@ async function validateWithEsbuild(code: string): Promise<string | null> {
   try {
     await esbuild.transform(code, { loader: 'js' });
     return null; // Valid
-  } catch (err: any) {
+  } catch (err) {
+    const be = err as BuildErrorLike;
     const errors: string[] = [];
-    if (err.errors && Array.isArray(err.errors)) {
-      for (const e of err.errors) {
+    if (be.errors && Array.isArray(be.errors)) {
+      for (const e of be.errors) {
         const parts: string[] = [];
         if (e.location?.line) parts.push(`Line ${e.location.line}:${e.location.column || 0}`);
         if (e.location?.lineText) parts.push(e.location.lineText);
@@ -282,7 +319,7 @@ async function validateWithEsbuild(code: string): Promise<string | null> {
         errors.push(parts.length > 0 ? parts.join('\n') : String(e));
       }
     } else {
-      errors.push(err.message || String(err));
+      errors.push(be.message || String(err));
     }
 
     return errors.join('\n\n') || 'Unknown JavaScript error';

package/lib/server/runtime/fs.ts

@@ -3,8 +3,8 @@
  * Uses Bun APIs when available, falls back to Node.js APIs.
  */
 
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const isBun = typeof globalThis.Bun !== 'undefined';
 
@@ -14,7 +14,7 @@ export async function readTextFile(path: string): Promise<string> {
   if (isBun) {
     return Bun.file(path).text();
   }
-  const { readFile } = await import('fs/promises');
+  const { readFile } = await import('node:fs/promises');
   return readFile(path, 'utf-8');
 }
 
@@ -22,7 +22,7 @@ export async function readJsonFile<T = unknown>(path: string): Promise<T> {
   if (isBun) {
     return Bun.file(path).json() as Promise<T>;
   }
-  const { readFile } = await import('fs/promises');
+  const { readFile } = await import('node:fs/promises');
   const text = await readFile(path, 'utf-8');
   return JSON.parse(text) as T;
 }
@@ -33,7 +33,7 @@ export async function fileExists(path: string): Promise<boolean> {
   if (isBun) {
     return Bun.file(path).exists();
   }
-  const { access } = await import('fs/promises');
+  const { access } = await import('node:fs/promises');
   try {
     await access(path);
     return true;
@@ -44,15 +44,12 @@ export async function fileExists(path: string): Promise<boolean> {
 
 // ── File writing ──────────────────────────────────────────────────────
 
-export async function writeFile(
-  path: string,
-  content: string | Uint8Array | ArrayBuffer,
-): Promise<void> {
+export async function writeFile(path: string, content: string | Uint8Array | ArrayBuffer): Promise<void> {
   if (isBun) {
     await Bun.write(path, content);
     return;
   }
-  const { writeFile: fsWrite } = await import('fs/promises');
+  const { writeFile: fsWrite } = await import('node:fs/promises');
   if (typeof content === 'string') {
     await fsWrite(path, content, 'utf-8');
   } else if (content instanceof ArrayBuffer) {
@@ -103,17 +100,14 @@ export function getMimeType(filePath: string): string {
   return MIME_MAP[ext] || 'application/octet-stream';
 }
 
-export async function serveFile(
-  path: string,
-  headers?: Record<string, string>,
-): Promise<Response> {
+export async function serveFile(path: string, headers?: Record<string, string>): Promise<Response> {
   if (isBun) {
     return new Response(Bun.file(path), { headers });
   }
 
   // Node.js path: stream the file via Web ReadableStream
-  const { createReadStream } = await import('fs');
-  const { Readable } = await import('stream');
+  const { createReadStream } = await import('node:fs');
+  const { Readable } = await import('node:stream');
   const nodeStream = createReadStream(path);
   const webStream = Readable.toWeb(nodeStream) as unknown as ReadableStream;
 
@@ -132,7 +126,7 @@ export function hashContent(content: string): string {
   if (isBun) {
     return Bun.hash(content).toString(16).slice(0, 8);
   }
-  const { createHash } = require('crypto') as typeof import('crypto');
+  const { createHash } = require('node:crypto') as typeof import('crypto');
   return createHash('sha256').update(content).digest('hex').slice(0, 8);
 }
 
@@ -142,14 +136,14 @@ export function inspect(value: unknown): string {
   if (isBun) {
     return Bun.inspect(value);
   }
-  const { inspect: nodeInspect } = require('util') as typeof import('util');
+  const { inspect: nodeInspect } = require('node:util') as typeof import('util');
   return nodeInspect(value, { depth: 4 });
 }
 
 // ── Directory helpers ─────────────────────────────────────────────────
 
 export async function ensureDir(path: string): Promise<void> {
-  const { mkdir } = await import('fs/promises');
+  const { mkdir } = await import('node:fs/promises');
   await mkdir(path, { recursive: true });
 }
 
@@ -189,15 +183,11 @@ export async function spawnProcess(
     return { exitCode };
   }
 
-  const { spawn } = await import('child_process');
+  const { spawn } = await import('node:child_process');
   return new Promise((resolve, reject) => {
     const child = spawn(cmd, args, {
       cwd: opts?.cwd,
-      stdio: [
-        'ignore',
-        opts?.stdout === 'pipe' ? 'pipe' : 'inherit',
-        opts?.stderr === 'pipe' ? 'pipe' : 'inherit',
-      ],
+      stdio: ['ignore', opts?.stdout === 'pipe' ? 'pipe' : 'inherit', opts?.stderr === 'pipe' ? 'pipe' : 'inherit'],
     });
 
     let stdout = '';
@@ -227,7 +217,7 @@ export async function getFileSize(path: string): Promise<number> {
   if (isBun) {
     return Bun.file(path).size;
   }
-  const { stat } = await import('fs/promises');
+  const { stat } = await import('node:fs/promises');
   const stats = await stat(path);
   return stats.size;
 }