@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/production-jar9ztm3.js

@@ -0,0 +1,44 @@
+// @bun
+import {
+  BUILD_INDEX_VERSION,
+  attachRelease,
+  buildIndexFile,
+  captureConventions,
+  conventionFileExists,
+  frozenDirListing,
+  locateRelease,
+  productionRelease,
+  readBuildIndex,
+  releaseConfig,
+  releaseModuleHref,
+  releaseModuleKey,
+  releaseSourceFile,
+  releaseSourceKey,
+  serializeReleaseConfig,
+  servedAppFiles,
+  servedConventions,
+  servedRelease,
+  writeBuildIndex
+} from "./index-tqn2qnnn.js";
+import"./index-rt9qq1va.js";
+export {
+  BUILD_INDEX_VERSION,
+  attachRelease,
+  buildIndexFile,
+  captureConventions,
+  conventionFileExists,
+  frozenDirListing,
+  locateRelease,
+  productionRelease,
+  readBuildIndex,
+  releaseConfig,
+  releaseModuleHref,
+  releaseModuleKey,
+  releaseSourceFile,
+  releaseSourceKey,
+  serializeReleaseConfig,
+  servedAppFiles,
+  servedConventions,
+  servedRelease,
+  writeBuildIndex
+};

package/dist/server/_chunks/proxy-config-j84dgksn.js

@@ -0,0 +1,21 @@
+// @bun
+import {
+  releasedProxy,
+  staticProxyConfig
+} from "./index-tvqkq6e6.js";
+import"./index-kq8kpzye.js";
+import"./index-3xbr4eyv.js";
+import"./index-x93hv0sc.js";
+import"./index-tqn2qnnn.js";
+import"./index-grta8ap3.js";
+import"./index-kresp2n8.js";
+import"./index-e3a6yx84.js";
+import"./index-7wc9n8be.js";
+import"./index-pym1cezq.js";
+import"./index-zqpqyg8p.js";
+import"./index-qjj6gddn.js";
+import"./index-rt9qq1va.js";
+export {
+  releasedProxy,
+  staticProxyConfig
+};

package/dist/server/_chunks/proxy-w1d0wmsn.js

@@ -0,0 +1,33 @@
+// @bun
+import {
+  registerProxyExtensions
+} from "./index-sv8m6789.js";
+import"./index-2wfv4kvx.js";
+import"./index-eeaanp2e.js";
+import"./index-kq8kpzye.js";
+import"./index-3xbr4eyv.js";
+import"./index-6q7zvrap.js";
+import"./index-6e4fqv30.js";
+import"./index-cjgqs13g.js";
+import"./index-jks0x0a1.js";
+import"./index-6b009mt0.js";
+import"./index-4zzebszd.js";
+import"./index-sq3kvz3g.js";
+import"./index-ckkdpht5.js";
+import"./index-20ppawv7.js";
+import"./index-x93hv0sc.js";
+import"./index-tqn2qnnn.js";
+import"./index-en7n9f7m.js";
+import"./index-grta8ap3.js";
+import"./index-kresp2n8.js";
+import"./index-e3a6yx84.js";
+import"./index-z4z9zv3b.js";
+import"./index-yz54pxrh.js";
+import"./index-7wc9n8be.js";
+import"./index-pym1cezq.js";
+import"./index-zqpqyg8p.js";
+import"./index-qjj6gddn.js";
+import"./index-rt9qq1va.js";
+export {
+  registerProxyExtensions
+};

package/dist/server/_chunks/router-k1reahfn.js

