npm - @affectively/aeon-pages - Versions diffs - 1.3.0 - Mend

@affectively/aeon-pages 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (124) hide show

package/CHANGELOG.md +112 -0
package/README.md +625 -0
package/examples/basic/aeon.config.ts +39 -0
package/examples/basic/components/Cursor.tsx +86 -0
package/examples/basic/components/OfflineIndicator.tsx +103 -0
package/examples/basic/components/PresenceBar.tsx +77 -0
package/examples/basic/package.json +20 -0
package/examples/basic/pages/index.tsx +80 -0
package/package.json +101 -0
package/packages/analytics/README.md +309 -0
package/packages/analytics/build.ts +35 -0
package/packages/analytics/package.json +50 -0
package/packages/analytics/src/click-tracker.ts +368 -0
package/packages/analytics/src/context-bridge.ts +319 -0
package/packages/analytics/src/data-layer.ts +302 -0
package/packages/analytics/src/gtm-loader.ts +239 -0
package/packages/analytics/src/index.ts +230 -0
package/packages/analytics/src/merkle-tree.ts +489 -0
package/packages/analytics/src/provider.tsx +300 -0
package/packages/analytics/src/types.ts +320 -0
package/packages/analytics/src/use-analytics.ts +296 -0
package/packages/analytics/tsconfig.json +19 -0
package/packages/benchmarks/src/benchmark.test.ts +691 -0
package/packages/cli/dist/index.js +61899 -0
package/packages/cli/package.json +43 -0
package/packages/cli/src/commands/build.test.ts +682 -0
package/packages/cli/src/commands/build.ts +890 -0
package/packages/cli/src/commands/dev.ts +473 -0
package/packages/cli/src/commands/init.ts +409 -0
package/packages/cli/src/commands/start.ts +297 -0
package/packages/cli/src/index.ts +105 -0
package/packages/directives/src/use-aeon.ts +272 -0
package/packages/mcp-server/package.json +51 -0
package/packages/mcp-server/src/index.ts +178 -0
package/packages/mcp-server/src/resources.ts +346 -0
package/packages/mcp-server/src/tools/index.ts +36 -0
package/packages/mcp-server/src/tools/navigation.ts +545 -0
package/packages/mcp-server/tsconfig.json +21 -0
package/packages/react/package.json +40 -0
package/packages/react/src/Link.tsx +388 -0
package/packages/react/src/components/InstallPrompt.tsx +286 -0
package/packages/react/src/components/OfflineDiagnostics.tsx +677 -0
package/packages/react/src/components/PushNotifications.tsx +453 -0
package/packages/react/src/hooks/useAeonNavigation.ts +219 -0
package/packages/react/src/hooks/useConflicts.ts +277 -0
package/packages/react/src/hooks/useNetworkState.ts +209 -0
package/packages/react/src/hooks/usePilotNavigation.ts +254 -0
package/packages/react/src/hooks/useServiceWorker.ts +278 -0
package/packages/react/src/hooks.ts +195 -0
package/packages/react/src/index.ts +151 -0
package/packages/react/src/provider.tsx +467 -0
package/packages/react/tsconfig.json +19 -0
package/packages/runtime/README.md +399 -0
package/packages/runtime/build.ts +48 -0
package/packages/runtime/package.json +71 -0
package/packages/runtime/schema.sql +40 -0
package/packages/runtime/src/api-routes.ts +465 -0
package/packages/runtime/src/benchmark.ts +171 -0
package/packages/runtime/src/cache.ts +479 -0
package/packages/runtime/src/durable-object.ts +1341 -0
package/packages/runtime/src/index.ts +360 -0
package/packages/runtime/src/navigation.test.ts +421 -0
package/packages/runtime/src/navigation.ts +422 -0
package/packages/runtime/src/nextjs-adapter.ts +272 -0
package/packages/runtime/src/offline/encrypted-queue.test.ts +607 -0
package/packages/runtime/src/offline/encrypted-queue.ts +478 -0
package/packages/runtime/src/offline/encryption.test.ts +412 -0
package/packages/runtime/src/offline/encryption.ts +397 -0
package/packages/runtime/src/offline/types.ts +465 -0
package/packages/runtime/src/predictor.ts +371 -0
package/packages/runtime/src/registry.ts +351 -0
package/packages/runtime/src/router/context-extractor.ts +661 -0
package/packages/runtime/src/router/esi-control-react.tsx +2053 -0
package/packages/runtime/src/router/esi-control.ts +541 -0
package/packages/runtime/src/router/esi-cyrano.ts +779 -0
package/packages/runtime/src/router/esi-format-react.tsx +1744 -0
package/packages/runtime/src/router/esi-react.tsx +1065 -0
package/packages/runtime/src/router/esi-translate-observer.ts +476 -0
package/packages/runtime/src/router/esi-translate-react.tsx +556 -0
package/packages/runtime/src/router/esi-translate.ts +503 -0
package/packages/runtime/src/router/esi.ts +666 -0
package/packages/runtime/src/router/heuristic-adapter.test.ts +295 -0
package/packages/runtime/src/router/heuristic-adapter.ts +557 -0
package/packages/runtime/src/router/index.ts +298 -0
package/packages/runtime/src/router/merkle-capability.ts +473 -0
package/packages/runtime/src/router/speculation.ts +451 -0
package/packages/runtime/src/router/types.ts +630 -0
package/packages/runtime/src/router.test.ts +470 -0
package/packages/runtime/src/router.ts +302 -0
package/packages/runtime/src/server.ts +481 -0
package/packages/runtime/src/service-worker-push.ts +319 -0
package/packages/runtime/src/service-worker.ts +553 -0
package/packages/runtime/src/skeleton-hydrate.ts +237 -0
package/packages/runtime/src/speculation.test.ts +389 -0
package/packages/runtime/src/speculation.ts +486 -0
package/packages/runtime/src/storage.test.ts +1297 -0
package/packages/runtime/src/storage.ts +1048 -0
package/packages/runtime/src/sync/conflict-resolver.test.ts +528 -0
package/packages/runtime/src/sync/conflict-resolver.ts +565 -0
package/packages/runtime/src/sync/coordinator.test.ts +608 -0
package/packages/runtime/src/sync/coordinator.ts +596 -0
package/packages/runtime/src/tree-compiler.ts +295 -0
package/packages/runtime/src/types.ts +728 -0
package/packages/runtime/src/worker.ts +327 -0
package/packages/runtime/tsconfig.json +20 -0
package/packages/runtime/wasm/aeon_pages_runtime.d.ts +504 -0
package/packages/runtime/wasm/aeon_pages_runtime.js +1657 -0
package/packages/runtime/wasm/aeon_pages_runtime_bg.wasm +0 -0
package/packages/runtime/wasm/aeon_pages_runtime_bg.wasm.d.ts +196 -0
package/packages/runtime/wasm/package.json +21 -0
package/packages/runtime/wrangler.toml +41 -0
package/packages/runtime-wasm/Cargo.lock +436 -0
package/packages/runtime-wasm/Cargo.toml +29 -0
package/packages/runtime-wasm/pkg/aeon_pages_runtime.d.ts +480 -0
package/packages/runtime-wasm/pkg/aeon_pages_runtime.js +1568 -0
package/packages/runtime-wasm/pkg/aeon_pages_runtime_bg.wasm +0 -0
package/packages/runtime-wasm/pkg/aeon_pages_runtime_bg.wasm.d.ts +192 -0
package/packages/runtime-wasm/pkg/package.json +21 -0
package/packages/runtime-wasm/src/hydrate.rs +352 -0
package/packages/runtime-wasm/src/lib.rs +191 -0
package/packages/runtime-wasm/src/render.rs +629 -0
package/packages/runtime-wasm/src/router.rs +298 -0
package/packages/runtime-wasm/src/skeleton.rs +430 -0
package/rfcs/RFC-001-ZERO-DEPENDENCY-RENDERING.md +1446 -0

