@weaverse/next 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/server.js

@@ -1,5 +1,72 @@
 'use strict';
 
+var schema = require('@weaverse/schema');
+
+// src/seo.ts
+function hasOpenGraphContent(seo) {
+  return Boolean(seo?.title || seo?.description || seo?.image || seo?.type);
+}
+function hasTwitterContent(seo) {
+  return Boolean(seo?.title || seo?.description || seo?.image || seo?.cardType);
+}
+function normalizeTwitterCard(cardType) {
+  return cardType === "summary_large_image" ? "summary_large_image" : "summary";
+}
+function normalizeOpenGraphType(type) {
+  if (type === "article" || type === "profile" || type === "video.other") {
+    return type;
+  }
+  return "website";
+}
+function formatWeaverseNextSeoMetadata(seo) {
+  let index = seo?.robots?.index !== false;
+  let follow = seo?.robots?.follow !== false;
+  let metadata = {
+    robots: { index, follow }
+  };
+  if (!seo) {
+    return metadata;
+  }
+  if (seo.title) {
+    metadata.title = seo.title;
+  }
+  if (seo.description) {
+    metadata.description = seo.description;
+  }
+  if (seo.keywords) {
+    metadata.keywords = seo.keywords;
+  }
+  if (seo.canonicalUrl) {
+    metadata.alternates = { canonical: seo.canonicalUrl };
+  }
+  let openGraph = seo.openGraph;
+  if (hasOpenGraphContent(openGraph)) {
+    metadata.openGraph = {
+      title: openGraph?.title,
+      description: openGraph?.description,
+      images: openGraph?.image ? [openGraph.image] : void 0,
+      type: normalizeOpenGraphType(openGraph?.type)
+    };
+  }
+  let twitter = seo.twitter;
+  if (hasTwitterContent(twitter)) {
+    metadata.twitter = {
+      card: normalizeTwitterCard(twitter?.cardType),
+      title: twitter?.title,
+      description: twitter?.description,
+      images: twitter?.image ? [twitter.image] : void 0
+    };
+  }
+  return metadata;
+}
+function getWeaverseNextSeoMetadata(data) {
+  if (!data) {
+    return formatWeaverseNextSeoMetadata(null);
+  }
+  let page = "items" in data && "id" in data ? data : data.page ?? null;
+  return formatWeaverseNextSeoMetadata(page?.seo ?? null);
+}
+
 // src/server/configs.ts
 var DEFAULT_WEAVERSE_HOST = "https://studio.weaverse.io";
 var DEFAULT_WEAVERSE_API_BASE = "https://api.weaverse.io";
@@ -71,7 +138,6 @@ function getWeaverseNextConfigs(context, options = {}) {
     envProjectId: readEnv(env, "WEAVERSE_PROJECT_ID") || "",
     weaverseHost,
     weaverseApiBase,
-    weaverseApiKey: lastParam(searchParams, "weaverseApiKey") || readEnv(env, "WEAVERSE_API_KEY") || "",
     weaverseVersion: lastParam(searchParams, "weaverseVersion") || options.weaverseVersion || "",
     isDesignMode,
     isPreviewMode,
@@ -84,8 +150,84 @@ function getWeaverseNextConfigs(context, options = {}) {
   };
 }
 