@@ -0,0 +1,498 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  hasUseClientDirective
+} from "./index-rn8dyr1f.js";
+import {
+  getNextConfig
+} from "./index-6e4fqv30.js";
+import"./index-cjgqs13g.js";
+import"./index-jks0x0a1.js";
+import"./index-6b009mt0.js";
+import"./index-4zzebszd.js";
+import"./index-sq3kvz3g.js";
+import"./index-ckkdpht5.js";
+import {
+  listFiles,
+  listFilesSync,
+  toPosixPath
+} from "./index-20ppawv7.js";
+import"./index-x93hv0sc.js";
+import"./index-tqn2qnnn.js";
+import"./index-ras0sdab.js";
+import"./index-grta8ap3.js";
+import"./index-kresp2n8.js";
+import"./index-e3a6yx84.js";
+import"./index-z4z9zv3b.js";
+import"./index-yz54pxrh.js";
+import"./index-7wc9n8be.js";
+import"./index-pym1cezq.js";
+import"./index-zqpqyg8p.js";
+import"./index-qjj6gddn.js";
+import"./index-rt9qq1va.js";
+
+// src/compat/pages/router.ts
+import { createHash } from "crypto";
+import { existsSync, statSync } from "fs";
+import {
+  copyFile,
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  symlink,
+  writeFile
+} from "fs/promises";
+import path from "path";
+import { tmpdir } from "os";
+import { fileURLToPath } from "url";
+var basePageExtensions = ["tsx", "ts", "jsx", "js", "mjs"];
+function materializeExtensions() {
+  const configured = getNextConfig().pageExtensions;
+  const extras = Array.isArray(configured) ? configured.filter((ext) => typeof ext === "string" && ext.length > 0) : [];
+  return [...new Set([...basePageExtensions, ...extras])];
+}
+var appConventions = new Set([
+  "default",
+  "error",
+  "forbidden",
+  "global-error",
+  "layout",
+  "loading",
+  "not-found",
+  "page",
+  "route",
+  "template",
+  "unauthorized"
+]);
+var metadataConventionPattern = /^(robots|sitemap|manifest|icon\d*|apple-icon\d*|opengraph-image\d*|twitter-image\d*)$/;
+function isAppConvention(name) {
+  return appConventions.has(name) || metadataConventionPattern.test(name);
+}
+async function materializePagesApp(root, base = path.join(tmpdir(), "pnext-pages-compat")) {
+  const pagesPath = path.join(root, "pages");
+  if (!existsSync(pagesPath))
+    return;
+  const nativeApp = path.join(root, "app");
+  const pages = await discoverPages(pagesPath);
+  const apiRoutes = await discoverPagesApi(pagesPath);
+  if (pages.length === 0 && apiRoutes.length === 0)
+    return;
+  const generatedRoot = path.join(base, materializationKey(root, nativeApp, pages, apiRoutes));
+  const appPath = path.join(generatedRoot, "app");
+  if (existsSync(appPath))
+    return appPath;
+  const staging = `${generatedRoot}.${process.pid.toString(36)}.staging`;
+  await buildMaterializedApp(staging, root, pagesPath, nativeApp, pages, apiRoutes);
+  try {
+    await rename(staging, generatedRoot);
+  } catch {
+    await rm(staging, { recursive: true, force: true });
+    if (!existsSync(appPath))
+      throw new Error(`pnext: could not materialize ${root}/pages`);
+  }
+  sweepStaleMaterializations(base, isInsideApp(root, generatedRoot) ? path.basename(generatedRoot) : undefined);
+  return appPath;
+}
+var isInsideApp = (root, dir) => !path.relative(root, dir).startsWith("..");
+function materializedLinkTarget(root, generatedRoot, target) {
+  return isInsideApp(root, generatedRoot) ? path.relative(generatedRoot, target) : target;
+}
+function materializationKey(root, nativeApp, pages, apiRoutes) {
+  const stamp = (file) => {
+    const info = statSync(file, { throwIfNoEntry: false });
+    return info ? `${info.size}:${info.mtimeMs}` : "";
+  };
+  const nativeFiles = existsSync(nativeApp) ? listFilesSync(nativeApp).map((file) => `${toPosixPath(path.relative(nativeApp, file))}\x00${stamp(file)}`).sort() : [];
+  const byRelative = (routes) => [...routes].sort((a, b) => a.relative.localeCompare(b.relative));
+  return createHash("sha256").update(JSON.stringify([
+    root,
+    materializeExtensions(),
+    byRelative(pages),
+    byRelative(apiRoutes),
+    nativeFiles,
+    stamp(fileURLToPath(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/compat/pages/router.ts").href))
+  ])).digest("hex").slice(0, 16);
+}
+var STALE_MATERIALIZATION_MS = 7 * 24 * 60 * 60000;
+async function sweepStaleMaterializations(base, current) {
+  try {
+    const cutoff = current ? Infinity : Date.now() - STALE_MATERIALIZATION_MS;
+    for (const entry of await readdir(base)) {
+      if (current && (entry === current || entry.endsWith(".staging")))
+        continue;
+      const dir = path.join(base, entry);
+      const info = statSync(dir, { throwIfNoEntry: false });
+      if (info && info.mtimeMs < cutoff)
+        await rm(dir, { recursive: true, force: true });
+    }
+  } catch {}
+}
+async function buildMaterializedApp(generatedRoot, root, pagesPath, nativeApp, pages, apiRoutes) {
+  const appPath = path.join(generatedRoot, "app");
+  const sourcePages = path.join(generatedRoot, "source-pages");
+  const sourceApp = path.join(generatedRoot, "source-app");
+  const link = (target, at) => symlink(materializedLinkTarget(root, generatedRoot, target), at, "dir");
+  await rm(generatedRoot, { recursive: true, force: true });
+  await mkdir(appPath, { recursive: true });
+  await link(pagesPath, sourcePages);
+  const nodeModules = path.join(root, "node_modules");
+  if (existsSync(nodeModules) && !isInsideApp(root, generatedRoot)) {
+    await link(nodeModules, path.join(generatedRoot, "node_modules"));
+  }
+  const publicDir = path.join(root, "public");
+  if (existsSync(publicDir))
+    await link(publicDir, path.join(generatedRoot, "public"));
+  if (existsSync(nativeApp)) {
+    await link(nativeApp, sourceApp);
+    await materializeNativeApp(sourceApp, appPath);
+  }
+  if (!existsSync(path.join(appPath, "layout.js"))) {
+    await writeFile(path.join(appPath, "layout.js"), `export default function PagesLayout({ children }) {
+  return <html><body>{children}</body></html>
+}
+`);
+  }
+  for (const page of pages) {
+    const destination = path.join(appPath, ...encodePrivateSegments(page.segments), "page.js");
+    if (existsSync(destination))
+      continue;
+    await mkdir(path.dirname(destination), { recursive: true });
+    const pagesPattern = `/${page.segments.join("/")}`.replace(/\/+$/, "") || "/";
+    const sourceSpecifier = relativeImport(destination, path.join(sourcePages, page.relative));
+    let clientSpecifier;
+    if (page.hasStaticProps || page.hasServerSideProps) {
+      const clientDestination = path.join(path.dirname(destination), "pnext-page-client.js");
+      await writeFile(clientDestination, `'use client';
+export { default } from ${JSON.stringify(sourceSpecifier)};
+`);
+      clientSpecifier = "./pnext-page-client.js";
+    }
+    await writeFile(destination, wrapperSource(sourceSpecifier, !page.hasServerSideProps && !page.hasStaticProps, page.hasServerSideProps, page.hasStaticProps, clientSpecifier, page.runtime, page.maxDuration, pagesPattern));
+  }
+  for (const apiRoute of apiRoutes) {
+    const destination = path.join(appPath, "api", ...apiRoute.segments, "route.js");
+    if (existsSync(destination))
+      continue;
+    await mkdir(path.dirname(destination), { recursive: true });
+    await writeFile(destination, pagesApiWrapperSource(relativeImport(destination, path.join(sourcePages, apiRoute.relative)), apiRoute.runtime));
+  }
+}
+async function materializeNativeApp(sourceApp, appPath) {
+  for (const file of await listFiles(sourceApp)) {
+    const relative = toPosixPath(path.relative(sourceApp, file));
+    const parsed = path.parse(relative);
+    if (!materializeExtensions().includes(parsed.ext.slice(1))) {
+      const destination2 = path.join(appPath, relative);
+      await mkdir(path.dirname(destination2), { recursive: true });
+      await copyFile(file, destination2);
+      continue;
+    }
+    if (!isAppConvention(parsed.name))
+      continue;
+    const destination = path.join(appPath, parsed.dir, `${parsed.name}.js`);
+    await mkdir(path.dirname(destination), { recursive: true });
+    const source = await readFile(file, "utf8");
+    const client = hasUseClientDirective(source) || await defaultExportImportsClientModule(file, source);
+    await writeFile(destination, wrapperSource(relativeImport(destination, file), client, false, false, undefined, runtimeFromSource(source)));
+  }
+}
+async function defaultExportImportsClientModule(file, source) {
+  const defaultExport = /export\s+default\s+([A-Za-z_$][\w$]*)\s*;?/.exec(source);
+  if (!defaultExport?.[1])
+    return false;
+  const binding = defaultExport[1];
+  const imports = /import\s*\{([^}]*)\}\s*from\s*['"]([^'"]+)['"]/g;
+  let match;
+  while (match = imports.exec(source)) {
+    const importsBinding = (match[1] ?? "").split(",").some((value) => {
+      const names = /^\s*([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?\s*$/.exec(value);
+      return (names?.[2] ?? names?.[1]) === binding;
+    });
+    if (!importsBinding || !match[2]?.startsWith("."))
+      continue;
+    const imported = resolveSourceImport(file, match[2]);
+    if (imported && hasUseClientDirective(await readFile(imported, "utf8")))
+      return true;
+  }
+  return false;
+}
+function resolveSourceImport(file, specifier) {
+  const base = path.resolve(path.dirname(file), specifier);
+  for (const candidate of [
+    base,
+    ...materializeExtensions().flatMap((extension) => [
+      `${base}.${extension}`,
+      path.join(base, `index.${extension}`)
+    ])
+  ]) {
+    if (existsSync(candidate) && statSync(candidate).isFile())
+      return candidate;
+  }
+  return;
+}
+function encodePrivateSegments(segments) {
+  return segments.map((segment) => segment.startsWith("_") ? `%5F${segment.slice(1)}` : segment);
+}
+async function discoverPages(pagesPath) {
+  const routes = new Map;
+  const files = await listFiles(pagesPath);
+  for (const extension of materializeExtensions()) {
+    for (const file of files) {
+      if (!file.endsWith(`.${extension}`))
+        continue;
+      const relative = toPosixPath(path.relative(pagesPath, file));
+      const withoutExtension = relative.slice(0, -extension.length - 1);
+      const sourceSegments = withoutExtension.split("/");
+      if (sourceSegments[0] === "api")
+        continue;
+      if (sourceSegments.length === 1 && (sourceSegments[0] === "_app" || sourceSegments[0] === "_document" || sourceSegments[0] === "_error")) {
+        continue;
+      }
+      const segments = sourceSegments.at(-1) === "index" ? sourceSegments.slice(0, -1) : sourceSegments;
+      const key = segments.join("/");
+      if (!routes.has(key)) {
+        const source = await readFile(file, "utf8");
+        routes.set(key, {
+          relative,
+          segments,
+          hasServerSideProps: /\bgetServerSideProps\b/.test(source),
+          hasStaticProps: /\bgetStaticProps\b/.test(source),
+          runtime: runtimeFromSource(source),
+          maxDuration: maxDurationFromSource(source)
+        });
+      }
+    }
+  }
+  return [...routes.values()];
+}
+async function discoverPagesApi(pagesPath) {
+  const routes = new Map;
+  const files = await listFiles(path.join(pagesPath, "api"));
+  for (const extension of materializeExtensions()) {
+    for (const file of files) {
+      if (!file.endsWith(`.${extension}`))
+        continue;
+      const relative = toPosixPath(path.relative(pagesPath, file));
+      const segments = relative.slice(0, -extension.length - 1).split("/").slice(1);
+      if (segments.some((segment) => segment.startsWith("_")))
+        continue;
+      const key = segments.join("/");
+      if (routes.has(key))
+        continue;
+      routes.set(key, {
+        relative,
+        segments,
+        runtime: runtimeFromSource(await readFile(file, "utf8"))
+      });
+    }
+  }
+  return [...routes.values()];
+}
+function routerStateModulePath() {
+  return path.join(__PNEXT_PACKAGE_ROOT__ + "/src/compat/pages", "router-state.ts");
+}
+function routerStateSnippet(pagesPattern) {
+  if (!pagesPattern) {
+    return { imports: "", render: "return createElement(Page, result?.props ?? {});" };
+  }
+  return {
+    imports: `import { pagesRouterSsrState, serializePagesRouterState } from ${JSON.stringify(routerStateModulePath())};
+`,
+    render: `const routerState = pagesRouterSsrState(${JSON.stringify(pagesPattern)}, resolvedParams);
+  return createElement(
+    Fragment,
+    null,
+    createElement('script', {
+      type: 'application/json',
+      id: '__PNEXT_PAGES_DATA__',
+      dangerouslySetInnerHTML: { __html: serializePagesRouterState(routerState) },
+    }),
+    createElement(Page, result?.props ?? {}),
+  );`
+  };
+}
+function wrapperSource(specifier, client = false, hasServerSideProps = false, hasStaticProps = false, clientSpecifier, runtime, maxDuration, pagesPattern) {
+  const runtimeExport = runtime ? `export const runtime = ${JSON.stringify(runtime)};
+` : "";
+  const maxDurationExport = maxDuration === undefined ? "" : `export const maxDuration = ${maxDuration};
+`;
+  const routerState = routerStateSnippet(pagesPattern);
+  if (hasStaticProps && clientSpecifier) {
+    return `import { createElement, Fragment } from 'react';
+import { notFound, redirect } from 'next/navigation';
+import Page from ${JSON.stringify(clientSpecifier)};
+import * as pageModule from ${JSON.stringify(specifier)};
+${routerState.imports}export * from ${JSON.stringify(specifier)};
+${runtimeExport}${maxDurationExport}export default async function PagesCompatStaticPage({ params }) {
+  // The otel compat exposes a span wrapper (Render.getStaticProps) at runtime.
+  const withSpan = globalThis.__PNEXT_PAGES_DATA_SPAN__ ?? ((kind, fn) => fn());
+  const resolvedParams = await params;
+  const invoke = async () => pageModule.getStaticProps?.({ params: resolvedParams });
+  const result = await withSpan('getStaticProps', invoke);
+  if (result?.notFound) notFound();
+  if (result?.redirect) redirect(result.redirect.destination);
+  ${routerState.render}
+}
+`;
+  }
+  if (!hasServerSideProps) {
+    if (client) {
+      return `'use client';
+export { default } from ${JSON.stringify(specifier)};
+${runtimeExport}${maxDurationExport}`;
+    }
+    return `import * as __pnext_page_ns from ${JSON.stringify(specifier)};
+export default __pnext_page_ns.default;
+export * from ${JSON.stringify(specifier)};
+${runtimeExport}${maxDurationExport}`;
+  }
+  return `import { createElement, Fragment } from 'react';
+import { notFound, redirect } from 'next/navigation';
+import { cookies, headers } from 'next/headers';
+import Page from ${JSON.stringify(clientSpecifier)};
+import * as pageModule from ${JSON.stringify(specifier)};
+${routerState.imports}export * from ${JSON.stringify(specifier)};
+export const dynamic = 'force-dynamic';
+${runtimeExport}${maxDurationExport}export default async function PagesCompatPage({ params, searchParams }) {
+  // The otel compat exposes a span wrapper (Render.getServerSideProps) at runtime.
+  const withSpan = globalThis.__PNEXT_PAGES_DATA_SPAN__ ?? ((kind, fn) => fn());
+  const resolvedParams = await params;
+  // getServerSideProps reads a node-shaped \`req\`/\`res\`. This page is
+  // force-dynamic, so headers()/cookies() are available; \`method\` is always
+  // 'GET' and \`res\` is inert (writes are dropped) \u2014 a workable baseline until
+  // the pages layer threads the real request through.
+  const requestHeaders = Object.fromEntries((await headers()).entries());
+  const requestCookies = Object.fromEntries(
+    (await cookies()).getAll().map(cookie => [cookie.name, cookie.value]),
+  );
+  const invoke = async () => pageModule.getServerSideProps?.({
+    params: resolvedParams,
+    query: (await searchParams) ?? {},
+    req: {
+      headers: requestHeaders,
+      cookies: requestCookies,
+      method: 'GET',
+      url: ${JSON.stringify(pagesPattern ?? "/")},
+    },
+    res: {
+      statusCode: 200,
+      setHeader() {},
+      getHeader() {},
+      getHeaders() { return {}; },
+      removeHeader() {},
+      end() {},
+      write() { return true; },
+    },
+    resolvedUrl: ${JSON.stringify(pagesPattern ?? "/")},
+    preview: false,
+    previewData: undefined,
+    draftMode: false,
+  });
+  const result = await withSpan('getServerSideProps', invoke);
+  if (result?.notFound) notFound();
+  if (result?.redirect) redirect(result.redirect.destination);
+  ${routerState.render}
+}
+`;
+}
+function runtimeFromSource(source) {
+  const runtime = /\bruntime\b\s*[:=]\s*(['"`])(edge|nodejs|experimental-edge)\1/.exec(source)?.[2];
+  return runtime === "experimental-edge" ? "edge" : runtime;
+}
+function maxDurationFromSource(source) {
+  const value = /\bmaxDuration\s*:\s*(\d+)\b/.exec(source)?.[1];
+  return value === undefined ? undefined : Number(value);
+}
+function pagesApiWrapperSource(specifier, runtime) {
+  const runtimeExport = runtime ? `export const runtime = ${JSON.stringify(runtime)};
+` : "";
+  return `import handler from ${JSON.stringify(specifier)};
+import { NextRequest } from 'next/server';
+import { Writable } from 'node:stream';
+${runtimeExport}export async function GET(request) {
+  return run(handler, request);
+}
+export async function POST(request) {
+  return run(handler, request);
+}
+export async function PUT(request) {
+  return run(handler, request);
+}
+export async function PATCH(request) {
+  return run(handler, request);
+}
+export async function DELETE(request) {
+  return run(handler, request);
+}
+// Bridge a pages-API handler onto the app-route Response contract. Edge-style
+// handlers (request-only, return a Response) pass through; node-style handlers
+// get a real Writable \`res\` whose bytes stream into the Response body, with
+// client disconnects surfaced as res 'close'/destroy (stream cancellation).
+async function run(handler, request) {
+  const nextRequest = request instanceof NextRequest ? request : new NextRequest(request);
+  const state = { status: 200, headers: new Headers() };
+  let controller;
+  let started = false;
+  let notifyStarted = () => {};
+  const startedPromise = new Promise(resolve => { notifyStarted = resolve; });
+  const start = () => {
+    if (!started) {
+      started = true;
+      notifyStarted();
+    }
+  };
+  const body = new ReadableStream({
+    start(c) { controller = c; },
+    cancel() { res.destroy(); },
+  });
+  const enqueue = chunk => {
+    try {
+      controller.enqueue(typeof chunk === 'string' ? new TextEncoder().encode(chunk) : new Uint8Array(chunk));
+    } catch {}
+  };
+  const res = new Writable({
+    write(chunk, _encoding, callback) { start(); enqueue(chunk); callback(); },
+    final(callback) { start(); try { controller.close(); } catch {} callback(); },
+    destroy(error, callback) { try { controller.close(); } catch {} callback(error); },
+  });
+  Object.defineProperty(res, 'statusCode', {
+    get: () => state.status,
+    set: value => { state.status = value; },
+  });
+  res.setHeader = (name, value) => { state.headers.set(name, String(value)); return res; };
+  res.getHeader = name => state.headers.get(name) ?? undefined;
+  res.removeHeader = name => { state.headers.delete(name); };
+  res.status = code => { state.status = code; return res; };
+  res.json = value => { state.headers.set('content-type', 'application/json'); res.end(JSON.stringify(value)); };
+  res.send = value => { res.end(value); };
+  // A client disconnect aborts the request signal; pages handlers observe it
+  // as the response closing (res.on('close') per Node semantics).
+  request.signal?.addEventListener?.('abort', () => res.destroy(), { once: true });
+  const finished = Promise.resolve()
+    .then(() => handler(nextRequest, res))
+    .catch(error => {
+      if (!started) throw error;
+      try { controller.error(error); } catch {}
+    });
+  const outcome = await Promise.race([
+    startedPromise.then(() => 'started'),
+    finished.then(() => 'done'),
+  ]);
+  if (outcome === 'done' && !started) {
+    const result = await finished;
+    return result instanceof Response ? result : new Response(null, { status: state.status, headers: state.headers });
+  }
+  return new Response(body, { status: state.status, headers: state.headers });
+}
+`;
+}
+function relativeImport(fromFile, targetFile) {
+  const relative = toPosixPath(path.relative(path.dirname(fromFile), targetFile));
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+export {
+  materializePagesApp
+};

package/dist/server/_chunks/routes-2s277fc6.js

@@ -0,0 +1,64 @@
+// @bun
+import {
+  addClientEntryReason,
+  assertNoServerActionsWithoutCompat,
+  collectFileCss,
+  collectNotFoundCss,
+  materializeRouteFacts,
+  materializeRouteFactsPaced,
+  routeFactsResolved,
+  routeFactsVersion,
+  scanRoutes,
+  setRouteFactsStore
+} from "./index-8k7pfejn.js";
+import"./index-91x12ykq.js";
+import {
+  findConventionFiles,
+  findGlobalError,
+  findLayouts,
+  matchInterception,
+  matchRoute,
+  normalizePathname,
+  parseNavState,
+  selectRouteForRequest,
+  serverActionsUnsupportedMessage
+} from "./index-jepjvcrf.js";
+import"./index-2dv4y4wd.js";
+import"./index-73z4esab.js";
+import"./index-y2jr2n72.js";
+import"./index-web361b8.js";
+import"./index-fp8r0sqs.js";
+import"./index-cjgqs13g.js";
+import"./index-p77b4kcx.js";
+import"./index-20ppawv7.js";
+import"./index-tqn2qnnn.js";
+import"./index-6kp9r0d9.js";
+import"./index-ras0sdab.js";
+import"./index-z4z9zv3b.js";
+import"./index-yz54pxrh.js";
+import"./index-7wc9n8be.js";
+import"./index-pym1cezq.js";
+import"./index-zqpqyg8p.js";
+import"./index-qjj6gddn.js";
+import"./index-rt9qq1va.js";
+export {
+  addClientEntryReason,
+  assertNoServerActionsWithoutCompat,
+  collectFileCss,
+  collectNotFoundCss,
+  findConventionFiles,
+  findGlobalError,
+  findLayouts,
+  matchInterception,
+  matchRoute,
+  materializeRouteFacts,
+  materializeRouteFactsPaced,
+  normalizePathname,
+  parseNavState,
+  routeFactsResolved,
+  routeFactsVersion,
+  scanRoutes,
+  selectRouteForRequest,
+  serverActionsUnsupportedMessage,
+  setRouteFactsStore
+};