@wular/pnext 0.1.6 → 0.1.8

package/dist/server/_chunks/index-grta8ap3.js

@@ -0,0 +1,238 @@
+// @bun
+import {
+  cacheComponents,
+  hangingPromise,
+  isPrerendering,
+  isRuntimePrefetchPrerender,
+  markRuntimeApiOnAwait
+} from "./index-kresp2n8.js";
+import {
+  PostponeError
+} from "./index-e3a6yx84.js";
+
+// src/request/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var WORK_UNIT_STORAGE = Symbol.for("pnext.workUnitStorage");
+var workUnitStorage = globalThis[WORK_UNIT_STORAGE] ??= new AsyncLocalStorage;
+function runWithWorkUnit(phase, callback) {
+  const unit = { phase, afterTasks: [], flushed: false };
+  return workUnitStorage.run(unit, callback);
+}
+function getWorkUnit() {
+  return workUnitStorage.getStore();
+}
+function setWorkUnitRelease(release) {
+  const unit = workUnitStorage.getStore();
+  if (unit)
+    unit.release = release;
+}
+function setPhase(phase) {
+  const unit = workUnitStorage.getStore();
+  if (unit)
+    unit.phase = phase;
+}
+function setWorkUnitRoute(routeKind, routeMode, responseHints) {
+  const unit = workUnitStorage.getStore();
+  if (!unit)
+    return;
+  unit.routeKind = routeKind;
+  if (routeMode)
+    unit.routeMode = routeMode;
+  if (responseHints)
+    unit.responseHints = responseHints;
+}
+function queueAfterTask(task) {
+  const unit = workUnitStorage.getStore();
+  if (!unit)
+    return false;
+  unit.afterTasks.push(task);
+  return true;
+}
+function flushWorkUnit(unit = workUnitStorage.getStore()) {
+  if (!unit || unit.flushed)
+    return;
+  unit.flushed = true;
+  if (unit.afterTasks.length === 0)
+    return;
+  const afterUnit = { ...unit, phase: "after" };
+  const flushing = workUnitStorage.run(afterUnit, async () => {
+    while (afterUnit.afterTasks.length) {
+      const tasks = afterUnit.afterTasks;
+      afterUnit.afterTasks = [];
+      for (const task of tasks) {
+        try {
+          await task();
+        } catch (error) {
+          console.error("after() task failed:", error);
+        }
+      }
+    }
+  });
+  pendingFlushes.add(flushing);
+  flushing.finally(() => pendingFlushes.delete(flushing));
+}
+var pendingFlushes = new Set;
+async function drainWorkUnits(timeoutMs = 1e4) {
+  if (pendingFlushes.size === 0)
+    return;
+  await Promise.race([
+    Promise.allSettled([...pendingFlushes]),
+    new Promise((resolve) => setTimeout(resolve, timeoutMs))
+  ]);
+}
+function flushWorkUnitOnClose(response, unit, signal) {
+  if (!unit)
+    return response;
+  if (!response.body) {
+    flushWorkUnit(unit);
+    return response;
+  }
+  if (response.headers.has("content-length")) {
+    flushWorkUnit(unit);
+    return response;
+  }
+  const reader = response.body.getReader();
+  const settle = () => {
+    signal?.removeEventListener("abort", settle);
+    flushWorkUnit(unit);
+  };
+  if (signal?.aborted)
+    settle();
+  else
+    signal?.addEventListener("abort", settle, { once: true });
+  const observed = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          settle();
+          controller.close();
+        } else {
+          controller.enqueue(chunk.value);
+        }
+      } catch (error) {
+        settle();
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      settle();
+      return reader.cancel(reason);
+    }
+  });
+  return new Response(observed, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+var REQUEST_STORAGE = Symbol.for("pnext.requestStorage");
+var requestStorage = globalThis[REQUEST_STORAGE] ??= new AsyncLocalStorage;
+function currentRequest() {
+  return requestStorage.getStore()?.request;
+}
+var WORK_UNIT_EXTERNAL = Symbol.for("pnext.workUnitExternal");
+function workUnitExternalStore() {
+  const request = currentRequest();
+  const type = isRuntimePrefetchPrerender() ? "prerender-runtime" : isPrerendering() || !request ? "prerender" : "request";
+  return {
+    type,
+    cookies: request?.cookies,
+    headers: request?.headers ?? new Headers
+  };
+}
+globalThis[WORK_UNIT_EXTERNAL] = workUnitExternalStore;
+function captureRequestScope() {
+  const scope = requestStorage.getStore();
+  if (!scope)
+    return (fn) => fn();
+  return (fn) => requestStorage.run(scope, fn);
+}
+function currentParams() {
+  return requestStorage.getStore()?.params ?? {};
+}
+function runWithRequest(request, callback, params = {}, extras = {}) {
+  if (!request)
+    return callback();
+  const scope = {
+    request,
+    params,
+    afterCallbacks: [],
+    responseHeaders: extras.responseHeaders
+  };
+  const result = requestStorage.run(scope, callback);
+  if (isThenable(result)) {
+    return result.then((value) => {
+      flushAfterCallbacks(scope);
+      return value;
+    }, (error) => {
+      flushAfterCallbacks(scope);
+      throw error;
+    });
+  }
+  flushAfterCallbacks(scope);
+  return result;
+}
+function currentResponseHeaders() {
+  return requestStorage.getStore()?.responseHeaders;
+}
+async function flushAfterCallbacks(scope) {
+  while (scope.afterCallbacks?.length) {
+    const callbacks = scope.afterCallbacks;
+    scope.afterCallbacks = [];
+    for (const callback of callbacks) {
+      try {
+        await requestStorage.run(scope, callback);
+      } catch (error) {
+        console.error("after() callback failed:", error);
+      }
+    }
+  }
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+var BAILOUT_PROBE = Symbol.for("pnext.dynamicBailoutProbe");
+function beginDynamicBailoutProbe(route) {
+  globalThis[BAILOUT_PROBE] = route;
+}
+function endDynamicBailoutProbe() {
+  delete globalThis[BAILOUT_PROBE];
+}
+function dynamicBailoutRoute() {
+  const route = globalThis[BAILOUT_PROBE];
+  return typeof route === "string" ? route : undefined;
+}
+var LEGACY_REQUEST_APIS = Symbol.for("pnext.legacyRequestAPIs");
+function setLegacyRequestAPIs(enabled) {
+  globalThis[LEGACY_REQUEST_APIS] = enabled;
+}
+function legacyRequestAPIs() {
+  return globalThis[LEGACY_REQUEST_APIS] === true;
+}
+function requireRequest(api) {
+  const probeRoute = dynamicBailoutRoute();
+  if (probeRoute !== undefined) {
+    const error = new Error(`Route ${probeRoute} couldn't be rendered statically because it used \`${api.replace(/\(\)$/, "")}\`. ` + `See more info here: https://nextjs.org/docs/messages/dynamic-server-error`);
+    error.name = "DynamicServerError";
+    throw error;
+  }
+  const request = currentRequest();
+  if (!request) {
+    if (isPrerendering())
+      throw new PostponeError(api);
+    throw new Error(`${api} can only be used while rendering a dynamic PNext request.`);
+  }
+  return request;
+}
+function requestApiPromise(api, produce) {
+  if (isPrerendering() && cacheComponents()) {
+    if (isRuntimePrefetchPrerender() && api !== "connection()") {
+      return markRuntimeApiOnAwait(Promise.resolve(produce()));
+    }
+    return hangingPromise(api);
+  }
+  return Promise.resolve(produce());
+}
+
+export { runWithWorkUnit, getWorkUnit, setWorkUnitRelease, setPhase, setWorkUnitRoute, queueAfterTask, flushWorkUnit, drainWorkUnits, flushWorkUnitOnClose, currentRequest, captureRequestScope, currentParams, runWithRequest, currentResponseHeaders, beginDynamicBailoutProbe, endDynamicBailoutProbe, setLegacyRequestAPIs, legacyRequestAPIs, requireRequest, requestApiPromise };

package/dist/server/_chunks/index-h2a70tg4.js

@@ -0,0 +1,7 @@
+// @bun
+// src/compat/react/router-shim.ts
+function nextRouterShimScript() {
+  return '<script>window.next=window.next||{};window.next.version=window.next.version||"16.3.0";(function(){' + "var r=window.next.router=window.next.router||{};" + 'function d(){try{var n=document.getElementById("__PNEXT_PAGES_DATA__");' + "return n&&n.textContent?JSON.parse(n.textContent):null}catch(e){return null}}" + "function q(){var s=d(),o={};if(s&&s.query){for(var k in s.query)o[k]=s.query[k]}" + 'new URLSearchParams(location.search).forEach(function(v,k){if(k!=="_rsc")o[k]=v});return o}' + "r.isReady=true;r.isFallback=r.isFallback||false;" + 'if(!Object.getOwnPropertyDescriptor(r,"query"))Object.defineProperty(r,"query",{get:q,configurable:true});' + 'if(!Object.getOwnPropertyDescriptor(r,"pathname"))Object.defineProperty(r,"pathname",{get:function(){var s=d();return(s&&s.pathname)||location.pathname},configurable:true});' + 'if(!Object.getOwnPropertyDescriptor(r,"asPath"))Object.defineProperty(r,"asPath",{get:function(){return location.pathname+location.search},configurable:true});' + "r.push=r.push||function(href){var s=String(href);" + "if(window.__PNEXT_ROUTER__&&window.__PNEXT_ROUTER__.navigate){return window.__PNEXT_ROUTER__.navigate(s).then(function(){return true})}" + "location.assign(s);return Promise.resolve(true)};" + "r.replace=r.replace||function(href){location.replace(String(href));return Promise.resolve(true)};" + "r.prefetch=r.prefetch||function(){return Promise.resolve(null)};" + "})();</script>";
+}
+
+export { nextRouterShimScript };

package/dist/server/_chunks/index-h4xy648y.js

@@ -0,0 +1,51 @@
+// @bun
+// src/compat/react/use.ts
+import { useContext } from "preact/hooks";
+var REPLAY_STATE_KEY = Symbol.for("pnext.useReplayState");
+var replayState = globalThis[REPLAY_STATE_KEY] ??= {
+  active: null,
+  index: 0
+};
+function withUseThenableState(state, run) {
+  const previousState = replayState.active;
+  const previousIndex = replayState.index;
+  replayState.active = state;
+  replayState.index = 0;
+  try {
+    return run();
+  } finally {
+    replayState.active = previousState;
+    replayState.index = previousIndex;
+  }
+}
+function use(usable) {
+  if (usable && typeof usable.then === "function") {
+    let thenable = usable;
+    if (replayState.active) {
+      const index = replayState.index++;
+      const existing = replayState.active.thenables[index];
+      if (existing)
+        thenable = existing;
+      else
+        replayState.active.thenables[index] = thenable;
+    }
+    if (thenable.status === "fulfilled")
+      return thenable.value;
+    if (thenable.status === "rejected")
+      throw thenable.reason;
+    if (thenable.status !== "pending") {
+      thenable.status = "pending";
+      thenable.then((value) => {
+        thenable.status = "fulfilled";
+        thenable.value = value;
+      }, (reason) => {
+        thenable.status = "rejected";
+        thenable.reason = reason;
+      });
+    }
+    throw thenable;
+  }
+  return useContext(usable);
+}
+
+export { withUseThenableState, use };

package/dist/server/_chunks/index-hdbwtdv2.js

@@ -0,0 +1,352 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  splitResourceQuery
+} from "./index-jt8e1pje.js";
+
+// src/runtime/production.ts
+import { existsSync, readFileSync as readFileSync2, readdirSync, realpathSync } from "fs";
+import { rename, writeFile } from "fs/promises";
+import path2 from "path";
+import { pathToFileURL } from "url";
+
+// src/runtime/prebundle.ts
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var PREBUNDLE_STAMP = path.join("dist", "server", "generation.json");
+var prebundle = typeof { version: "0.1.8", fingerprint: "64aaa993cbaa58df", entries: ["cli/index", "cli/start", "client/reference", "api/client-cache", "compat/next/canonical-url", "compat/next/link-transform", "compat/next/client-navigation", "compat/next/og", "compat/next/link", "compat/next/usage", "compat/next/client-script", "compat/next/headers", "compat/next/custom-server", "compat/next/legacy-image", "compat/next/router", "compat/next/navigation", "compat/next/dist/server/web/spec-extension/unstable-no-store", "compat/next/dist/server/web/spec-extension/unstable-cache", "compat/next/dist/server/web/spec-extension/revalidate", "compat/next/dist/client/components/app-router-headers", "compat/next/web-vitals", "compat/next/root-params", "compat/next/route-state", "compat/next/server-only", "compat/next/client-server", "compat/next/legacy-request-apis", "compat/next/redirects", "compat/next/resource-hints", "compat/next/svgr", "compat/next/client-only", "compat/next/image/props", "compat/next/image/optimizer", "compat/next/image/validate", "compat/next/image/shared", "compat/next/image/patterns", "compat/next/image/config", "compat/next/image/client", "compat/next/image/static-metadata", "compat/next/user-agent", "compat/next/client-cache", "compat/next/head", "compat/next/dynamic", "compat/next/telemetry", "compat/next/offline", "compat/next/cache", "compat/next/constants", "compat/next/error", "compat/next/script", "compat/next/index", "compat/next/font/shared", "compat/next/font/runtime", "compat/next/font/google", "compat/next/font/cache", "compat/next/font/runtime-client", "compat/next/font/local", "compat/next/font/index", "compat/next/config-loader", "compat/next/config", "compat/next/image", "compat/next/server", "compat/next/rewrites", "compat/next/preferred-region", "compat/next/config-headers", "compat/next/form", "compat/react/dom", "compat/react/hooks-extra", "compat/react/react-server", "compat/react/dom-client", "compat/react/style-values", "compat/react/compiler-runtime", "compat/react/router-shim", "compat/react/dom-server", "compat/react/dom-react-server", "compat/react/server-component-use", "compat/react/action-state", "compat/react/client", "compat/react/client-lite", "compat/react/server-inserted-html", "compat/react/parity", "compat/react/preact", "compat/react/use", "compat/react/view-transition", "compat/react/internals", "compat/react/server"] } === "object" ? { version: "0.1.8", fingerprint: "64aaa993cbaa58df", entries: ["cli/index", "cli/start", "client/reference", "api/client-cache", "compat/next/canonical-url", "compat/next/link-transform", "compat/next/client-navigation", "compat/next/og", "compat/next/link", "compat/next/usage", "compat/next/client-script", "compat/next/headers", "compat/next/custom-server", "compat/next/legacy-image", "compat/next/router", "compat/next/navigation", "compat/next/dist/server/web/spec-extension/unstable-no-store", "compat/next/dist/server/web/spec-extension/unstable-cache", "compat/next/dist/server/web/spec-extension/revalidate", "compat/next/dist/client/components/app-router-headers", "compat/next/web-vitals", "compat/next/root-params", "compat/next/route-state", "compat/next/server-only", "compat/next/client-server", "compat/next/legacy-request-apis", "compat/next/redirects", "compat/next/resource-hints", "compat/next/svgr", "compat/next/client-only", "compat/next/image/props", "compat/next/image/optimizer", "compat/next/image/validate", "compat/next/image/shared", "compat/next/image/patterns", "compat/next/image/config", "compat/next/image/client", "compat/next/image/static-metadata", "compat/next/user-agent", "compat/next/client-cache", "compat/next/head", "compat/next/dynamic", "compat/next/telemetry", "compat/next/offline", "compat/next/cache", "compat/next/constants", "compat/next/error", "compat/next/script", "compat/next/index", "compat/next/font/shared", "compat/next/font/runtime", "compat/next/font/google", "compat/next/font/cache", "compat/next/font/runtime-client", "compat/next/font/local", "compat/next/font/index", "compat/next/config-loader", "compat/next/config", "compat/next/image", "compat/next/server", "compat/next/rewrites", "compat/next/preferred-region", "compat/next/config-headers", "compat/next/form", "compat/react/dom", "compat/react/hooks-extra", "compat/react/react-server", "compat/react/dom-client", "compat/react/style-values", "compat/react/compiler-runtime", "compat/react/router-shim", "compat/react/dom-server", "compat/react/dom-react-server", "compat/react/server-component-use", "compat/react/action-state", "compat/react/client", "compat/react/client-lite", "compat/react/server-inserted-html", "compat/react/parity", "compat/react/preact", "compat/react/use", "compat/react/view-transition", "compat/react/internals", "compat/react/server"] } : undefined;
+var packageRoot = path.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/runtime", "..", "..");
+var srcRoot = path.join(packageRoot, "src") + path.sep;
+var distRoot = path.join(packageRoot, "dist", "server");
+var entries = new Set(prebundle?.entries);
+function packageVersion(root) {
+  return JSON.parse(readFileSync(path.join(root, "package.json"), "utf8")).version;
+}
+function readPrebundleStamp(frameworkRoot, fingerprint) {
+  let stamp;
+  try {
+    stamp = JSON.parse(readFileSync(path.join(frameworkRoot, PREBUNDLE_STAMP), "utf8"));
+  } catch {
+    return;
+  }
+  return stamp.fingerprint === fingerprint && stamp.version === packageVersion(frameworkRoot) ? stamp : undefined;
+}
+function prebundledFile(file) {
+  if (!prebundle || !file.startsWith(srcRoot))
+    return file;
+  const entry = file.slice(srcRoot.length).replace(/\.tsx?$/, "");
+  return entries.has(entry) ? path.join(distRoot, `${entry}.js`) : file;
+}
+function registerResolvePlugin(plugin) {
+  globalThis.Bun.plugin(plugin);
+}
+var registered = false;
+function registerPrebundleResolve() {
+  if (!prebundle || registered)
+    return;
+  registered = true;
+  const escaped = srcRoot.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  registerResolvePlugin({
+    name: "pnext-prebundle",
+    setup(build) {
+      build.onResolve({ filter: new RegExp(`^${escaped}.*\\.tsx?$`) }, (args) => {
+        const target = prebundledFile(args.path);
+        return target === args.path ? undefined : { path: target };
+      });
+      build.onResolve({ filter: /^file:.*\.tsx?$/ }, (args) => {
+        const file = fileURLToPath(args.path);
+        const target = prebundledFile(file);
+        return target === file ? undefined : { path: target };
+      });
+      build.onResolve({ filter: /^\.\.?\/.*\/src\/.*\.tsx?$/ }, (args) => {
+        const file = path.resolve(path.dirname(args.importer), args.path);
+        const target = prebundledFile(file);
+        return target === file ? undefined : { path: target };
+      });
+    }
+  });
+}
+
+// src/runtime/production.ts
+var BUILD_INDEX_VERSION = 1;
+var releases = new WeakMap;
+var WORK_UNIT_STORAGE = Symbol.for("pnext.workUnitStorage");
+function buildIndexFile(outPath) {
+  return path2.join(outPath, "server", "build-index.json");
+}
+function buildManifestFile(outPath) {
+  return path2.join(outPath, "server", "manifest.json");
+}
+function releaseFrameworkRoot(outPath) {
+  try {
+    const { name } = JSON.parse(readFileSync2(path2.join(frameworkRoot, "package.json"), "utf8"));
+    return realpathSync(path2.join(outPath, "node_modules", name));
+  } catch {
+    return frameworkRoot;
+  }
+}
+function releaseSourceRoot(outPath, serializedOutPath) {
+  return path2.resolve(outPath, path2.relative(serializedOutPath, "."));
+}
+function standaloneOriginsFile(outPath) {
+  return path2.join(path2.dirname(outPath), "cache", "standalone.json");
+}
+var shippedRelease;
+function servingReleaseDir() {
+  if (shippedRelease === undefined) {
+    shippedRelease = null;
+    for (let dir = path2.dirname(frameworkRoot);dir !== path2.dirname(dir); dir = path2.dirname(dir)) {
+      if (path2.basename(dir) === "node_modules" && existsSync(buildIndexFile(path2.dirname(dir)))) {
+        shippedRelease = path2.dirname(dir);
+        break;
+      }
+    }
+  }
+  return shippedRelease ?? undefined;
+}
+var linkedReleases = new Map;
+function linkStandaloneOrigins(release) {
+  if (servingReleaseDir() === release)
+    return true;
+  const known = linkedReleases.get(release);
+  if (known !== undefined)
+    return known;
+  let origins;
+  try {
+    const parsed = JSON.parse(readFileSync2(standaloneOriginsFile(release), "utf8"));
+    if (parsed.release === release)
+      origins = parsed.origins;
+  } catch {
+    origins = undefined;
+  }
+  linkedReleases.set(release, origins !== undefined);
+  if (!origins)
+    return false;
+  const files = origins;
+  const modules = `${path2.join(release, "node_modules")}${path2.sep}`;
+  registerResolvePlugin({
+    name: "pnext-standalone-origins",
+    setup(build) {
+      build.onResolve({ filter: /node_modules\// }, (args) => {
+        const file = path2.resolve(path2.dirname(args.importer), splitResourceQuery(args.path).path);
+        if (!file.startsWith(modules))
+          return;
+        const origin = files[path2.relative(release, file).split(path2.sep).join("/")];
+        return origin && existsSync(origin) ? { path: prebundledFile(origin) } : undefined;
+      });
+    }
+  });
+  return true;
+}
+function releaseModuleKey(layer, target, file) {
+  return `${layer}:${target}:${file}`;
+}
+function productionRelease(config) {
+  return releases.get(config);
+}
+function servedRelease() {
+  const units = globalThis[WORK_UNIT_STORAGE];
+  return units?.getStore()?.release;
+}
+function servedConventions() {
+  return servedRelease()?.conventions;
+}
+function frozenDirListing(dir) {
+  const facts = servedConventions();
+  if (!facts || !isInsideDir(facts.appPath, dir))
+    return;
+  return facts.dirs.get(dir) ?? { files: new Set, dirs: [] };
+}
+function conventionFileExists(file) {
+  return frozenDirListing(path2.dirname(file))?.files.has(path2.basename(file)) ?? existsSync(file);
+}
+function releaseModuleHref(release, layer, target, file) {
+  const href = release.modules.get(releaseModuleKey(layer, target, path2.resolve(file)));
+  if (!href) {
+    throw new Error(`pnext: ${file} (${layer}, ${target}) is not in this build's release. Run 'pnext build' again.`);
+  }
+  return href;
+}
+function attachRelease(config, index = readBuildIndex(config.outPath)) {
+  const existing = releases.get(config);
+  if (existing)
+    return existing;
+  const fromRoot = (file) => path2.resolve(config.root, file);
+  const framework = releaseFrameworkRoot(config.outPath);
+  const modules = new Map;
+  for (const [key, artifact] of Object.entries(index.modules)) {
+    const second = key.indexOf(":", key.indexOf(":") + 1);
+    modules.set(`${key.slice(0, second + 1)}${releaseSourceFile(key.slice(second + 1), config.root, config.workspaceRoot, framework)}`, pathToFileURL(path2.resolve(config.outPath, artifact)).href);
+  }
+  const dirs = new Map;
+  for (const [dir, names] of Object.entries(index.conventions)) {
+    dirs.set(fromRoot(dir), {
+      files: new Set(names.filter((name) => !name.endsWith("/"))),
+      dirs: names.filter((name) => name.endsWith("/")).map((name) => name.slice(0, -1))
+    });
+  }
+  const release = {
+    modules,
+    conventions: {
+      appPath: config.appPath,
+      dirs,
+      client: new Set(index.clientConventions.map(fromRoot)),
+      documentLayouts: new Set(index.documentLayouts.map(fromRoot))
+    },
+    globalCss: index.globalCss.map(fromRoot),
+    proxy: index.proxy ? { ...index.proxy, file: fromRoot(index.proxy.file) } : {},
+    ...index.compat ? { compat: index.compat } : {},
+    ...index.instrumentation ? {
+      instrumentation: {
+        file: path2.resolve(config.outPath, index.instrumentation.file),
+        ...index.instrumentation.edge ? { edge: path2.resolve(config.outPath, index.instrumentation.edge) } : {}
+      }
+    } : {},
+    ...index.fonts ? {
+      fonts: Object.fromEntries(Object.entries(index.fonts).map(([key, font]) => [
+        key,
+        { ...font, files: font.files.map((file) => path2.resolve(config.outPath, file)) }
+      ]))
+    } : {}
+  };
+  releases.set(config, release);
+  return release;
+}
+var conventionBases = new Set([
+  "page",
+  "route",
+  "layout",
+  "template",
+  "loading",
+  "error",
+  "not-found",
+  "default",
+  "forbidden",
+  "unauthorized",
+  "global-error",
+  "global-not-found"
+]);
+var metadataBase = /^(?:robots|sitemap|manifest|favicon|(?:apple-)?icon\d*|opengraph-image\d*|twitter-image\d*)$/;
+var codeFile = /\.(?:[cm]?[jt]sx?|mdx?)$/;
+function capturedFile(name) {
+  const base = /^[^.]+/.exec(name)?.[0] ?? name;
+  return conventionBases.has(base) || metadataBase.test(base);
+}
+function servedAppFiles(facts) {
+  return [...facts.dirs].flatMap(([dir, listing]) => [...listing.files].map((name) => path2.join(dir, name)));
+}
+function captureConventions(root, appPath) {
+  const conventions = {};
+  const files = [];
+  const visit = (dir) => {
+    let entries2;
+    try {
+      entries2 = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const names = [];
+    for (const entry of entries2) {
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name.startsWith("."))
+          continue;
+        names.push(`${entry.name}/`);
+        visit(path2.join(dir, entry.name));
+      } else if (capturedFile(entry.name)) {
+        names.push(entry.name);
+        if (codeFile.test(entry.name))
+          files.push(path2.join(dir, entry.name));
+      }
+    }
+    conventions[toPosix(path2.relative(root, dir)) || "."] = names.sort();
+  };
+  visit(appPath);
+  return { conventions, files };
+}
+var frameworkRoot = path2.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/runtime", "..", "..");
+function releaseSourceKey(file, root, workspaceRoot) {
+  const inRoot = path2.relative(root, file);
+  if (!inRoot.startsWith("..") && !path2.isAbsolute(inRoot))
+    return `r:${toPosix(inRoot)}`;
+  const inWorkspace = path2.relative(workspaceRoot, file);
+  if (!inWorkspace.startsWith("..") && !path2.isAbsolute(inWorkspace))
+    return `w:${toPosix(inWorkspace)}`;
+  const inFramework = path2.relative(frameworkRoot, file);
+  if (!inFramework.startsWith("..") && !path2.isAbsolute(inFramework))
+    return `f:${toPosix(inFramework)}`;
+  return `r:${toPosix(inRoot)}`;
+}
+function releaseSourceFile(key, root, workspaceRoot, framework = frameworkRoot) {
+  const value = key.slice(2);
+  if (key.startsWith("r:"))
+    return path2.join(root, value);
+  if (key.startsWith("w:"))
+    return path2.resolve(workspaceRoot, value);
+  if (key.startsWith("f:"))
+    return path2.resolve(framework, value);
+  return path2.join(root, value);
+}
+function toPosix(file) {
+  return file.split(path2.sep).join("/");
+}
+function isInsideDir(root, file) {
+  return file === root || file.startsWith(`${root}${path2.sep}`);
+}
+function readBuildIndex(outPath) {
+  const file = buildIndexFile(outPath);
+  let index;
+  try {
+    index = JSON.parse(readFileSync2(file, "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    throw new Error("No production build found. Run 'pnext build' first.");
+  }
+  if (index.version !== BUILD_INDEX_VERSION) {
+    throw new Error(`pnext: ${file} is from another pnext version. Run 'pnext build' again.`);
+  }
+  return index;
+}
+function serializeReleaseConfig(config) {
+  const relative = (file) => path2.relative(config.root, file) || ".";
+  return JSON.parse(JSON.stringify({
+    ...config,
+    root: ".",
+    workspaceRoot: relative(config.workspaceRoot),
+    appPath: relative(config.appPath),
+    publicPath: relative(config.publicPath),
+    outPath: relative(config.outPath),
+    outRootPath: relative(config.outRootPath),
+    typesPath: relative(config.typesPath),
+    checksPath: relative(config.checksPath)
+  }, (_key, value) => value instanceof RegExp ? { $regexp: [value.source, value.flags] } : value));
+}
+function releaseConfig(serialized, root, outPath) {
+  const config = JSON.parse(JSON.stringify(serialized), (_key, value) => {
+    const pattern = value?.$regexp;
+    return pattern ? new RegExp(pattern[0], pattern[1]) : value;
+  });
+  const fromRoot = (file) => path2.resolve(root, file);
+  const fromOut = (file) => path2.resolve(outPath, path2.relative(config.outPath, file));
+  return {
+    ...config,
+    root,
+    workspaceRoot: fromRoot(config.workspaceRoot),
+    appPath: fromRoot(config.appPath),
+    publicPath: fromRoot(config.publicPath),
+    outPath,
+    outRootPath: fromOut(config.outRootPath),
+    typesPath: fromOut(config.typesPath),
+    checksPath: fromOut(config.checksPath)
+  };
+}
+async function writeBuildIndex(config, index) {
+  const file = buildIndexFile(config.outPath);
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile(temporary, JSON.stringify(index));
+  await rename(temporary, file);
+}
+
+export { PREBUNDLE_STAMP, readPrebundleStamp, prebundledFile, registerPrebundleResolve, BUILD_INDEX_VERSION, buildIndexFile, buildManifestFile, releaseFrameworkRoot, releaseSourceRoot, standaloneOriginsFile, servingReleaseDir, linkStandaloneOrigins, releaseModuleKey, productionRelease, servedRelease, servedConventions, frozenDirListing, conventionFileExists, releaseModuleHref, attachRelease, servedAppFiles, captureConventions, releaseSourceKey, releaseSourceFile, readBuildIndex, serializeReleaseConfig, releaseConfig, writeBuildIndex };