theokit 0.48.9 → 0.48.10

package/dist/{chunk-Q2S2IGSM.js → chunk-7UMA5DY4.js}

@@ -1380,11 +1380,31 @@ function generateSingleShotEntry(options) {
   return [
     `import React, { Suspense } from 'react'`,
     `import { renderToPipeableStream } from 'react-dom/server'`,
-    `import { createStaticHandler, createStaticRouter, StaticRouterProvider } from 'react-router'`,
+    `import { createStaticHandler, createStaticRouter, StaticRouterProvider, matchRoutes } from 'react-router'`,
     `import { PassThrough } from 'node:stream'`,
-    `import { routes } from '/@theo/route-manifest'`,
+    `import { routes, __theoPreloadMap } from '/@theo/route-manifest'`,
     theoUiImport,
     `export async function render(url, options = {}) {`,
+    // Resolve the matched pages BEFORE rendering.
+    //
+    // Pages are React.lazy() in the route manifest, which is right for the browser and pure loss
+    // here: the server already has every chunk on local disk. Rendering without this makes React
+    // suspend on the page component, so \`onShellReady\` fires with the layout alone and the actual
+    // page streams afterwards inside a hidden div. The reader gets an empty frame that fills in --
+    // measured at CLS 1.12 and an article absent from the DOM for ~700ms on a real site.
+    //
+    // This mirrors what entry.ts already does before hydrateRoot, using the same preload map.
+    // Streaming still applies to genuine data-fetching Suspense, which is where it earns its keep.
+    // A failed import is swallowed on purpose: React.lazy will retry and suspend as before, which
+    // is strictly no worse than not having preloaded at all.
+    `  const __theoMatches = matchRoutes(routes, url.split('?')[0]) ?? []`,
+    `  await Promise.all(`,
+    `    __theoMatches`,
+    `      .map((m) => m.route && m.route.path)`,
+    `      .filter((p) => typeof p === 'string' && p in __theoPreloadMap)`,
+    `      .map((p) => __theoPreloadMap[p]().catch(() => null)),`,
+    `  )`,
+    ``,
     `  const handler = createStaticHandler(routes)`,
     `  const request = new Request('http://localhost' + url)`,
     `  const context = await handler.query(request)`,
@@ -1429,6 +1449,26 @@ function streamingWebRenderer(appTree) {
     `// Response with the stream as body. Honors request.signal for client`,
     `// disconnect cleanup.`,
     `export async function renderStreamingWeb(request, options = {}) {`,
+    // Resolve the matched pages BEFORE rendering.
+    //
+    // Pages are React.lazy() in the route manifest, which is right for the browser and pure loss
+    // here: the server already has every chunk on local disk. Rendering without this makes React
+    // suspend on the page component, so \`onShellReady\` fires with the layout alone and the actual
+    // page streams afterwards inside a hidden div. The reader gets an empty frame that fills in --
+    // measured at CLS 1.12 and an article absent from the DOM for ~700ms on a real site.
+    //
+    // This mirrors what entry.ts already does before hydrateRoot, using the same preload map.
+    // Streaming still applies to genuine data-fetching Suspense, which is where it earns its keep.
+    // A failed import is swallowed on purpose: React.lazy will retry and suspend as before, which
+    // is strictly no worse than not having preloaded at all.
+    `  const __theoMatches = matchRoutes(routes, url.split('?')[0]) ?? []`,
+    `  await Promise.all(`,
+    `    __theoMatches`,
+    `      .map((m) => m.route && m.route.path)`,
+    `      .filter((p) => typeof p === 'string' && p in __theoPreloadMap)`,
+    `      .map((p) => __theoPreloadMap[p]().catch(() => null)),`,
+    `  )`,
+    ``,
     `  const handler = createStaticHandler(routes)`,
     `  const url = new URL(request.url)`,
     `  const context = await handler.query(request)`,
@@ -1461,6 +1501,26 @@ function streamingNodeRenderer(appTree) {
     `// Flushes the shell as soon as it's ready, then streams Suspense boundaries.`,
     `// EC-11: respects request.signal for client-disconnect cleanup.`,
     `export async function renderStreaming(url, response, options = {}) {`,
+    // Resolve the matched pages BEFORE rendering.
+    //
+    // Pages are React.lazy() in the route manifest, which is right for the browser and pure loss
+    // here: the server already has every chunk on local disk. Rendering without this makes React
+    // suspend on the page component, so \`onShellReady\` fires with the layout alone and the actual
+    // page streams afterwards inside a hidden div. The reader gets an empty frame that fills in --
+    // measured at CLS 1.12 and an article absent from the DOM for ~700ms on a real site.
+    //
+    // This mirrors what entry.ts already does before hydrateRoot, using the same preload map.
+    // Streaming still applies to genuine data-fetching Suspense, which is where it earns its keep.
+    // A failed import is swallowed on purpose: React.lazy will retry and suspend as before, which
+    // is strictly no worse than not having preloaded at all.
+    `  const __theoMatches = matchRoutes(routes, url.split('?')[0]) ?? []`,
+    `  await Promise.all(`,
+    `    __theoMatches`,
+    `      .map((m) => m.route && m.route.path)`,
+    `      .filter((p) => typeof p === 'string' && p in __theoPreloadMap)`,
+    `      .map((p) => __theoPreloadMap[p]().catch(() => null)),`,
+    `  )`,
+    ``,
     `  const handler = createStaticHandler(routes)`,
     `  const request = new Request('http://localhost' + url, { signal: options.signal })`,
     `  const context = await handler.query(request)`,
@@ -1503,6 +1563,26 @@ function backCompatRenderer(appTree) {
     `// Backward compatibility: keep the single-shot render export available so`,
     `// callers that always used 'render()' don't break when streaming is on.`,
     `export async function render(url, options = {}) {`,
+    // Resolve the matched pages BEFORE rendering.
+    //
+    // Pages are React.lazy() in the route manifest, which is right for the browser and pure loss
+    // here: the server already has every chunk on local disk. Rendering without this makes React
+    // suspend on the page component, so \`onShellReady\` fires with the layout alone and the actual
+    // page streams afterwards inside a hidden div. The reader gets an empty frame that fills in --
+    // measured at CLS 1.12 and an article absent from the DOM for ~700ms on a real site.
+    //
+    // This mirrors what entry.ts already does before hydrateRoot, using the same preload map.
+    // Streaming still applies to genuine data-fetching Suspense, which is where it earns its keep.
+    // A failed import is swallowed on purpose: React.lazy will retry and suspend as before, which
+    // is strictly no worse than not having preloaded at all.
+    `  const __theoMatches = matchRoutes(routes, url.split('?')[0]) ?? []`,
+    `  await Promise.all(`,
+    `    __theoMatches`,
+    `      .map((m) => m.route && m.route.path)`,
+    `      .filter((p) => typeof p === 'string' && p in __theoPreloadMap)`,
+    `      .map((p) => __theoPreloadMap[p]().catch(() => null)),`,
+    `  )`,
+    ``,
     `  const handler = createStaticHandler(routes)`,
     `  const request = new Request('http://localhost' + url)`,
     `  const context = await handler.query(request)`,
@@ -1543,8 +1623,8 @@ function generateStreamingEntry(options) {
   return [
     `import React, { Suspense } from 'react'`,
     `import { renderToPipeableStream, renderToReadableStream } from 'react-dom/server'`,
-    `import { createStaticHandler, createStaticRouter, StaticRouterProvider } from 'react-router'`,
-    `import { routes } from '/@theo/route-manifest'`,
+    `import { createStaticHandler, createStaticRouter, StaticRouterProvider, matchRoutes } from 'react-router'`,
+    `import { routes, __theoPreloadMap } from '/@theo/route-manifest'`,
     theoUiImport,
     ``,
     ...streamingWebRenderer(appTree),
@@ -2121,4 +2201,4 @@ export {
   theoPluginAsync,
   theoPlugin
 };
-//# sourceMappingURL=chunk-Q2S2IGSM.js.map
+//# sourceMappingURL=chunk-7UMA5DY4.js.map