@aravindc26/velu 0.13.4 → 0.13.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aravindc26/velu",
-  "version": "0.13.4",
+  "version": "0.13.6",
   "description": "A modern documentation site generator powered by Markdown and JSON configuration",
   "type": "module",
   "license": "MIT",

package/src/engine/app/_preview/[sessionId]/[...slug]/page.tsx

@@ -154,7 +154,6 @@ export default async function PreviewPage({ params }: PageProps) {
   let pageToc: any;
 
   if (typeof loadFn === 'function') {
-    // Dynamic/async entry — compile MDX on demand
     const loaded = await loadFn();
     MDX = loaded.body;
     pageToc = loaded.toc;

package/src/engine/app/_preview/api/sessions/[sessionId]/init/route.ts

@@ -11,12 +11,16 @@ export async function POST(
 
   const { sessionId } = await params;
 
+  console.log(`[PREVIEW:init] START session=${sessionId}`);
+
   try {
     const result = generateSessionContent(sessionId);
+    console.log(`[PREVIEW:init] generateSessionContent result:`, JSON.stringify(result));
 
     // Invalidate the cached dynamic source so the next page request
     // re-scans the content directory and picks up the new files.
     invalidateSessionSource(sessionId);
+    console.log(`[PREVIEW:init] DONE session=${sessionId}`);
 
     return Response.json({
       status: 'ready',
@@ -26,7 +30,7 @@ export async function POST(
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Unknown error';
-    console.error(`[PREVIEW] Init failed for session ${sessionId}:`, message);
+    console.error(`[PREVIEW:init] FAILED session=${sessionId}:`, message);
     return Response.json(
       { status: 'error', error: message },
       { status: 500 },

package/src/engine/app/_preview/api/sessions/[sessionId]/sync/route.ts

@@ -12,6 +12,8 @@ export async function POST(
   const { sessionId } = await params;
   const file = request.nextUrl.searchParams.get('file');
 
+  console.log(`[PREVIEW:sync] START session=${sessionId} file=${file}`);
+
   if (!file) {
     return Response.json(
       { error: 'Missing "file" query parameter' },
@@ -21,9 +23,11 @@ export async function POST(
 
   try {
     const result = syncSessionFile(sessionId, file);
+    console.log(`[PREVIEW:sync] syncSessionFile result:`, JSON.stringify(result));
 
     // Invalidate cached source so next page request re-scans content
     invalidateSessionSource(sessionId);
+    console.log(`[PREVIEW:sync] DONE session=${sessionId} file=${file}`);
 
     return Response.json({
       status: 'synced',
@@ -32,7 +36,7 @@ export async function POST(
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Unknown error';
-    console.error(`[PREVIEW] Sync failed for session ${sessionId}, file ${file}:`, message);
+    console.error(`[PREVIEW:sync] FAILED session=${sessionId} file=${file}:`, message);
     return Response.json(
       { status: 'error', error: message },
       { status: 500 },

package/src/engine/lib/preview-content.ts

@@ -755,6 +755,8 @@ export function syncSessionFile(
   const workspaceDir = join(WORKSPACE_DIR, sessionId);
   const outputDir = join(PREVIEW_CONTENT_DIR, sessionId);
 
+  console.log(`[PREVIEW:syncFile] session=${sessionId} file=${filePath}`);
+
   if (filePath === PRIMARY_CONFIG_NAME || filePath === LEGACY_CONFIG_NAME) {
     generateSessionContent(sessionId);
     return { synced: true };

package/src/engine/lib/preview-source.ts

@@ -9,7 +9,7 @@
  * Used only in preview mode (PREVIEW_MODE=true) — production builds still use
  * the standard `source.ts` with build-time collections.
  */
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { loader } from 'fumadocs-core/source';
 import { dynamic } from 'fumadocs-mdx/runtime/dynamic';
@@ -24,8 +24,37 @@ import * as sourceConfigExports from '../source.config';
 
 const PREVIEW_CONTENT_DIR = process.env.PREVIEW_CONTENT_DIR || './content';
 
+function log(tag: string, msg: string, data?: Record<string, unknown>) {
+  const payload = data ? ' ' + JSON.stringify(data) : '';
+  console.log(`[PREVIEW:${tag}] ${msg}${payload}`);
+}
+
 // ── Cache ──────────────────────────────────────────────────────────────────
 
+// File-based invalidation signal. Next.js bundles API routes and page routes
+// into separate module instances, so in-memory invalidation from the sync/init
+// route handler does NOT clear the cache seen by the page renderer. Instead,
+// the invalidation writes a timestamp to a file on disk which both sides can see.
+const INVALIDATION_DIR = join(PREVIEW_CONTENT_DIR, '.invalidation');
+
+function getInvalidationPath(sessionId: string): string {
+  return join(INVALIDATION_DIR, `${sessionId}.stamp`);
+}
+
+function readInvalidationStamp(sessionId: string): number {
+  const p = getInvalidationPath(sessionId);
+  try {
+    return Number(readFileSync(p, 'utf-8').trim()) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+function writeInvalidationStamp(sessionId: string): void {
+  mkdirSync(INVALIDATION_DIR, { recursive: true });
+  writeFileSync(getInvalidationPath(sessionId), String(Date.now()), 'utf-8');
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const sourceCache = new Map<string, { source: any; createdAt: number }>();
 
@@ -37,6 +66,7 @@ async function getDynamic() {
   if (dynamicInstance) return dynamicInstance;
   if (dynamicInitPromise) return dynamicInitPromise;
 
+  log('dynamic', 'Initializing new dynamic() instance');
   dynamicInitPromise = dynamic(
     sourceConfigExports,
     {
@@ -47,6 +77,7 @@ async function getDynamic() {
   ).then((inst) => {
     dynamicInstance = inst;
     dynamicInitPromise = null;
+    log('dynamic', 'dynamic() instance ready');
     return inst;
   });
 
@@ -146,11 +177,22 @@ function scanContentDir(sessionDir: string): {
  */
 export async function getSessionSource(sessionId: string) {
   const cached = sourceCache.get(sessionId);
-  if (cached) return cached.source;
+  if (cached) {
+    const stamp = readInvalidationStamp(sessionId);
+    if (stamp <= cached.createdAt) {
+      const age = Date.now() - cached.createdAt;
+      log('source', `Cache HIT for session ${sessionId}`, { ageMs: age });
+      return cached.source;
+    }
+    log('source', `Cache STALE for session ${sessionId} (stamp=${stamp} > created=${cached.createdAt}), rebuilding`);
+    sourceCache.delete(sessionId);
+  } else {
+    log('source', `Cache MISS for session ${sessionId}`);
+  }
 
   const sessionDir = join(PREVIEW_CONTENT_DIR, sessionId);
   if (!existsSync(sessionDir)) {
-    // Return an empty source if no content yet
+    log('source', `Session dir does not exist: ${sessionDir}`);
     const emptySource = loader({
       baseUrl: '/',
       source: { files: [] },
@@ -161,6 +203,11 @@ export async function getSessionSource(sessionId: string) {
   const dyn = await getDynamic();
   const { entries, metaFiles } = scanContentDir(sessionDir);
 
+  log('source', `Scanned ${sessionDir}`, {
+    entryCount: entries.length,
+    metaFileCount: Object.keys(metaFiles).length,
+  });
+
   const collection = await dyn.docs('docs', sessionDir, metaFiles, entries);
   const fumadocsSource = collection.toFumadocsSource();
 
@@ -188,15 +235,23 @@ export async function getSessionSource(sessionId: string) {
   });
 
   sourceCache.set(sessionId, { source: src, createdAt: Date.now() });
+  log('source', `Built and cached source for session ${sessionId}`, {
+    pageCount: src.getPages().length,
+  });
   return src;
 }
 
 /**
  * Invalidate the cached source for a session.
- * Call after content generation or sync so the next request re-scans.
+ * Writes a file-based timestamp so that ALL Next.js module instances
+ * (API routes AND page routes) see the invalidation, even though they
+ * run in separate bundles with separate in-memory Maps.
  */
 export function invalidateSessionSource(sessionId: string): void {
+  const had = sourceCache.has(sessionId);
   sourceCache.delete(sessionId);
+  writeInvalidationStamp(sessionId);
+  log('invalidate', `session=${sessionId} hadCache=${had} wroteStamp=true`);
 }
 
 /**