+// src/request-info.ts
+function toUrl2(value) {
+  return typeof value === "string" ? new URL(value, "http://localhost") : value;
+}
+function getSearchParamsFromContext(context) {
+  if (context?.searchParams) {
+    return new URLSearchParams(context.searchParams);
+  }
+  if (context?.url) {
+    let url = toUrl2(context.url);
+    return new URLSearchParams(url.searchParams);
+  }
+  return new URLSearchParams();
+}
+function withPathPrefix(pathname, i18n) {
+  let raw = typeof i18n?.pathPrefix === "string" ? i18n.pathPrefix : "";
+  let segments = raw.split("/").filter(Boolean);
+  let prefix = segments.length > 0 ? `/${segments.join("/")}` : "";
+  if (prefix === "" || pathname === prefix || pathname.startsWith(`${prefix}/`)) {
+    return pathname;
+  }
+  return pathname === "/" ? prefix : `${prefix}${pathname}`;
+}
+function getPathnameFromContext(context) {
+  if (context?.pathname) {
+    return withPathPrefix(context.pathname, context.i18n);
+  }
+  if (context?.url) {
+    let url = toUrl2(context.url);
+    return withPathPrefix(url.pathname || "/", context.i18n);
+  }
+  return "/";
+}
+function coerceQueryValue(value) {
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  return value;
+}
+function toQueryRecord(searchParams) {
+  let queries = {};
+  for (let [key, value] of searchParams.entries()) {
+    queries[key] = coerceQueryValue(value);
+  }
+  return queries;
+}
+var TRANSIENT_STUDIO_PARAMS = /* @__PURE__ */ new Set([
+  "weaverseDraftItem",
+  // Legacy name from the original design-mode draft-item spike. Keep it out of
+  // runtime requestInfo too, in case an older Builder bundle is in front of a
+  // newer Next storefront.
+  "__weaverseDraftItem"
+]);
+function getRequestInfoSearchParams(context) {
+  let searchParams = new URLSearchParams(getSearchParamsFromContext(context));
+  for (let key of TRANSIENT_STUDIO_PARAMS) {
+    searchParams.delete(key);
+  }
+  return searchParams;
+}
+function buildWeaverseNextRequestInfo(context) {
+  let searchParams = getRequestInfoSearchParams(context);
+  let search = searchParams.toString();
+  return {
+    pathname: getPathnameFromContext(context),
+    search: search ? `?${search}` : "",
+    queries: toQueryRecord(searchParams),
+    ...context?.i18n ? { i18n: context.i18n } : {},
+    ...context?.pageType ? { pageType: context.pageType } : {},
+    ...context?.handle ? { handle: context.handle } : {}
+  };
+}
+
 // src/server/normalize-page-url.ts