package/packages/runtime/src/skeleton-hydrate.ts ADDED Viewed

@@ -0,0 +1,237 @@
+/**
+ * Skeleton Hydration - Client-Side Swap
+ *
+ * Handles the smooth transition from skeleton to real content.
+ * Designed to be inlined in <head> for instant execution.
+ */
+/** Skeleton swap options */
+export interface SkeletonSwapOptions {
+  /** Enable cross-fade animation */
+  fade?: boolean;
+  /** Fade duration in milliseconds */
+  duration?: number;
+  /** Callback when swap completes */
+  onComplete?: () => void;
+}
+/** Skeleton state for the current page */
+interface SkeletonState {
+  skeletonRoot: HTMLElement | null;
+  contentRoot: HTMLElement | null;
+  swapped: boolean;
+}
+const state: SkeletonState = {
+  skeletonRoot: null,
+  contentRoot: null,
+  swapped: false,
+};
+/**
+ * Initialize skeleton system
+ * Called immediately in <head> before body renders
+ */
+export function initSkeleton(): void {
+  // Find skeleton and content containers
+  state.skeletonRoot = document.getElementById('aeon-skeleton');
+  state.contentRoot = document.getElementById('root');
+  if (!state.skeletonRoot || !state.contentRoot) {
+    return;
+  }
+  // Hide content, show skeleton
+  state.contentRoot.style.display = 'none';
+  state.skeletonRoot.style.display = 'block';
+}
+/**
+ * Swap skeleton with real content
+ * Called when content is ready to render
+ */
+export function swapToContent(options: SkeletonSwapOptions = {}): void {
+  if (state.swapped || !state.skeletonRoot || !state.contentRoot) {
+    options.onComplete?.();
+    return;
+  }
+  const { fade = true, duration = 150, onComplete } = options;
+  if (fade) {
+    // Cross-fade animation
+    const transitionStyle = `opacity ${duration}ms ease-out`;
+    state.skeletonRoot.style.transition = transitionStyle;
+    state.contentRoot.style.transition = transitionStyle;
+    state.contentRoot.style.opacity = '0';
+    state.contentRoot.style.display = 'block';
+    // Force reflow to ensure transition works
+    void state.contentRoot.offsetHeight;
+    // Start transition
+    state.skeletonRoot.style.opacity = '0';
+    state.contentRoot.style.opacity = '1';
+    // Cleanup after transition
+    setTimeout(() => {
+      state.skeletonRoot?.remove();
+      onComplete?.();
+    }, duration);
+  } else {
+    // Instant swap
+    state.skeletonRoot.remove();
+    state.contentRoot.style.display = 'block';
+    onComplete?.();
+  }
+  state.swapped = true;
+}
+/**
+ * Check if skeleton is still visible
+ */
+export function isSkeletonVisible(): boolean {
+  return !state.swapped && state.skeletonRoot !== null;
+}
+/**
+ * Generate minified inline init script for <head>
+ * This script executes before body renders, ensuring skeleton shows first
+ */
+export function generateSkeletonInitScript(): string {
+  return `<script>
+(function(){
+  var s=document.getElementById('aeon-skeleton'),r=document.getElementById('root');
+  if(s&&r){r.style.display='none';s.style.display='block'}
+  window.__AEON_SKELETON__={
+    swap:function(o){
+      if(this.done)return;
+      o=o||{};
+      var f=o.fade!==false,d=o.duration||150;
+      if(f){
+        s.style.transition=r.style.transition='opacity '+d+'ms ease-out';
+        r.style.opacity='0';r.style.display='block';
+        void r.offsetHeight;
+        s.style.opacity='0';r.style.opacity='1';
+        setTimeout(function(){s.remove();o.onComplete&&o.onComplete()},d);
+      }else{
+        s.remove();r.style.display='block';o.onComplete&&o.onComplete();
+      }
+      this.done=true
+    },
+    isVisible:function(){return!this.done&&!!s},
+    done:false
+  };
+})();
+</script>`;
+}
+/**
+ * Generate the complete HTML structure for skeleton-first rendering
+ */
+export function generateSkeletonPageStructure(options: {
+  title: string;
+  description?: string;
+  skeletonHtml: string;
+  skeletonCss: string;
+  contentHtml: string;
+  contentCss: string;
+  headExtra?: string;
+  bodyExtra?: string;
+}): string {
+  const {
+    title,
+    description,
+    skeletonHtml,
+    skeletonCss,
+    contentHtml,
+    contentCss,
+    headExtra = '',
+    bodyExtra = '',
+  } = options;
+  const descriptionMeta = description
+    ? `\n  <meta name="description" content="${escapeHtml(description)}">`
+    : '';
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>${descriptionMeta}
+  <style>
+/* Skeleton CSS */
+${skeletonCss}
+/* Content CSS */
+${contentCss}
+  </style>
+  ${generateSkeletonInitScript()}
+  ${headExtra}
+</head>
+<body>
+  <div id="aeon-skeleton" aria-hidden="true">${skeletonHtml}</div>
+  <div id="root" style="display:none">${contentHtml}</div>
+  <script>
+    // Swap when DOM is ready
+    if(document.readyState==='loading'){
+      document.addEventListener('DOMContentLoaded',function(){
+        window.__AEON_SKELETON__.swap({fade:true});
+      });
+    }else{
+      window.__AEON_SKELETON__.swap({fade:true});
+    }
+  </script>
+  ${bodyExtra}
+</body>
+</html>`;
+}
+/**
+ * Generate skeleton swap script for async content loading
+ * Use this when content loads after initial page render
+ */
+export function generateAsyncSwapScript(): string {
+  return `<script>
+(function(){
+  // Wait for content to be ready (e.g., after React hydration)
+  function checkReady(){
+    var root=document.getElementById('root');
+    if(root&&root.children.length>0){
+      window.__AEON_SKELETON__&&window.__AEON_SKELETON__.swap({fade:true});
+    }else{
+      requestAnimationFrame(checkReady);
+    }
+  }
+  if(document.readyState==='loading'){
+    document.addEventListener('DOMContentLoaded',checkReady);
+  }else{
+    checkReady();
+  }
+})();
+</script>`;
+}
+/**
+ * Escape HTML special characters
+ */
+function escapeHtml(str: string): string {
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#039;');
+}
+// TypeScript declaration for the global skeleton API
+declare global {
+  interface Window {
+    __AEON_SKELETON__?: {
+      swap: (options?: SkeletonSwapOptions) => void;
+      isVisible: () => boolean;
+      done: boolean;
+    };
+  }
+}

package/packages/runtime/src/speculation.test.ts ADDED Viewed

@@ -0,0 +1,389 @@
+import {
+  describe,
+  test,
+  expect,
+  beforeEach,
+  afterEach,
+  mock,
+  spyOn,
+} from 'bun:test';
+import {
+  SpeculativeRenderer,
+  getSpeculativeRenderer,
+  setSpeculativeRenderer,
+  initSpeculativeRendering,
+  type SpeculativeRendererConfig,
+} from './speculation';
+import { setPredictor, NavigationPredictor } from './predictor';
+// Mock DOM environment
+function createMockDOM() {
+  return {
+    querySelectorAll: mock(() => []),
+    addEventListener: mock(() => {}),
+    createElement: mock(() => ({
+      type: '',
+      textContent: '',
+    })),
+    head: {
+      appendChild: mock(() => {}),
+    },
+    open: mock(() => {}),
+    write: mock(() => {}),
+    close: mock(() => {}),
+  };
+}
+function createMockWindow() {
+  return {
+    location: { pathname: '/', origin: 'http://localhost' },
+    history: {
+      pushState: mock(() => {}),
+    },
+    addEventListener: mock(() => {}),
+    IntersectionObserver: mock((callback: Function, options: any) => ({
+      observe: mock(() => {}),
+      unobserve: mock(() => {}),
+      disconnect: mock(() => {}),
+    })),
+  };
+}
+describe('SpeculativeRenderer', () => {
+  let originalWindow: typeof globalThis.window;
+  let originalDocument: typeof globalThis.document;
+  let originalFetch: typeof globalThis.fetch;
+  beforeEach(() => {
+    originalWindow = globalThis.window;
+    originalDocument = globalThis.document;
+    originalFetch = globalThis.fetch;
+    // Set up a mock predictor
+    const predictor = new NavigationPredictor();
+    setPredictor(predictor);
+  });
+  afterEach(() => {
+    globalThis.window = originalWindow;
+    globalThis.document = originalDocument;
+    globalThis.fetch = originalFetch;
+    setSpeculativeRenderer(null as any);
+  });
+  test('creates instance with default config', () => {
+    const renderer = new SpeculativeRenderer();
+    expect(renderer).toBeDefined();
+    const stats = renderer.getStats();
+    expect(stats.cachedPages).toBe(0);
+    expect(stats.cacheSize).toBe(0);
+  });
+  test('creates instance with custom config', () => {
+    const config: Partial<SpeculativeRendererConfig> = {
+      maxCachedPages: 10,
+      maxCacheSize: 10 * 1024 * 1024,
+      minConfidence: 0.5,
+    };
+    const renderer = new SpeculativeRenderer(config);
+    expect(renderer).toBeDefined();
+  });
+  test('getSpeculativeRenderer returns singleton', () => {
+    const renderer1 = getSpeculativeRenderer();
+    const renderer2 = getSpeculativeRenderer();
+    expect(renderer1).toBe(renderer2);
+  });
+  test('setSpeculativeRenderer replaces singleton', () => {
+    const original = getSpeculativeRenderer();
+    const replacement = new SpeculativeRenderer();
+    setSpeculativeRenderer(replacement);
+    expect(getSpeculativeRenderer()).toBe(replacement);
+    expect(getSpeculativeRenderer()).not.toBe(original);
+  });
+  test('prerender caches page HTML', async () => {
+    const mockHtml = '<html><body>Test Page</body></html>';
+    globalThis.fetch = mock(
+      async () =>
+        ({
+          ok: true,
+          text: async () => mockHtml,
+        }) as Response,
+    );
+    globalThis.window = {
+      location: { pathname: '/' },
+    } as any;
+    const renderer = new SpeculativeRenderer();
+    const result = await renderer.prerender('/about');
+    expect(result).toBe(true);
+    expect(renderer.getStats().cachedPages).toBe(1);
+    expect(renderer.getStats().cacheSize).toBe(mockHtml.length);
+  });
+  test('prerender skips current route', async () => {
+    globalThis.window = {
+      location: { pathname: '/about' },
+    } as any;
+    const renderer = new SpeculativeRenderer();
+    const result = await renderer.prerender('/about');
+    expect(result).toBe(false);
+    expect(renderer.getStats().cachedPages).toBe(0);
+  });
+  test('prerender handles fetch failures', async () => {
+    globalThis.fetch = mock(
+      async () =>
+        ({
+          ok: false,
+          status: 404,
+        }) as Response,
+    );
+    globalThis.window = {
+      location: { pathname: '/' },
+    } as any;
+    const renderer = new SpeculativeRenderer();
+    const result = await renderer.prerender('/not-found');
+    expect(result).toBe(false);
+    expect(renderer.getStats().cachedPages).toBe(0);
+  });
+  test('prerender handles network errors', async () => {
+    globalThis.fetch = mock(async () => {
+      throw new Error('Network error');
+    });
+    globalThis.window = {
+      location: { pathname: '/' },
+    } as any;
+    const renderer = new SpeculativeRenderer();
+    const result = await renderer.prerender('/error');
+    expect(result).toBe(false);
+    expect(renderer.getStats().cachedPages).toBe(0);
+  });
+  test('invalidate marks pages as stale', async () => {
+    const mockHtml = '<html><body>Test</body></html>';
+    globalThis.fetch = mock(
+      async () =>
+        ({
+          ok: true,
+          text: async () => mockHtml,
+        }) as Response,
+    );
+    globalThis.window = {
+      location: { pathname: '/' },
+    } as any;
+    const renderer = new SpeculativeRenderer();
+    await renderer.prerender('/about');
+    await renderer.prerender('/contact');
+    // Invalidate specific routes
+    renderer.invalidate(['/about']);
+    // About should be stale, navigate should fail
+    const navigateResult = await renderer.navigate('/about');
+    expect(navigateResult).toBe(false);
+  });
+  test('invalidate without routes marks all as stale', async () => {
+    const mockHtml = '<html><body>Test</body></html>';
+    globalThis.fetch = mock(
+      async () =>
+        ({
+          ok: true,
+          text: async () => mockHtml,
+        }) as Response,
+    );
+    globalThis.window = {
+      location: { pathname: '/' },
+    } as any;
+    const renderer = new SpeculativeRenderer();
+    await renderer.prerender('/about');
+    await renderer.prerender('/contact');
+    // Invalidate all
+    renderer.invalidate();
+    // Both should be stale
+    const aboutResult = await renderer.navigate('/about');
+    const contactResult = await renderer.navigate('/contact');
+    expect(aboutResult).toBe(false);
+    expect(contactResult).toBe(false);
+  });
+  test('evicts old pages when cache is full', async () => {
+    const mockHtml = 'x'.repeat(1000); // 1KB per page
+    globalThis.fetch = mock(
+      async () =>
+        ({
+          ok: true,
+          text: async () => mockHtml,
+        }) as Response,
+    );
+    globalThis.window = {
+      location: { pathname: '/' },
+    } as any;
+    // Small cache - max 2 pages
+    const renderer = new SpeculativeRenderer({
+      maxCachedPages: 2,
+    });
+    await renderer.prerender('/page1');
+    await renderer.prerender('/page2');
+    expect(renderer.getStats().cachedPages).toBe(2);
+    // Adding third page should evict oldest
+    await renderer.prerender('/page3');
+    expect(renderer.getStats().cachedPages).toBe(2);
+  });
+  test('evicts based on cache size limit', async () => {
+    globalThis.fetch = mock(
+      async () =>
+        ({
+          ok: true,
+          text: async () => 'x'.repeat(1000), // 1KB
+        }) as Response,
+    );
+    globalThis.window = {
+      location: { pathname: '/' },
+    } as any;
+    // Small cache - max 1.5KB
+    const renderer = new SpeculativeRenderer({
+      maxCacheSize: 1500,
+      maxCachedPages: 100,
+    });
+    await renderer.prerender('/page1');
+    await renderer.prerender('/page2');
+    // Should only keep one page due to size limit
+    expect(renderer.getStats().cachedPages).toBe(1);
+    expect(renderer.getStats().cacheSize).toBeLessThanOrEqual(1500);
+  });
+  test('uses cached page on second prerender', async () => {
+    let fetchCount = 0;
+    const mockHtml = '<html><body>Test</body></html>';
+    globalThis.fetch = mock(async () => {
+      fetchCount++;
+      return {
+        ok: true,
+        text: async () => mockHtml,
+      } as Response;
+    });
+    globalThis.window = {
+      location: { pathname: '/' },
+    } as any;
+    const renderer = new SpeculativeRenderer();
+    await renderer.prerender('/about');
+    expect(fetchCount).toBe(1);
+    // Second call should use cache
+    await renderer.prerender('/about');
+    expect(fetchCount).toBe(1); // No additional fetch
+  });
+  test('destroy cleans up resources', async () => {
+    const mockHtml = '<html><body>Test</body></html>';
+    globalThis.fetch = mock(
+      async () =>
+        ({
+          ok: true,
+          text: async () => mockHtml,
+        }) as Response,
+    );
+    globalThis.window = {
+      location: { pathname: '/' },
+    } as any;
+    const renderer = new SpeculativeRenderer();
+    await renderer.prerender('/about');
+    expect(renderer.getStats().cachedPages).toBe(1);
+    renderer.destroy();
+    expect(renderer.getStats().cachedPages).toBe(0);
+    expect(renderer.getStats().cacheSize).toBe(0);
+  });
+});
+describe('initSpeculativeRendering', () => {
+  test('creates and initializes renderer', () => {
+    // Can't fully test init without DOM, but verify function exists
+    expect(initSpeculativeRendering).toBeDefined();
+    expect(typeof initSpeculativeRendering).toBe('function');
+  });
+});
+describe('Speculation integration with predictor', () => {
+  test('predictor predictions are used for pre-rendering', () => {
+    const predictor = new NavigationPredictor();
+    // Record some navigation history
+    predictor.record({
+      from: '/',
+      to: '/dashboard',
+      timestamp: Date.now(),
+      duration: 5000,
+    });
+    predictor.record({
+      from: '/',
+      to: '/dashboard',
+      timestamp: Date.now(),
+      duration: 3000,
+    });
+    predictor.record({
+      from: '/',
+      to: '/explore',
+      timestamp: Date.now(),
+      duration: 2000,
+    });
+    // Predict from home
+    const predictions = predictor.predict('/');
+    expect(predictions.length).toBeGreaterThan(0);
+    expect(predictions[0].route).toBe('/dashboard'); // Most likely
+    expect(predictions[0].probability).toBeGreaterThan(0.4); // ~0.48 expected
+  });
+});