@uniweb/runtime 0.14.1 → 0.15.0

package/dist/ssr.js

@@ -1,8 +1,16 @@
-import { isRichSchema, deriveCacheKey as deriveCacheKey$1, resolveDefaultLocale as resolveDefaultLocale$1, hasDarkScheme, createUniweb, resolveRequestStyle, resolveServiceUrl, substitutePlaceholders as substitutePlaceholders$1, matchWhere } from "@uniweb/core";
+import { isRichSchema, deriveCacheKey, resolveDefaultLocale, hasDarkScheme, createUniweb, resolveServiceUrl, substitutePlaceholders, matchWhere, sortRecords, sortToWire } from "@uniweb/core";
 import React from "react";
 import { renderToString } from "react-dom/server";
 import { sectionDomId } from "@uniweb/core/section-id";
+import { routePatternToRegex, decodeRouteValue, splitPathCapture } from "@uniweb/core/route-match";
+import { DEFAULT_ICON_BASE, iconUrl } from "@uniweb/core/icon-corpus";
 import { buildTheme, FONT_LINKS_MARKER, buildSectionOverrides } from "@uniweb/theming";
+import "@uniweb/core/services";
+import "@uniweb/core/tracker";
+import { resolveFetchConfigs } from "@uniweb/core/fetch-config";
+import { deriveCacheKey as deriveCacheKey$1 } from "@uniweb/core/datastore";
+import { buildDetailConfig } from "@uniweb/core/detail-url";
+import { resolveDefaultLocale as resolveDefaultLocale$1 } from "@uniweb/core/locale-config";
 function guaranteeItemStructure(item) {
   return {
     title: item.title || "",
@@ -240,27 +248,6 @@ function getComponentMeta(componentName) {
 function getComponentDefaults(componentName) {
   return globalThis.uniweb?.getComponentDefaults?.(componentName) || {};
 }
-const PARAM_NAME = "[A-Za-z0-9_-]+";
-const REGEX_SPECIALS = /[.*+?^${}()|[\]\\]/g;
-function normalizeRoute(route) {
-  if (typeof route !== "string" || route === "") return "/";
-  return route === "/" ? "/" : route.replace(/\/+$/, "") || "/";
-}
-function routePatternToRegex(pattern) {
-  const paramNames = [];
-  const source = normalizeRoute(pattern).replace(REGEX_SPECIALS, "\\$&").replace(new RegExp(`:(${PARAM_NAME})`, "g"), (_, name) => {
-    paramNames.push(name);
-    return "([^/]+)";
-  });
-  return { regex: new RegExp(`^${source}$`), paramNames };
-}
-const DEFAULT_ICON_BASE = "https://uniweb.github.io/icons";
-function iconPath(family, name) {
-  return `${family}/${family}-${name}.svg`;
-}
-function iconUrl(family, name, base = DEFAULT_ICON_BASE) {
-  return `${String(base).replace(/\/+$/, "")}/${iconPath(family, name)}`;
-}
 function default404Html(basePath = "") {
   const homeHref = basePath ? `${basePath}/` : "/";
   return `<div class="page-not-found" style="min-height:80vh;display:flex;flex-direction:column;align-items:center;justify-content:center;padding:2rem;text-align:center"><h1 style="font-size:3rem;font-weight:bold;color:#1f2937;margin-bottom:1rem">404</h1><p style="color:#64748b;margin-bottom:2rem">Page not found</p><a href="${homeHref}" style="color:#3b82f6;text-decoration:underline">Go to homepage</a></div>`;
@@ -282,7 +269,7 @@ function wireFoundationCapabilities(uniweb, foundation) {
   }
 }
 function sliceContentForLocale(content, locale) {
-  const defaultLang = resolveDefaultLocale$1(content?.config);
+  const defaultLang = resolveDefaultLocale(content?.config);
   const locData = content?.locales?.[locale];
   if (!locale || locale === defaultLang || !locData) return content;
   return {
@@ -299,7 +286,7 @@ function hydrateDataStore(website, fetchedData) {
   if (!website?.dataStore || !fetchedData?.length) return;
   for (const entry of fetchedData) {
     if (entry.outcome && entry.outcome !== "fetched") continue;
-    website.dataStore.set(deriveCacheKey$1(entry.config), { data: entry.data });
+    website.dataStore.set(deriveCacheKey(entry.config), entry.meta ? { data: entry.data, meta: entry.meta } : { data: entry.data });
   }
 }
 function ensureThemeCss(uniweb, foundation) {
@@ -628,7 +615,7 @@ function renderLayout(page, website) {
 function initPrerenderForLocale(content, foundation, locale, extensionsOrOptions, maybeOptions) {
   const localeContent = sliceContentForLocale(content, locale);
   const uniweb = initPrerender(localeContent, foundation, extensionsOrOptions, maybeOptions);
-  const defaultLang = resolveDefaultLocale$1(content?.config);
+  const defaultLang = resolveDefaultLocale(content?.config);
   if (locale && locale !== defaultLang && uniweb.activeWebsite?.setActiveLocale) {
     uniweb.activeWebsite.setActiveLocale(locale);
   }
@@ -852,211 +839,40 @@ function generate404Html({ baseHtml, website, siteContent }) {
   }
   return { html, hasNotFoundPage: !!notFoundPage };
 }
-const DATA_DIR = "data";
-const DATA_URL_PREFIX = `/${DATA_DIR}/`;
-function queryDataUrl(name) {
-  return `${DATA_URL_PREFIX}${name}.json`;
-}
-function recordDataUrl(query, slug) {
-  return `${DATA_URL_PREFIX}${query}/${slug}.json`;
-}
-function isDataUrl(path) {
-  return typeof path === "string" && path.startsWith(DATA_URL_PREFIX);
-}
-const PLACEHOLDER_RE = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
-function substitutePlaceholders(value, context, options = {}) {
-  const { encode = true } = options;
-  if (typeof value === "string") {
-    return value.replace(PLACEHOLDER_RE, (literal, key) => {
-      if (!(key in (context || {}))) return literal;
-      const raw = context[key];
-      if (raw === void 0 || raw === null) return literal;
-      return encode ? encodeURIComponent(String(raw)) : String(raw);
-    });
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => substitutePlaceholders(item, context, options));
-  }
-  if (value && typeof value === "object") {
-    const result = {};
-    for (const key of Object.keys(value)) {
-      result[key] = substitutePlaceholders(value[key], context, options);
-    }
-    return result;
-  }
-  return value;
-}
-const PATH_SLOT = "{path}";
-const PARAM_SLOT = "{param}";
-const warnedPatterns = /* @__PURE__ */ new Set();
-function warnOnce(key, message) {
-  if (warnedPatterns.has(key)) return;
-  warnedPatterns.add(key);
-  console.warn(`[query-address] ${message}`);
-}
-function readPattern(lane, key) {
-  if (!lane || typeof lane !== "object" || Array.isArray(lane)) return null;
-  const pattern = lane[key];
-  return typeof pattern === "string" && pattern.length > 0 ? pattern : null;
-}
-function resolveQueryAddress(query, lane) {
-  if (typeof query !== "string" || query.length === 0) return null;
-  const pattern = readPattern(lane, "list");
-  if (!pattern) return null;
-  if (!pattern.includes(PATH_SLOT)) {
-    warnOnce(
-      `list:${pattern}`,
-      `config.records.list carries no ${PATH_SLOT} placeholder, so every query would resolve to the same address. Ignoring it and reading the compiled file instead.`
-    );
-    return null;
-  }
-  return substitutePlaceholders(pattern, { path: query });
-}
-function resolveRecordAddressPattern(query, lane) {
-  if (typeof query !== "string" || query.length === 0) return null;
-  const pattern = readPattern(lane, "record");
-  if (!pattern) return null;
-  if (!pattern.includes(PARAM_SLOT)) {
-    warnOnce(
-      `record:${pattern}`,
-      `config.records.record carries no ${PARAM_SLOT} placeholder, so every record would resolve to the same address. Ignoring it and reading the per-record file instead.`
-    );
-    return null;
-  }
-  return substitutePlaceholders(pattern, { path: query });
-}
-function localizeConfig(cfg, locale, defaultLocale) {
-  if (!cfg.path) return cfg;
-  if (!locale || locale === defaultLocale) return cfg;
-  if (!isDataUrl(cfg.path)) return cfg;
-  return { ...cfg, path: `/${locale}${cfg.path}` };
-}
-function applyDeferredDetail(cfg, queries, records) {
-  if (cfg.detail !== void 0) return cfg;
-  if (cfg.endpoint) {
-    const recordPattern = resolveRecordAddressPattern(cfg.query, records);
-    if (recordPattern) return { ...cfg, detail: recordPattern };
-  }
-  const queryName = cfg.query || bindingKey(cfg);
-  if (!queryName || !queries) return cfg;
-  const collConfig = queries[queryName];
-  if (!collConfig || typeof collConfig !== "object") return cfg;
-  const deferred = Array.isArray(collConfig.deferred) ? collConfig.deferred : null;
-  if (!deferred || deferred.length === 0) return cfg;
-  const pattern = typeof collConfig.detailUrl === "string" ? collConfig.detailUrl : recordDataUrl(queryName, "{slug}");
-  return { ...cfg, detail: pattern };
-}
-function resolveQuerySource(cfg, records) {
-  if (typeof cfg.query !== "string" || cfg.query.length === 0) return cfg;
-  const endpoint = resolveQueryAddress(cfg.query, records);
-  if (endpoint) {
-    const { path, url, ...rest } = cfg;
-    return { ...rest, endpoint };
-  }
-  return { ...cfg, path: queryDataUrl(cfg.query) };
-}
-function bindingKey(cfg) {
-  return cfg?.as;
-}
-function resolveFetchConfigs(sources, options = {}) {
-  const {
-    schemas = [],
-    locale = null,
-    defaultLocale = null,
-    queries = null,
-    records = null
-  } = options;
-  const configs = /* @__PURE__ */ new Map();
-  const collectAll = schemas.length === 0;
-  for (const source of sources) {
-    if (!source) continue;
-    const configList = Array.isArray(source) ? source : [source];
-    for (const cfg of configList) {
-      const key = bindingKey(cfg);
-      if (!key) continue;
-      if (configs.has(key)) continue;
-      if (!collectAll && !schemas.includes(key)) continue;
-      const sourced = resolveQuerySource(cfg, records);
-      const localized = localizeConfig(sourced, locale, defaultLocale);
-      configs.set(key, applyDeferredDetail(localized, queries, records));
-    }
-  }
-  return configs;
-}
-function deriveCacheKey(request) {
-  const { path, url, endpoint, transform } = request || {};
-  const as = request?.as;
-  const method = request?.method && request.method.toUpperCase() !== "GET" ? request.method.toUpperCase() : void 0;
-  const body = method === "POST" ? request?.body : void 0;
-  return JSON.stringify({ path, url, endpoint, as, transform, method, body });
-}
-function codeOf(entry) {
-  if (typeof entry === "string" && entry.trim() && entry.trim() !== "*") return entry.trim();
-  if (entry && typeof entry === "object" && typeof entry.code === "string" && entry.code.trim()) {
-    return entry.code.trim();
-  }
-  return null;
-}
-function normalizeLanguageList(value) {
-  if (!Array.isArray(value)) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const codes = [];
-  for (const entry of value) {
-    const code = codeOf(entry);
-    if (!code || seen.has(code)) continue;
-    seen.add(code);
-    codes.push(code);
-  }
-  return codes;
-}
-function resolveDefaultLocale(config = {}) {
-  if (typeof config?.defaultLanguage === "string" && config.defaultLanguage.trim()) {
-    return config.defaultLanguage.trim();
-  }
-  return normalizeLanguageList(config?.languages)[0] || "en";
-}
-const KNOWN_OPERATORS = /* @__PURE__ */ new Set(["where", "limit", "sort"]);
-function createDefaultFetcher({ basePath = "", config = {}, dev = false, records = null, fetch: fetchImpl = null } = {}) {
+function createDefaultFetcher({ basePath = "", dev = false, records = null, fetch: fetchImpl = null } = {}) {
   const doFetch = (input, init) => (fetchImpl || globalThis.fetch)(input, init);
   const pathPrefix = basePath && basePath !== "/" ? basePath.replace(/\/$/, "") : "";
-  const baseUrl = typeof config?.baseUrl === "string" ? config.baseUrl.replace(/\/$/, "") : "";
-  const staticHeaders = buildStaticHeaders(config?.headers);
-  const supports = normalizeSupports(config?.supports);
-  const requestConfig = config?.request && typeof config.request === "object" ? config.request : {};
-  const styleName = typeof requestConfig.style === "string" ? requestConfig.style : null;
-  const style = resolveRequestStyle(styleName, { dev });
-  const rename = normalizeRename(requestConfig.rename, style, { dev });
-  const siteEnvelope = config?.envelope && typeof config.envelope === "object" ? config.envelope : null;
-  const envelope = { ...style.defaultEnvelope || {}, ...siteEnvelope || {} };
   const stampedArrayKey = records?.envelope && typeof records.envelope === "object" && typeof records.envelope.records === "string" && records.envelope.records.length ? records.envelope.records : null;
   const laneEnvelope = stampedArrayKey ? { list: stampedArrayKey } : null;
+  const doorQueues = /* @__PURE__ */ new Map();
+  const askDoor = (request, ctx) => new Promise((resolve) => {
+    const url = resolveServiceUrl(request.door, pathPrefix);
+    let queue = doorQueues.get(url);
+    if (!queue) {
+      queue = [];
+      doorQueues.set(url, queue);
+      queueMicrotask(() => {
+        doorQueues.delete(url);
+        flushDoor(url, queue, doFetch);
+      });
+    }
+    queue.push({ request, ctx, resolve });
+  });
   return {
     /**
-     * Cache-key function. The default-fetcher's cache key includes only
-     * the operators it pushes down (because they affect what the source
-     * sees). Operators applied as runtime fallback operate on a shared
-     * cached value and therefore must NOT split the cache.
-     *
-     * Example: with `supports: []`, two pages declaring different
-     * `where:` clauses against the same path share one cache entry —
-     * the file is fetched once and each page filters its own copy. With
-     * `supports: [where]`, the same two pages fire two requests because
-     * the predicate travels in the request.
+     * The cache identity is the request's ADDRESS — or, on a question door,
+     * the QUESTION (`deriveCacheKey` hashes every operator of an address-less
+     * request). Operators evaluated here run over a shared cached value and
+     * must NOT split the cache: two pages declaring different `where:` clauses
+     * against the same path share one entry — the file is fetched once and
+     * each page filters its own copy.
      */
     cacheKey(request) {
-      const base = deriveCacheKey$1(request);
-      const projected = {};
-      for (const op of supports) {
-        if (!style.canPush.has(op)) continue;
-        if (request[op] !== void 0) projected[op] = request[op];
-      }
-      if (Object.keys(projected).length === 0 && style.name === "json-body") {
-        return base;
-      }
-      return base + "::style=" + style.name + "::" + JSON.stringify(projected);
+      return deriveCacheKey(request);
     },
     async resolve(request, ctx = {}) {
       if (!request) return { data: null };
+      if (request.door) return askDoor(request, ctx);
       const { path, url, endpoint, transform, body: rawBody } = request;
       let method = (request.method || "GET").toUpperCase();
       if (method !== "GET" && method !== "POST") {
@@ -1064,59 +880,39 @@ function createDefaultFetcher({ basePath = "", config = {}, dev = false, records
         method = "GET";
       }
       let target;
-      let isRemote;
       if (endpoint) {
         target = resolveServiceUrl(endpoint, pathPrefix);
-        isRemote = true;
+        if (typeof request.locale === "string" && request.locale) {
+          target += (target.includes("?") ? "&" : "?") + "locale=" + encodeURIComponent(request.locale);
+        }
       } else if (path) {
         target = pathPrefix && path.startsWith("/") && !path.startsWith("//") ? pathPrefix + path : path;
-        isRemote = false;
       } else if (url) {
-        target = isAbsoluteUrl(url) ? url : joinUrl(baseUrl, url);
-        isRemote = true;
+        target = url;
       } else {
         return { data: [], error: "No path, url or endpoint specified" };
       }
       const init = { signal: ctx.signal, method };
-      const headers = {};
-      if (isRemote && staticHeaders) Object.assign(headers, staticHeaders);
-      const pushCandidates = /* @__PURE__ */ new Set();
-      if (isRemote) {
-        for (const op of KNOWN_OPERATORS) {
-          if (supports.has(op) && style.canPush.has(op) && request[op] !== void 0 && request[op] !== null) {
-            pushCandidates.add(op);
-          }
-        }
-      }
-      const encoded = pushCandidates.size > 0 ? style.encode(request, { method, pushCandidates, rename }) : { queryParams: [], bodyMerge: null, pushed: /* @__PURE__ */ new Set() };
-      const pushedOperators = encoded.pushed;
-      if (encoded.queryParams.length > 0 && method === "GET") {
-        target = appendStyleQueryParams(target, encoded.queryParams);
-      }
       if (method === "POST") {
         const dc = request.dynamicContext;
-        const resolvedBody = rawBody !== void 0 && rawBody !== null && dc && dc.paramName ? substitutePlaceholders$1(rawBody, { [dc.paramName]: dc.paramValue }, { encode: false }) : rawBody;
-        const finalBody = composePostBody(resolvedBody, encoded.bodyMerge);
-        if (finalBody !== null) {
-          if (!hasHeader(headers, "Content-Type")) {
-            headers["Content-Type"] = "application/json";
-          }
-          init.body = typeof finalBody === "string" ? finalBody : JSON.stringify(finalBody);
+        const body = rawBody !== void 0 && rawBody !== null && dc && dc.paramName ? substitutePlaceholders(rawBody, { [dc.paramName]: dc.paramValue }, { encode: false }) : rawBody;
+        if (body !== void 0 && body !== null) {
+          init.headers = { "Content-Type": "application/json" };
+          init.body = typeof body === "string" ? body : JSON.stringify(body);
         }
       }
-      if (Object.keys(headers).length) init.headers = headers;
       try {
         const response = await doFetch(target, init);
         const requestEnvelope = request.envelope && typeof request.envelope === "object" ? request.envelope : null;
-        const effectiveEnvelope = requestEnvelope ?? (endpoint && laneEnvelope ? { ...envelope, ...laneEnvelope } : envelope);
+        const envelope = requestEnvelope ?? (endpoint && laneEnvelope ? laneEnvelope : {});
         if (!response.ok) {
           let extracted;
-          if (effectiveEnvelope.error) {
+          if (envelope.error) {
             try {
               const text = await response.text();
               const body = safeParseJSON(text);
               if (body !== void 0) {
-                const candidate = getNestedValue(body, effectiveEnvelope.error);
+                const candidate = getNestedValue(body, envelope.error);
                 if (typeof candidate === "string" && candidate.length) {
                   extracted = candidate;
                 }
@@ -1142,12 +938,13 @@ function createDefaultFetcher({ basePath = "", config = {}, dev = false, records
           }
         }
         const isDetailRequest = !!request.dynamicContext;
-        const effectiveTransform = transform || (isDetailRequest ? effectiveEnvelope.item : effectiveEnvelope.list);
+        const effectiveTransform = transform || (isDetailRequest ? envelope.item : envelope.list);
         if (effectiveTransform && data !== null && data !== void 0) {
           data = getNestedValue(data, effectiveTransform);
         }
-        data = applyFallbackOperators(data, request, pushedOperators);
-        return { data: data ?? [] };
+        data = applyOperators(data, request, { dev });
+        const depth = request.depth === "brief" || request.depth === "full" ? request.depth : void 0;
+        return depth ? { data: data ?? [], meta: { depth } } : { data: data ?? [] };
       } catch (error) {
         if (error?.name === "AbortError") {
           return { data: [], error: "aborted" };
@@ -1157,105 +954,100 @@ function createDefaultFetcher({ basePath = "", config = {}, dev = false, records
     }
   };
 }
-function normalizeRename(raw, style, { dev }) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+function doorQuestion(request) {
+  const q = { schema: request.schema };
+  let where = request.where && typeof request.where === "object" ? request.where : null;
+  let scope = typeof request.scope === "string" && request.scope ? request.scope : null;
+  if (where && !scope && where.path && typeof where.path === "object" && typeof where.path.under === "string" && where.path.under) {
+    const { path, ...rest } = where;
+    scope = path.under;
+    where = Object.keys(rest).length ? rest : null;
+  }
+  if (scope) q.scope = scope;
+  if (where) q.where = renameOperators(where);
+  const sort = sortToWire(request.sort);
+  if (sort) q.sort = sort;
+  if (typeof request.limit === "number" && request.limit > 0) q.limit = request.limit;
+  if (request.depth === "brief" || request.depth === "full") q.depth = request.depth;
+  return q;
+}
+const DOOR_OPERATOR = { nin: "not_in" };
+function renameOperators(where) {
+  if (Array.isArray(where)) return where.map(renameOperators);
+  if (!where || typeof where !== "object") return where;
   const out = {};
-  for (const [op, wireName] of Object.entries(raw)) {
-    if (typeof wireName !== "string" || wireName.length === 0) continue;
-    if (dev && !style.canPush.has(op) && !warnedRenameTargets.has(op)) {
-      warnedRenameTargets.add(op);
-      console.warn(
-        `[default-fetcher] request.rename: operator "${op}" is not pushed by style "${style.name}" — rename has no effect. Known operators for this style: ${[...style.canPush].join(", ") || "(none)"}.`
-      );
-    }
-    out[op] = wireName;
-  }
-  return Object.keys(out).length ? out : null;
-}
-const warnedRenameTargets = /* @__PURE__ */ new Set();
-function normalizeSupports(raw) {
-  const out = /* @__PURE__ */ new Set();
-  if (!Array.isArray(raw)) return out;
-  for (const op of raw) {
-    if (typeof op !== "string") continue;
-    if (KNOWN_OPERATORS.has(op)) out.add(op);
-    else if (!warnedUnknownOperators.has(op)) {
-      warnedUnknownOperators.add(op);
-      console.warn(`[default-fetcher] supports: unknown operator "${op}" — ignored.`);
-    }
+  for (const [key, value] of Object.entries(where)) {
+    out[DOOR_OPERATOR[key] ?? key] = value && typeof value === "object" ? renameOperators(value) : value;
   }
   return out;
 }
-const warnedUnknownOperators = /* @__PURE__ */ new Set();
-function appendStyleQueryParams(url, pairs) {
-  if (!pairs || pairs.length === 0) return url;
-  const params = pairs.map(
-    ([k, v]) => encodeURIComponent(k) + "=" + encodeURIComponent(v)
-  );
-  const sep = url.includes("?") ? "&" : "?";
-  return url + sep + params.join("&");
-}
-function composePostBody(authorBody, bodyMerge) {
-  if (!bodyMerge) {
-    return authorBody === void 0 ? null : authorBody;
-  }
-  if (typeof authorBody === "string") {
-    return authorBody;
-  }
-  const base = authorBody && typeof authorBody === "object" ? authorBody : {};
-  return { ...base, ...bodyMerge };
+async function flushDoor(url, queue, doFetch) {
+  const body = {};
+  const keys = [];
+  for (const entry of queue) {
+    const base = entry.request.as || "q";
+    let key = base;
+    for (let n = 2; key in body; n += 1) key = `${base}#${n}`;
+    keys.push(key);
+    body[key] = doorQuestion(entry.request);
+  }
+  let parsed;
+  try {
+    const response = await doFetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error = `HTTP ${response.status}: ${response.statusText}`;
+      for (const entry of queue) entry.resolve({ data: null, error });
+      return;
+    }
+    parsed = await response.json();
+  } catch (error) {
+    const message = error?.name === "AbortError" ? "aborted" : error?.message || String(error);
+    for (const entry of queue) entry.resolve({ data: null, error: message });
+    return;
+  }
+  const data = parsed && typeof parsed.data === "object" && parsed.data ? parsed.data : {};
+  const errors = parsed && typeof parsed.errors === "object" && parsed.errors ? parsed.errors : {};
+  const depths = parsed && typeof parsed.depths === "object" && parsed.depths ? parsed.depths : {};
+  queue.forEach((entry, i) => {
+    const key = keys[i];
+    if (key in errors) {
+      const e = errors[key];
+      entry.resolve({ data: null, error: typeof e === "string" ? e : e?.message || JSON.stringify(e) });
+      return;
+    }
+    if (!(key in data)) {
+      entry.resolve({ data: null, error: `the records door answered without the key "${key}"` });
+      return;
+    }
+    const depth = depths[key] === "brief" || depths[key] === "full" ? depths[key] : entry.request.depth === "brief" || entry.request.depth === "full" ? entry.request.depth : void 0;
+    entry.resolve(depth ? { data: data[key], meta: { depth } } : { data: data[key] });
+  });
 }
-function applyFallbackOperators(data, request, pushedOperators) {
+function applyOperators(data, request, { dev = false } = {}) {
   if (!Array.isArray(data)) return data;
   let result = data;
-  if (request.where && !pushedOperators.has("where")) {
-    result = matchWhere(request.where, result);
-  }
-  if (request.sort && !pushedOperators.has("sort")) {
-    result = applySortFallback(result, request.sort);
-  }
-  if (typeof request.limit === "number" && request.limit > 0 && !pushedOperators.has("limit")) {
-    result = result.slice(0, request.limit);
-  }
+  if (request.where) result = matchWhere(request.where, result);
+  if (request.sort) result = applySort(result, request.sort, dev);
+  if (typeof request.limit === "number" && request.limit > 0) result = result.slice(0, request.limit);
   return result;
 }
-function applySortFallback(items, sortExpr) {
-  const sorts = String(sortExpr).split(",").map((s) => {
-    const [field, dir = "asc"] = s.trim().split(/\s+/);
-    return { field, desc: dir.toLowerCase() === "desc" };
-  });
-  return [...items].sort((a, b) => {
-    for (const { field, desc } of sorts) {
-      const av = getNestedValue(a, field) ?? "";
-      const bv = getNestedValue(b, field) ?? "";
-      if (av < bv) return desc ? 1 : -1;
-      if (av > bv) return desc ? -1 : 1;
+const warnedBadSorts = /* @__PURE__ */ new Set();
+function applySort(items, sortExpr, dev) {
+  try {
+    return sortRecords(items, sortExpr);
+  } catch (err) {
+    if (dev) throw err;
+    const key = String(sortExpr);
+    if (!warnedBadSorts.has(key)) {
+      warnedBadSorts.add(key);
+      console.error(`[default-fetcher] ${err.message} Records delivered unsorted.`);
     }
-    return 0;
-  });
-}
-function buildStaticHeaders(headers) {
-  if (!headers || typeof headers !== "object" || Array.isArray(headers)) return null;
-  const out = {};
-  for (const [k, v] of Object.entries(headers)) {
-    if (v === null || v === void 0) continue;
-    out[k] = String(v);
+    return items;
   }
-  return Object.keys(out).length ? out : null;
-}
-function hasHeader(headers, name) {
-  const lower = name.toLowerCase();
-  return Object.keys(headers).some((k) => k.toLowerCase() === lower);
-}
-function isAbsoluteUrl(url) {
-  if (typeof url !== "string") return false;
-  if (url.startsWith("//")) return true;
-  return /^[a-z][a-z0-9+.-]*:\/\//i.test(url);
-}
-function joinUrl(baseUrl, url) {
-  if (!baseUrl) return url;
-  if (url.startsWith("/")) return baseUrl + url;
-  return baseUrl + "/" + url;
 }
 function getNestedValue(obj, path) {
   if (!obj || !path) return obj;
@@ -1282,25 +1074,44 @@ function findPageForRoute(content, route) {
     if (!page.isDynamic || !page.route) continue;
     const compiled = routePatternToRegex(page.route);
     const m = compiled?.regex ? compiled.regex.exec(route) : null;
-    if (m) return { page, params: Object.fromEntries((compiled.paramNames || []).map((n, i) => [n, m[i + 1]])) };
+    if (m) {
+      const params = {};
+      (compiled.paramNames || []).forEach((n, i) => {
+        const raw = m[i + 1];
+        params[n] = n === compiled.catchAll ? raw.split("/").map(decodeRouteValue).join("/") : decodeRouteValue(raw);
+      });
+      return { page, params };
+    }
   }
   return { page: null, params: {} };
 }
+function routeBinding(page, params) {
+  const { catchAll } = routePatternToRegex(page.route);
+  if (catchAll && params[catchAll] !== void 0) {
+    const parts = splitPathCapture(params[catchAll]);
+    const paramName2 = page.paramName || "slug";
+    return { paramName: paramName2, paramValue: parts.slug, variables: { ...params, ...parts } };
+  }
+  const paramName = page.paramName || Object.keys(params)[0];
+  return { paramName, paramValue: params[paramName], variables: { ...params } };
+}
 function resolvePageFetchConfigs(content, route, { locale = null } = {}) {
-  const { page } = findPageForRoute(content, route);
+  const { page, params } = findPageForRoute(content, route);
   if (!page) return [];
   const pages = content?.pages || [];
   const parent = page.parent ? pages.find((p) => p.route === page.parent) : null;
+  const binding = page.isDynamic && Object.keys(params).length ? routeBinding(page, params) : null;
   const options = {
     locale,
-    defaultLocale: resolveDefaultLocale(content?.config) ?? null,
+    defaultLocale: resolveDefaultLocale$1(content?.config) ?? null,
     queries: content?.config?.queries ?? null,
-    records: content?.config?.records ?? null
+    records: content?.config?.records ?? null,
+    variables: binding?.variables ?? null
   };
   const out = /* @__PURE__ */ new Map();
   const add = (sources) => {
     for (const cfg of resolveFetchConfigs(sources, options).values()) {
-      const key = deriveCacheKey(cfg);
+      const key = deriveCacheKey$1(cfg);
       if (!out.has(key)) out.set(key, cfg);
     }
   };
@@ -1312,6 +1123,14 @@ function resolvePageFetchConfigs(content, route, { locale = null } = {}) {
     }
   };
   walk(page.sections);
+  if (binding && binding.paramValue !== void 0 && page.parentSchema) {
+    const listCfg = [...out.values()].find((cfg) => cfg.as === page.parentSchema && cfg.detail);
+    const detailCfg = listCfg ? buildDetailConfig(listCfg, { paramName: binding.paramName, paramValue: String(binding.paramValue) }) : null;
+    if (detailCfg) {
+      const key = deriveCacheKey$1(detailCfg);
+      if (!out.has(key)) out.set(key, detailCfg);
+    }
+  }
   return [...out.values()];
 }
 async function executeFetchConfigs(configs, { content, fetch: fetch2 = null, dev = false, prerender = "always" } = {}) {
@@ -1320,33 +1139,63 @@ async function executeFetchConfigs(configs, { content, fetch: fetch2 = null, dev
   }
   const fetcher = createDefaultFetcher({
     basePath: content?.config?.base || "",
-    config: content?.config?.fetcher ?? {},
     records: content?.config?.records ?? null,
     dev,
     fetch: fetch2
   });
   const ctx = { website: null };
-  const out = [];
-  for (const config of configs || []) {
-    if (!config) continue;
+  return Promise.all((configs || []).filter(Boolean).map(async (config) => {
     if (prerender === "author" && config.prerender === false) {
-      out.push({ config, outcome: "skipped", data: null });
-      continue;
+      return { config, outcome: "skipped", data: null };
     }
     const result = await fetcher.resolve(config, ctx);
-    if (result?.error) out.push({ config, outcome: "failed", data: null, error: result.error });
-    else out.push({ config, outcome: "fetched", data: result?.data ?? null });
-  }
-  return out;
+    if (result?.error) return { config, outcome: "failed", data: null, error: result.error };
+    return { config, outcome: "fetched", data: result?.data ?? null, ...result?.meta ? { meta: result.meta } : {} };
+  }));
 }
 async function prefetchPageData({ content, route, locale = null, fetch: fetch2 = null, dev = false, prerender = "always" }) {
   const configs = resolvePageFetchConfigs(content, route, { locale });
   return executeFetchConfigs(configs, { content, fetch: fetch2, dev, prerender });
 }
+function createPageRenderer({ website, shell }) {
+  if (!website) throw new Error("createPageRenderer: `website` is required");
+  if (typeof shell !== "string") throw new Error("createPageRenderer: `shell` must be an HTML string");
+  function render(target, { inject = {} } = {}) {
+    const page = typeof target === "string" ? resolvePage(website, target) : target;
+    if (!page) return { outcome: "notFound", html: null, page: null, error: null };
+    let result;
+    try {
+      result = renderPage(page, website);
+    } catch (err) {
+      return { outcome: "failed", html: null, page, error: classifyRenderError(err) };
+    }
+    if (result.error) return { outcome: "failed", html: null, page, error: result.error };
+    const html = injectPageContent(shell, result.renderedContent, page, {
+      ...inject,
+      sectionOverrideCSS: result.sectionOverrideCSS
+    });
+    return { outcome: "rendered", html, page, error: null };
+  }
+  return { website, render };
+}
+async function prefetchAndHydrate({ website, content, route, locale = null, fetch: fetch2 = null, dev = false, prerender = "always" }) {
+  if (!website?.dataStore) {
+    throw new Error("prefetchAndHydrate: `website` must be an initialized Website with a dataStore");
+  }
+  if (typeof fetch2 !== "function") {
+    throw new Error(
+      "prefetchAndHydrate: `fetch` must be a function. A transport does not survive a JSON-serialized isolate boundary — pass it as an RPC method argument. To use the ambient fetch deliberately, pass `fetch: globalThis.fetch`."
+    );
+  }
+  const fetched = await prefetchPageData({ content, route, locale, fetch: fetch2, dev, prerender });
+  hydrateDataStore(website, fetched);
+  return fetched;
+}
 export {
   applyDefaults,
   applySchemas,
   classifyRenderError,
+  createPageRenderer,
   escapeHtml,
   executeFetchConfigs,
   findPageForRoute,
@@ -1359,6 +1208,7 @@ export {
   initPrerender,
   initPrerenderForLocale,
   injectPageContent,
+  prefetchAndHydrate,
   prefetchIcons,
   prefetchPageData,
   prepareProps,