-var KEPT_PARAM_RE = /^(?:__revisionId|isDesignMode|weaverse)/;
+var KEPT_PARAM_RE = /^(?:__revisionId|__weaverseDraftItem|isDesignMode|weaverse)/;
 var DATA_SUFFIX = ".data";
 function normalizeNextPageUrl(url) {
   let parsed;
@@ -109,12 +251,49 @@ function normalizeNextPageUrl(url) {
 }
 function resolveRequestUrl(context) {
   if (context?.url) {
-    return typeof context.url === "string" ? context.url : context.url.toString();
+    let raw = String(context.url);
+    let url = new URL(raw, "http://localhost");
+    let pathname2 = withPathPrefix(url.pathname, context.i18n);
+    if (pathname2 === url.pathname) {
+      return raw;
+    }
+    url.pathname = pathname2;
+    return url.toString();
   }
-  let pathname = context?.pathname || "/";
+  let pathname = withPathPrefix(context?.pathname || "/", context?.i18n);
   let search = context?.searchParams ? new URLSearchParams(context.searchParams).toString() : "";
   return `http://localhost${pathname}${search ? `?${search}` : ""}`;
 }
+var DENIED_ROUTE_CONTEXT_PARAMS = [
+  "weaverseprojectid",
+  "weaversehost",
+  "weaverseapikey",
+  "weaverseapibase",
+  "weaversepublicapibase",
+  "weaverseversion",
+  "projectid",
+  "weaversedraftitem",
+  "__weaversedraftitem",
+  "_rsc"
+];
+var ROUTE_CONTEXT_I18N_KEYS = [
+  "country",
+  "label",
+  "language",
+  "locale",
+  "pathPrefix"
+];
+function sanitizeRouteContextSearch(search) {
+  let params = new URLSearchParams(search);
+  let denied = new Set(DENIED_ROUTE_CONTEXT_PARAMS);
+  for (let key of [...new Set(params.keys())]) {
+    if (denied.has(key.toLowerCase())) {
+      params.delete(key);
+    }
+  }
+  let serialized = params.toString();
+  return serialized ? `?${serialized}` : "";
+}
 
 // src/utils.ts
 function generateDataFromSchema(schema) {
@@ -134,6 +313,211 @@ function generateDataFromSchema(schema) {
   return data;
 }
 
+// src/server/revalidate-handler.ts
+var NO_STORE_HEADERS = {
+  "Content-Type": "application/json",
+  "Cache-Control": "no-store"
+};
+var STATUS_OK = 200;
+var STATUS_BAD_REQUEST = 400;
+var STATUS_NOT_FOUND = 404;
+var STATUS_UNPROCESSABLE = 422;
+var STATUS_SERVER_ERROR = 500;
+var MAX_PATHNAME_LENGTH = 2048;
+var MAX_SEARCH_LENGTH = 8192;
+var MAX_HANDLE_LENGTH = 512;
+var MAX_I18N_FIELD_LENGTH = 256;
+var CONTROL_CHAR_PATTERN = /[\u0000-\u001F\u007F]/;
+function isValidPathname(pathname) {
+  if (!pathname || pathname.length > MAX_PATHNAME_LENGTH) {
+    return false;
+  }
+  if (pathname[0] !== "/" || pathname.startsWith("//")) {
+    return false;
+  }
+  if (pathname.includes("\\") || pathname.includes("?")) {
+    return false;
+  }
+  if (pathname.includes("#") || CONTROL_CHAR_PATTERN.test(pathname)) {
+    return false;
+  }
+  return true;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  let proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function sanitizeRouteContextI18n(input) {
+  if (input === void 0) {
+    return;
+  }
+  if (!isPlainObject(input)) {
+    return null;
+  }
+  let source = input;
+  let allowed = new Set(ROUTE_CONTEXT_I18N_KEYS);
+  for (let key of Object.keys(source)) {
+    if (!allowed.has(key)) {
+      return null;
+    }
+  }
+  let result = {};
+  for (let key of ROUTE_CONTEXT_I18N_KEYS) {
+    let value = source[key];
+    if (value === void 0) {
+      continue;
+    }
+    if (typeof value !== "string" || value.length > MAX_I18N_FIELD_LENGTH) {
+      return null;
+    }
+    result[key] = value;
+  }
+  return Object.keys(result).length ? result : void 0;
+}
+function reconstructRouteContext(request, routeContext) {
+  if (typeof routeContext !== "object" || routeContext === null || Array.isArray(routeContext)) {
+    return null;
+  }
+  let { pathname, search, handle, pageType, i18n } = routeContext;
+  if (typeof pathname !== "string" || !isValidPathname(pathname)) {
+    return null;
+  }
+  if (typeof search !== "string" || search.length > MAX_SEARCH_LENGTH) {
+    return null;
+  }
+  let rawSearch = search;
+  if (rawSearch.length && !rawSearch.startsWith("?")) {
+    return null;
+  }
+  let sanitizedI18n = sanitizeRouteContextI18n(i18n);
+  if (sanitizedI18n === null) {
+    return null;
+  }
+  let resolvedPageType;
+  if (pageType !== void 0) {
+    let parsed = schema.PageTypeSchema.safeParse(pageType);
+    if (!parsed.success) {
+      return null;
+    }
+    resolvedPageType = parsed.data;
+  }
+  let resolvedHandle;
+  if (handle !== void 0) {
+    if (typeof handle !== "string" || !handle || handle.length > MAX_HANDLE_LENGTH) {
+      return null;
+    }
+    resolvedHandle = handle;
+  }
+  let endpointUrl = new URL(request.url);
+  let routeUrl = new URL(endpointUrl.origin);
+  routeUrl.pathname = pathname;
+  routeUrl.search = sanitizeRouteContextSearch(rawSearch);
+  let canonicalPathname = routeUrl.pathname;
+  let searchParams = routeUrl.searchParams;
+  let lastParam2 = (key) => {
+    let values = searchParams.getAll(key);
+    return values.length ? values.at(-1) : void 0;
+  };
+  return {
+    pathname: canonicalPathname,
+    searchParams,
+    url: routeUrl,
+    // Headers come from the actual same-origin POST, never its JSON body.
+    headers: new Headers(request.headers),
+    ...sanitizedI18n ? { i18n: sanitizedI18n } : {},
+    ...resolvedPageType ? { pageType: resolvedPageType } : {},
+    ...resolvedHandle ? { handle: resolvedHandle } : {},
+    isDesignMode: lastParam2("isDesignMode") === "true",
+    isPreviewMode: lastParam2("isPreviewMode") === "true",
+    isRevisionPreview: searchParams.has("__revisionId"),
+    sectionType: lastParam2("sectionType") || void 0
+  };
+}
+function json(body, status) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: NO_STORE_HEADERS
+  });
+}
+function parseDraftItem(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return null;
+  }
+  let draftItem = payload.draftItem;
+  if (typeof draftItem !== "object" || draftItem === null) {
+    return null;
+  }
+  let { id, type } = draftItem;
+  if (typeof id !== "string" || !id || typeof type !== "string" || !type) {
+    return null;
+  }
+  return draftItem;
+}
+function createWeaverseNextRevalidateHandler(config) {
+  return {
+    POST: async (request) => {
+      let payload;
+      try {
+        payload = await request.json();
+      } catch {
+        return json({ error: "invalid-payload" }, STATUS_BAD_REQUEST);
+      }
+      let draftItem = parseDraftItem(payload);
+      if (!draftItem) {
+        return json({ error: "invalid-payload" }, STATUS_BAD_REQUEST);
+      }
+      let requestContext;
+      let body = payload;
+      if (Object.hasOwn(body, "routeContext")) {
+        let reconstructed = reconstructRouteContext(request, body.routeContext);
+        if (!reconstructed) {
+          return json({ error: "invalid-route-context" }, STATUS_BAD_REQUEST);
+        }
+        requestContext = reconstructed;
+      }
+      let client;
+      try {
+        client = await config.getClient(request, requestContext);
+      } catch (error) {
+        console.error("\u274C Revalidate handler getClient failed.", error);
+        return json({ error: "client-init-failed" }, STATUS_SERVER_ERROR);
+      }
+      let component = client.components.find(
+        (candidate) => candidate?.schema?.type === draftItem.type
+      );
+      if (!component) {
+        return json({ error: "unknown-component-type" }, STATUS_NOT_FOUND);
+      }
+      if (typeof component.loader !== "function") {
+        return json({ error: "missing-loader" }, STATUS_UNPROCESSABLE);
+      }
+      try {
+        let loaderData = await component.loader({
+          data: {
+            ...generateDataFromSchema(component.schema),
+            ...draftItem.data
+          },
+          weaverse: client,
+          context: client.requestContext,
+          commerce: client.commerce
+        });
+        return json({ loaderData: loaderData ?? null }, STATUS_OK);
+      } catch (error) {
+        console.error(
+          "\u274C Item loader revalidation failed.",
+          draftItem.type,
+          draftItem.id,
+          error
+        );
+        return json({ error: "loader-failed" }, STATUS_SERVER_ERROR);
+      }
+    }
+  };
+}
+
 // src/loader.ts
 function isItemNode(node) {
   return typeof node === "object" && node !== null && typeof node.type === "string";
@@ -211,61 +595,11 @@ async function runWeaverseComponentLoaders(args) {
   return data;
 }
 
-// src/request-info.ts
-function toUrl2(value) {
-  return typeof value === "string" ? new URL(value, "http://localhost") : value;
-}
-function getSearchParamsFromContext(context) {
-  if (context?.searchParams) {
-    return new URLSearchParams(context.searchParams);
-  }
-  if (context?.url) {
-    let url = toUrl2(context.url);
-    return new URLSearchParams(url.searchParams);
-  }
-  return new URLSearchParams();
-}
-function getPathnameFromContext(context) {
-  if (context?.pathname) {
-    return context.pathname;
-  }
-  if (context?.url) {
-    let url = toUrl2(context.url);
-    return url.pathname || "/";
-  }
-  return "/";
-}
-function coerceQueryValue(value) {
-  if (value === "true") {
-    return true;
-  }
-  if (value === "false") {
-    return false;
-  }
-  return value;
-}
-function toQueryRecord(searchParams) {
-  let queries = {};
-  for (let [key, value] of searchParams.entries()) {
-    queries[key] = coerceQueryValue(value);
-  }
-  return queries;
-}
-function buildWeaverseNextRequestInfo(context) {
-  let searchParams = getSearchParamsFromContext(context);
-  let search = searchParams.toString();
-  return {
-    pathname: getPathnameFromContext(context),
-    search: search ? `?${search}` : "",
-    queries: toQueryRecord(searchParams),
-    ...context?.i18n ? { i18n: context.i18n } : {}
-  };
-}
-
 // src/server/server-client.ts
 var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
 var RANDOM_ID_RADIX = 36;
 var RANDOM_ID_SLICE_START = 2;
+var MAX_CUSTOM_PAGE_PAGES = 100;
 var JSON_HEADERS = {
   "Content-Type": "application/json",
   Accept: "application/json",
@@ -280,6 +614,25 @@ function generateUuid() {
   }
   return `id-${Math.random().toString(RANDOM_ID_RADIX).slice(RANDOM_ID_SLICE_START)}`;
 }
+function normalizeWeaverseNextPageAssignment(input) {
+  if (!input || typeof input !== "object") {
+    return;
+  }
+  let { projectId, type, handle, locale, meta } = input;
+  if (typeof projectId !== "string" || typeof type !== "string" || typeof handle !== "string") {
+    return;
+  }
+  let normalized = {
+    projectId,
+    type,
+    handle,
+    locale: typeof locale === "string" ? locale : ""
+  };
+  if (meta && typeof meta === "object") {
+    normalized.meta = meta;
+  }
+  return normalized;
+}
 var NextServerClient = class {
   components;
   commerce;
@@ -399,6 +752,59 @@ var NextServerClient = class {
       clearTimeout(timeoutId);
     }
   };
+  _buildCustomPagesUrl(projectId, options, cursor) {
+    let params = new URLSearchParams();
+    if (options.locale) {
+      params.set("locale", options.locale);
+    }
+    if (options.limit) {
+      params.set("limit", String(options.limit));
+    }
+    if (cursor) {
+      params.set("cursor", cursor);
+    }
+    let qs = params.toString();
+    return `${this._baseConfigs.weaverseApiBase}/api/public/v1/projects/${projectId}/custom-pages${qs ? `?${qs}` : ""}`;
+  }
+  /**
+   * Fetch all published custom pages for sitemap generation. Mirrors Hydrogen's
+   * helper but uses Next's fetch cache knobs (`revalidate` / `tags`). It returns
+   * accumulated results on partial pagination failure so a single API hiccup
+   * does not break sitemap generation entirely.
+   */
+  fetchCustomPages = async (options = {}) => {
+    let projectId = await this.resolveProjectId();
+    let entries = [];
+    if (!projectId) {
+      console.warn(
+        "[WeaverseNext] Failed to fetch custom pages: missing projectId"
+      );
+      return entries;
+    }
+    let cursor = null;
+    for (let page = 0; page < MAX_CUSTOM_PAGE_PAGES; page += 1) {
+      let url = this._buildCustomPagesUrl(projectId, options, cursor);
+      try {
+        let result = await this.fetchWithCache(url, {
+          revalidate: options.revalidate,
+          tags: options.tags
+        });
+        entries.push(...result.data ?? []);
+        if (!result.nextCursor) {
+          return entries;
+        }
+        cursor = result.nextCursor;
+      } catch (error) {
+        let message = error instanceof Error ? error.message : String(error);
+        console.warn(
+          entries.length === 0 ? `[WeaverseNext] Failed to fetch custom pages: ${message}` : `[WeaverseNext] Custom pages pagination interrupted: ${message}`
+        );
+        return entries;
+      }
+    }
+    console.warn("[WeaverseNext] Custom pages pagination cap reached");
+    return entries;
+  };
   _generateFallbackPage(message) {
     let rootId = generateUuid();
     return {
@@ -526,7 +932,9 @@ var NextServerClient = class {
     this._assertNoPageError(payload);
     let page = payload.page;
     let project = payload.project;
-    let pageAssignment = payload.pageAssignment;
+    let pageAssignment = normalizeWeaverseNextPageAssignment(
+      payload.pageAssignment
+    );
     page ??= this._generateFallbackPage(
       '<div style="text-align: center;">Please add new section to start.</div>'
     );
@@ -582,12 +990,58 @@ var NextServerClient = class {
       return null;
     }
   };
+  /**
+   * Resolve the request locale (e.g. `fr-ca`) used for merchant overrides.
+   * Unlike Hydrogen — which defaults to `en`/`us` because a Hydrogen
+   * storefront always has an i18n context — Next apps may not thread one
+   * through, so a missing language or country means "no explicit locale" and
+   * the translation fetch is skipped rather than guessed.
+   */
+  _resolveOverridesLocale() {
+    let i18n = this.requestContext?.i18n;
+    let language = typeof i18n?.language === "string" ? i18n.language.trim() : "";
+    let country = typeof i18n?.country === "string" ? i18n.country.trim() : "";
+    if (!(language && country)) {
+      return;
+    }
+    return `${language.toLowerCase()}-${country.toLowerCase()}`;
+  }
+  /**
+   * Fetch locale-specific static-text overrides from the translation API.
+   * Ported from Hydrogen's `fetchMerchantOverrides`: skipped entirely when the
+   * theme has no `i18n` schema (nothing translatable) or when the request has
+   * no explicit locale, and never allowed to fail theme settings.
+   */
+  async _fetchMerchantOverrides(projectId, options) {
+    let { weaverseHost } = this._baseConfigs;
+    if (!(asThemeSchema(this.themeSchema)?.i18n && projectId && weaverseHost)) {
+      return;
+    }
+    let locale = this._resolveOverridesLocale();
+    if (!locale) {
+      return;
+    }
+    let url = `${weaverseHost}/api/translation/static?projectId=${projectId}&locale=${locale}`;
+    try {
+      let overrides = await this.fetchWithCache(url, {
+        method: "GET",
+        headers: { Accept: "application/json" },
+        revalidate: options.revalidate,
+        tags: options.tags
+      });
+      return typeof overrides === "object" && overrides !== null ? overrides : void 0;
+    } catch (error) {
+      console.warn(
+        "[WeaverseNext] Unable to load merchant overrides, using theme defaults:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return;
+    }
+  }
   loadThemeSettings = async (optionsInput = {}) => {
     let options = optionsInput;
     let themeSchema = asThemeSchema(this.themeSchema);
-    let defaultThemeSettings = generateDataFromSchema(
-      this.themeSchema
-    );
+    let defaultThemeSettings = generateDataFromSchema(this.themeSchema);
     let staticContent = themeSchema?.i18n?.staticContent;
     try {
       let projectId = await this.resolveProjectId();
@@ -596,16 +1050,16 @@ var NextServerClient = class {
       }
       let { isDesignMode } = this._baseConfigs;
       let url = `${this._baseConfigs.weaverseApiBase}/api/public/project_configs`;
-      let result = await this.fetchWithCache(
-        url,
-        {
+      let [result, merchantOverrides] = await Promise.all([
+        this.fetchWithCache(url, {
           method: "POST",
           body: JSON.stringify({ projectId, isDesignMode }),
           headers: JSON_HEADERS,
           revalidate: options.revalidate,
           tags: options.tags
-        }
-      );
+        }),
+        this._fetchMerchantOverrides(projectId, options)
+      ]);
       if (typeof result !== "object" || result === null) {
         result = { theme: defaultThemeSettings };
       }
@@ -619,21 +1073,25 @@ var NextServerClient = class {
       if (staticContent) {
         result.staticContent = staticContent;
       }
+      if (merchantOverrides) {
+        result.merchantOverrides = merchantOverrides;
+      }
       if (isDesignMode) {
+        let serializableSchema = themeSchema ? {
+          ...themeSchema,
+          settings: themeSchema.settings?.map((group) => ({
+            ...group,
+            inputs: group?.inputs?.map(
+              (inputItem) => typeof inputItem?.condition === "function" ? {
+                ...inputItem,
+                condition: inputItem.condition.toString()
+              } : inputItem
+            )
+          }))
+        } : void 0;
         result = {
           ...result,
-          schema: themeSchema ? {
-            ...themeSchema,
-            settings: themeSchema.settings?.map((group) => ({
-              ...group,
-              inputs: group?.inputs?.map(
-                (inputItem) => typeof inputItem?.condition === "function" ? {
-                  ...inputItem,
-                  condition: inputItem.condition.toString()
-                } : inputItem
-              )
-            }))
-          } : void 0,
+          schema: serializableSchema,
           publicEnv: this._baseConfigs.publicEnv
         };
       }
@@ -654,8 +1112,11 @@ function createWeaverseNextServerClient(config) {
   return new NextServerClient(config);
 }
 
+exports.createWeaverseNextRevalidateHandler = createWeaverseNextRevalidateHandler;
 exports.createWeaverseNextServerClient = createWeaverseNextServerClient;
+exports.formatWeaverseNextSeoMetadata = formatWeaverseNextSeoMetadata;
 exports.getWeaverseNextConfigs = getWeaverseNextConfigs;
+exports.getWeaverseNextSeoMetadata = getWeaverseNextSeoMetadata;
 exports.normalizeNextPageUrl = normalizeNextPageUrl;
 exports.resolveRequestUrl = resolveRequestUrl;
 //# sourceMappingURL=server.js.map