@weaverse/hydrogen 5.23.0 → 5.24.0

package/dist/index.js

@@ -1,2237 +1,2407 @@
-'use strict';
-
-var hydrogen = require('@shopify/hydrogen');
-var react = require('@weaverse/react');
-var schema$1 = require('@weaverse/schema');
-var jsxRuntime = require('react/jsx-runtime');
-var react$1 = require('react');
-var reactRouter = require('react-router');
-var reactErrorBoundary = require('react-error-boundary');
-
-// src/index.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _shopify_hydrogen = require("@shopify/hydrogen");
+let _weaverse_react = require("@weaverse/react");
+let _weaverse_schema = require("@weaverse/schema");
+let react_jsx_runtime = require("react/jsx-runtime");
+let react = require("react");
+let react_router = require("react-router");
+let react_error_boundary = require("react-error-boundary");
+//#region src/components/main.tsx
 function Main(props) {
-  let { children, dangerouslySetInnerHTML, ...rest } = props;
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    "div",
-    {
-      ...rest,
-      children,
-      dangerouslySetInnerHTML: children ? void 0 : dangerouslySetInnerHTML
-    }
-  );
+	let { children, dangerouslySetInnerHTML, ...rest } = props;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		...rest,
+		children,
+		dangerouslySetInnerHTML: children ? void 0 : dangerouslySetInnerHTML
+	});
 }
-var main_default = Main;
-var schema = schema$1.createSchema({
-  type: "main",
-  title: "Main"
-});
-
-// src/components/index.ts
-var defaultComponents = [
-  {
-    default: main_default,
-    schema
-  }
-];
+//#endregion
+//#region src/components/index.ts
+/** Built-in components required to render the root of every Weaverse page. */
+let defaultComponents = [{
+	default: Main,
+	schema: (0, _weaverse_schema.createSchema)({
+		type: "main",
+		title: "Main"
+	})
+}];
+//#endregion
+//#region src/hooks/translation-context.tsx
+/**
+* Traverse a nested object by dot-path.
+*
+* @example
+* getNestedKey({ cart: { title: 'Cart' } }, 'cart.title') // => 'Cart'
+* getNestedKey({}, 'cart.title', 'fallback')              // => 'fallback'
+*/
 function getNestedKey(obj, path, fallback) {
-  const keys = path.split(".");
-  let current = obj;
-  for (const key of keys) {
-    if (current == null || typeof current !== "object") {
-      return fallback;
-    }
-    current = current[key];
-  }
-  if (typeof current === "string") {
-    return current;
-  }
-  return fallback;
+	const keys = path.split(".");
+	let current = obj;
+	for (const key of keys) {
+		if (current == null || typeof current !== "object") return fallback;
+		current = current[key];
+	}
+	if (typeof current === "string") return current;
+	return fallback;
 }
+/**
+* Replace `{{variable}}` patterns in a string with provided values.
+*
+* @example
+* interpolate('Hello {{name}}!', { name: 'World' }) // => 'Hello World!'
+* interpolate('-{{percentage}}% Off', { percentage: 15 }) // => '-15% Off'
+*/
 function interpolate(template, variables) {
-  if (!variables) {
-    return template;
-  }
-  return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
-    const value = variables[key];
-    return value === void 0 ? match : String(value);
-  });
+	if (!variables) return template;
+	return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+		const value = variables[key];
+		return value === void 0 ? match : String(value);
+	});
 }
-var TranslationContext = react$1.createContext(null);
+const TranslationContext = (0, react.createContext)(null);
 TranslationContext.displayName = "WeaverseTranslationContext";
+/**
+* Build the `t()` translation function over a fixed set of sources.
+*
+* Resolution order, highest priority first:
+* 1. `externalT`         – host i18n (e.g. Shopify), unless it echoes the key
+* 2. `designOverrides`   – live design-mode edits, flat dot-path keys
+* 3. `merchantOverrides` – locale overrides from the API, nested
+* 4. `staticContent`     – the theme's default locale JSON
+* 5. the key itself
+*
+* Design overrides are looked up per-key (own properties only) rather than
+* merged into `merchantOverrides`: a flat key like `cart.title` must override
+* exactly that leaf without wiping sibling keys (`cart.subtitle`), and a
+* per-key own-property lookup never builds nested objects from
+* merchant-controlled keys, so it cannot pollute `Object.prototype`.
+*/
 function createTranslate(sources) {
-  const { staticContent, merchantOverrides, designOverrides, externalT } = sources;
-  return (key, variables) => {
-    if (externalT) {
-      const external = externalT(key, variables);
-      if (external && external !== key) {
-        return external;
-      }
-    }
-    const design = designOverrides && Object.hasOwn(designOverrides, key) ? designOverrides[key] : void 0;
-    const override = merchantOverrides ? getNestedKey(merchantOverrides, key) : void 0;
-    const staticValue = getNestedKey(staticContent, key);
-    const raw = design ?? override ?? staticValue ?? key;
-    return interpolate(raw, variables);
-  };
+	const { staticContent, merchantOverrides, designOverrides, externalT } = sources;
+	return (key, variables) => {
+		if (externalT) {
+			const external = externalT(key, variables);
+			if (external && external !== key) return external;
+		}
+		const design = designOverrides && Object.hasOwn(designOverrides, key) ? designOverrides[key] : void 0;
+		const override = merchantOverrides ? getNestedKey(merchantOverrides, key) : void 0;
+		const staticValue = getNestedKey(staticContent, key);
+		return interpolate(design ?? override ?? staticValue ?? key, variables);
+	};
 }
-var EMPTY = {};
-var NOOP_SUBSCRIBE = () => () => {
-};
-var NOOP_SNAPSHOT = () => EMPTY;
-function TranslationProvider({
-  staticContent,
-  merchantOverrides,
-  t: externalT,
-  translationStore,
-  themeTextStore,
-  children
-}) {
-  const store = translationStore ?? themeTextStore ?? null;
-  const designOverrides = react.useSafeExternalStore(
-    store?.subscribe ?? NOOP_SUBSCRIBE,
-    store?.getSnapshot ?? NOOP_SNAPSHOT,
-    store?.getServerSnapshot ?? NOOP_SNAPSHOT
-  );
-  const value = react$1.useMemo(
-    () => ({
-      t: createTranslate({
-        staticContent,
-        merchantOverrides,
-        designOverrides,
-        externalT
-      }),
-      translationStore: store,
-      // Deprecated alias — same instance, kept for backward compatibility.
-      themeTextStore: store,
-      merchantOverrides: merchantOverrides ?? null
-    }),
-    [staticContent, merchantOverrides, designOverrides, externalT, store]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(TranslationContext.Provider, { value, children });
+const EMPTY = {};
+const NOOP_SUBSCRIBE = () => () => {};
+const NOOP_SNAPSHOT = () => EMPTY;
+/**
+* Provider that wraps the app to expose the `t()` function.
+*
+* - `staticContent`      – the theme's default locale JSON (from themeSchema.i18n)
+* - `merchantOverrides`  – locale-specific overrides fetched from the API
+* - `translationStore`   – optional store for live design-mode text overrides
+*   (the deprecated `themeTextStore` prop is accepted as a fallback)
+*/
+function TranslationProvider({ staticContent, merchantOverrides, t: externalT, translationStore, themeTextStore, children }) {
+	const store = translationStore ?? themeTextStore ?? null;
+	const designOverrides = (0, _weaverse_react.useSafeExternalStore)(store?.subscribe ?? NOOP_SUBSCRIBE, store?.getSnapshot ?? NOOP_SNAPSHOT, store?.getServerSnapshot ?? NOOP_SNAPSHOT);
+	const value = (0, react.useMemo)(() => ({
+		t: createTranslate({
+			staticContent,
+			merchantOverrides,
+			designOverrides,
+			externalT
+		}),
+		translationStore: store,
+		themeTextStore: store,
+		merchantOverrides: merchantOverrides ?? null
+	}), [
+		staticContent,
+		merchantOverrides,
+		designOverrides,
+		externalT,
+		store
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TranslationContext.Provider, {
+		value,
+		children
+	});
 }
+/**
+* Hook to access the translation `t()` function.
+*
+* Must be used inside a component wrapped by `withWeaverse` or `TranslationProvider`.
+*
+* @example
+* ```tsx
+* function CartTitle() {
+*   const { t } = useTranslation()
+*   return <h2>{t('cart.title')}</h2>
+* }
+* ```
+*/
 function useTranslation() {
-  const ctx = react$1.useContext(TranslationContext);
-  if (!ctx) {
-    throw new Error(
-      "useTranslation must be used within <TranslationProvider>. Wrap your app with withWeaverse()."
-    );
-  }
-  return ctx;
+	const ctx = (0, react.useContext)(TranslationContext);
+	if (!ctx) throw new Error("useTranslation must be used within <TranslationProvider>. Wrap your app with withWeaverse().");
+	return ctx;
 }
-var ThemeTextProvider = TranslationProvider;
-var useThemeText = useTranslation;
+/**
+* Legacy name for {@link TranslationProvider}.
+* @deprecated Use {@link TranslationProvider} instead.
+*/
+const ThemeTextProvider = TranslationProvider;
+/**
+* Legacy name for {@link useTranslation}.
+* @deprecated Use {@link useTranslation} instead.
+*/
+const useThemeText = useTranslation;
+//#endregion
+//#region src/hooks/use-weaverse-data-context.ts
+/**
+* Creates flat route-keyed structure from matches
+* Target: {root: {...rootData}, "routes/product": {...productData}}
+* Eliminates all duplication by using route IDs as keys
+*/
 function createFlatDataContext(matches) {
-  const context = {};
-  for (const match of matches) {
-    if (match.data && typeof match.data === "object") {
-      context[match.id] = match.data;
-    }
-  }
-  return context;
+	const context = {};
+	for (const match of matches) if (match.data && typeof match.data === "object") context[match.id] = match.data;
+	return context;
 }
+/**
+* Hook to get flat route-keyed data context from matches
+* Returns: {root: {...}, "routes/xxx": {...}}
+* No more useLoaderData dependency - everything comes from matches
+*/
 function useWeaverseDataContext() {
-  const matches = reactRouter.useMatches();
-  return createFlatDataContext(matches);
+	return createFlatDataContext((0, react_router.useMatches)());
 }
+/**
+* Helper function to create flat route-keyed data context from useMatches() result
+* Returns: {root: {...}, "routes/xxx": {...}}
+*/
 function createWeaverseDataContext(matches) {
-  return createFlatDataContext(matches);
+	return createFlatDataContext(matches);
 }
-
-// src/seo.ts
+//#endregion
+//#region src/seo.ts
+/**
+* Convert a Weaverse page-level SEO payload into React Router
+* `MetaDescriptor[]`. Pure, synchronous, tree-shakeable — does not fetch.
+*
+* Behavior:
+* - `title` → top-level `{ title }` descriptor.
+* - `description` / `keywords` → `<meta name="...">`.
+* - `canonicalUrl` → `<link rel="canonical">`.
+* - `openGraph.*` → `<meta property="og:*">`. `og:type` defaults to
+*   `'website'` when any other OG field is present.
+* - `twitter.*` → `<meta name="twitter:*">`. `twitter:card` defaults to
+*   `'summary'` when any other Twitter field is present.
+* - `robots` is always emitted (defaults to `'index,follow'`) so themes
+*   stacking multiple SEO sources have a deterministic last word on
+*   indexing for Weaverse-managed pages.
+* - Empty strings / missing fields are filtered before return so empty
+*   descriptors don't override earlier sources (e.g. Hydrogen
+*   `getSeoMeta`).
+*/
 function formatMetaDescriptors(seo) {
-  if (!seo) {
-    return [{ name: "robots", content: "index,follow" }];
-  }
-  let descriptors = [];
-  if (seo.title) {
-    descriptors.push({ title: seo.title });
-  }
-  if (seo.description) {
-    descriptors.push({ name: "description", content: seo.description });
-  }
-  if (seo.keywords) {
-    descriptors.push({ name: "keywords", content: seo.keywords });
-  }
-  if (seo.canonicalUrl) {
-    descriptors.push({
-      tagName: "link",
-      rel: "canonical",
-      href: seo.canonicalUrl
-    });
-  }
-  let og = seo.openGraph;
-  if (og && (og.title || og.description || og.image || og.type)) {
-    if (og.title) {
-      descriptors.push({ property: "og:title", content: og.title });
-    }
-    if (og.description) {
-      descriptors.push({ property: "og:description", content: og.description });
-    }
-    if (og.image) {
-      descriptors.push({ property: "og:image", content: og.image });
-    }
-    descriptors.push({ property: "og:type", content: og.type || "website" });
-  }
-  let tw = seo.twitter;
-  if (tw && (tw.title || tw.description || tw.image || tw.cardType)) {
-    descriptors.push({
-      name: "twitter:card",
-      content: tw.cardType || "summary"
-    });
-    if (tw.title) {
-      descriptors.push({ name: "twitter:title", content: tw.title });
-    }
-    if (tw.description) {
-      descriptors.push({ name: "twitter:description", content: tw.description });
-    }
-    if (tw.image) {
-      descriptors.push({ name: "twitter:image", content: tw.image });
-    }
-  }
-  let index = seo.robots?.index !== false;
-  let follow = seo.robots?.follow !== false;
-  descriptors.push({
-    name: "robots",
-    content: `${index ? "index" : "noindex"},${follow ? "follow" : "nofollow"}`
-  });
-  return descriptors;
+	if (!seo) return [{
+		name: "robots",
+		content: "index,follow"
+	}];
+	let descriptors = [];
+	if (seo.title) descriptors.push({ title: seo.title });
+	if (seo.description) descriptors.push({
+		name: "description",
+		content: seo.description
+	});
+	if (seo.keywords) descriptors.push({
+		name: "keywords",
+		content: seo.keywords
+	});
+	if (seo.canonicalUrl) descriptors.push({
+		tagName: "link",
+		rel: "canonical",
+		href: seo.canonicalUrl
+	});
+	let og = seo.openGraph;
+	if (og && (og.title || og.description || og.image || og.type)) {
+		if (og.title) descriptors.push({
+			property: "og:title",
+			content: og.title
+		});
+		if (og.description) descriptors.push({
+			property: "og:description",
+			content: og.description
+		});
+		if (og.image) descriptors.push({
+			property: "og:image",
+			content: og.image
+		});
+		descriptors.push({
+			property: "og:type",
+			content: og.type || "website"
+		});
+	}
+	let tw = seo.twitter;
+	if (tw && (tw.title || tw.description || tw.image || tw.cardType)) {
+		descriptors.push({
+			name: "twitter:card",
+			content: tw.cardType || "summary"
+		});
+		if (tw.title) descriptors.push({
+			name: "twitter:title",
+			content: tw.title
+		});
+		if (tw.description) descriptors.push({
+			name: "twitter:description",
+			content: tw.description
+		});
+		if (tw.image) descriptors.push({
+			name: "twitter:image",
+			content: tw.image
+		});
+	}
+	let index = seo.robots?.index !== false;
+	let follow = seo.robots?.follow !== false;
+	descriptors.push({
+		name: "robots",
+		content: `${index ? "index" : "noindex"},${follow ? "follow" : "nofollow"}`
+	});
+	return descriptors;
 }
+/**
+* Convenience accessor: pull `page.seo` out of a `WeaverseLoaderData`
+* (or `HydrogenPageData`) and emit `MetaDescriptor[]`. Null-safe.
+*
+* @example
+* ```ts
+* export const meta: MetaFunction<typeof loader> = ({ data }) => {
+*   return getWeaverseSeoMeta(data?.weaverseData)
+* }
+* ```
+*/
 function getWeaverseSeoMeta(data) {
-  if (!data) {
-    return formatMetaDescriptors(null);
-  }
-  let page = "items" in data && "id" in data ? data : data.page ?? null;
-  return formatMetaDescriptors(page?.seo ?? null);
+	if (!data) return formatMetaDescriptors(null);
+	return formatMetaDescriptors(("items" in data && "id" in data ? data : data.page ?? null)?.seo ?? null);
 }
+//#endregion
+//#region src/types.ts
+/**
+* Type guard for detecting function-based projectId.
+*
+* Used internally by WeaverseClient constructor to determine
+* if projectId needs evaluation or can be used directly.
+*/
 function isProjectIdFunction(projectId) {
-  return typeof projectId === "function";
+	return typeof projectId === "function";
 }
-var WeaverseError = class _WeaverseError extends Error {
-  /** Machine-readable error code. */
-  code;
-  /** HTTP status associated with the failure, when available. */
-  statusCode;
-  /** Structured diagnostic details for logging and error handling. */
-  context;
-  /** Creates a Weaverse request error with a stable code and diagnostics. */
-  constructor(message, code = "WEAVERSE_ERROR", statusCode, context) {
-    super(message);
-    this.name = "WeaverseError";
-    this.code = code;
-    this.statusCode = statusCode;
-    this.context = context;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _WeaverseError);
-    }
-  }
+/** Error raised by Weaverse requests with a stable code and optional context. */
+var WeaverseError = class WeaverseError extends Error {
+	/** Machine-readable error code. */
+	code;
+	/** HTTP status associated with the failure, when available. */
+	statusCode;
+	/** Structured diagnostic details for logging and error handling. */
+	context;
+	/** Creates a Weaverse request error with a stable code and diagnostics. */
+	constructor(message, code = "WEAVERSE_ERROR", statusCode, context) {
+		super(message);
+		this.name = "WeaverseError";
+		this.code = code;
+		this.statusCode = statusCode;
+		this.context = context;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, WeaverseError);
+	}
+};
+/**
+* Error thrown by {@link WeaverseClient.loadPage} when the client is created
+* with `throwPageLoadFailures: true` and the page cannot be loaded.
+*
+* Genuine absence is not an error: a missing project still resolves to `null`
+* and an unassigned page still resolves to a fallback page.
+*/
+var WeaverseLoadError = class extends WeaverseError {
+	/** Failure class used to choose a response status or recovery action. */
+	kind;
+	/** Creates a classified page-load failure. */
+	constructor(message, kind, statusCode, context) {
+		super(message, "LOAD_FAILURE", statusCode, context);
+		this.name = "WeaverseLoadError";
+		this.kind = kind;
+	}
 };
+/**
+* Type guards for response validation
+*/
 function isWithCacheFetchResponse(response) {
-  return typeof response === "object" && response !== null && "data" in response && "response" in response;
+	return typeof response === "object" && response !== null && "data" in response && "response" in response;
 }
+/** Checks whether a value contains the required project response fields. */
 function isFetchProjectPayload(payload) {
-  return typeof payload === "object" && payload !== null && "page" in payload && "project" in payload && "pageAssignment" in payload;
+	return typeof payload === "object" && payload !== null && "page" in payload && "project" in payload && "pageAssignment" in payload;
 }
+/** Checks whether a response contains a string error message. */
 function hasError(response) {
-  return typeof response === "object" && response !== null && "error" in response && typeof response.error === "string";
+	return typeof response === "object" && response !== null && "error" in response && typeof response.error === "string";
 }
+/** Checks whether a value contains a theme settings object. */
 function isThemeSettingsResponse(data) {
-  if (typeof data !== "object" || data === null) {
-    return false;
-  }
-  const record = data;
-  return "theme" in record && typeof record.theme === "object" && record.theme !== null;
+	if (typeof data !== "object" || data === null) return false;
+	const record = data;
+	return "theme" in record && typeof record.theme === "object" && record.theme !== null;
 }
-function isValidHydrogenSchema(schema2) {
-  return schema$1.isValidSchema(schema2);
+/**
+* Type guard to check if a schema is valid.
+* Leverages validation from @weaverse/schema package which provides
+* comprehensive Zod-based validation with the ElementSchema.
+*
+* @param schema - Unknown value to validate
+* @returns True if schema is a valid HydrogenComponentSchema
+*
+* @example
+* ```typescript
+* if (isValidHydrogenSchema(userInput)) {
+*   // userInput is now typed as HydrogenComponentSchema
+*   console.log(userInput.type)
+* }
+* ```
+*/
+function isValidHydrogenSchema(schema) {
+	return (0, _weaverse_schema.isValidSchema)(schema);
 }
-function hasWeaverseStudio(window2) {
-  return "weaverseStudio" in window2 && typeof window2.weaverseStudio === "object";
+/** Checks whether the browser window exposes the Weaverse Studio bridge. */
+function hasWeaverseStudio(window) {
+	return "weaverseStudio" in window && typeof window.weaverseStudio === "object";
 }
-
-// src/utils/studio-script-src.ts
-var DEFAULT_WEAVERSE_HOST = "https://studio.weaverse.io";
-var TRUSTED_STUDIO_DOMAINS = ["weaverse.io", "weaverse.dev"];
+//#endregion
+//#region src/utils/studio-script-src.ts
+const DEFAULT_WEAVERSE_HOST = "https://studio.weaverse.io";
+/**
+* Weaverse-controlled apex domains the Studio bridge may be served from
+* (matched on the host itself and any subdomain).
+*/
+const TRUSTED_STUDIO_DOMAINS = ["weaverse.io", "weaverse.dev"];
 function isLoopbackHostname(hostname) {
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".localhost");
+	return hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".localhost");
 }
+/**
+* Whether `host` is an origin we trust to serve the Studio bridge script (or,
+* server-side, to resolve page/theme data).
+*
+* The bridge executes inside the storefront document and the host can drive
+* server-side fetches, so a host taken from an attacker-controllable source —
+* e.g. a crafted `?weaverseHost=` query — is both an XSS and an SSRF vector.
+* Callers MUST reject untrusted hosts before acting on them. Trusts
+* `weaverse.io`/`weaverse.dev` and their subdomains over https; loopback is
+* opt-in (see {@link TrustedStudioHostOptions.allowLoopback}).
+*/
 function isTrustedStudioHost(host, options) {
-  let parsed;
-  try {
-    parsed = new URL(host);
-  } catch {
-    return false;
-  }
-  let { hostname, protocol } = parsed;
-  if (options?.allowLoopback && isLoopbackHostname(hostname)) {
-    return protocol === "http:" || protocol === "https:";
-  }
-  if (protocol !== "https:") {
-    return false;
-  }
-  return TRUSTED_STUDIO_DOMAINS.some(
-    (domain) => hostname === domain || hostname.endsWith(`.${domain}`)
-  );
+	let parsed;
+	try {
+		parsed = new URL(host);
+	} catch {
+		return false;
+	}
+	let { hostname, protocol } = parsed;
+	if (options?.allowLoopback && isLoopbackHostname(hostname)) return protocol === "http:" || protocol === "https:";
+	if (protocol !== "https:") return false;
+	return TRUSTED_STUDIO_DOMAINS.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
 }
+/**
+* Build the Studio bridge script URL for the current mode, or `null` when the
+* storefront is not being previewed inside Weaverse Studio.
+*
+* This is the single gate that keeps the bridge off production storefronts:
+* a normal visitor's URL carries none of the design/preview markers, so the
+* result is `null` and no script is ever requested.
+*
+* Shared by the page-scoped `useStudio` (which also binds the page for
+* editing) and the root-level `useStudioConnect` (which only needs the script
+* to load so Studio's `checkWeaversePage()` handshake can answer on routes
+* with no Weaverse content).
+*/
 function getStudioScriptSrc(mode) {
-  let {
-    isDesignMode,
-    isPreviewMode,
-    isRevisionPreview,
-    weaverseHost,
-    weaverseVersion
-  } = mode;
-  let base = `${weaverseHost}/static/studio/hydrogen`;
-  let version = `?v=${weaverseVersion}`;
-  if (isRevisionPreview || isPreviewMode) {
-    return `${base}/preview.js${version}`;
-  }
-  if (isDesignMode) {
-    return `${base}/index.js${version}`;
-  }
-  return null;
+	let { isDesignMode, isPreviewMode, isRevisionPreview, weaverseHost, weaverseVersion } = mode;
+	let base = `${weaverseHost}/static/studio/hydrogen`;
+	let version = `?v=${weaverseVersion}`;
+	if (isRevisionPreview || isPreviewMode) return `${base}/preview.js${version}`;
+	if (isDesignMode) return `${base}/index.js${version}`;
+	return null;
 }
+/**
+* Resolve the Studio bridge script URL from a URL query string — the markers
+* Studio attaches when it drives the preview iframe (`isDesignMode`,
+* `isPreviewMode`, `__revisionId`, `weaverseHost`, `weaverseVersion`) — or
+* `null` outside Studio.
+*
+* `storefrontHostname` is the document's own hostname: a loopback Studio host
+* is only honored when the storefront itself is loopback (genuine local-builder
+* dev), so a crafted public link can't load a script from a visitor's loopback
+* service into the storefront origin.
+*
+* The `weaverseHost` query is attacker-controllable, so a host that is not a
+* {@link isTrustedStudioHost trusted origin} resolves to `null` (no bridge) —
+* it is never silently replaced with production Studio, which would otherwise
+* inject the wrong bridge for self-hosted/staging deployments. Such deployments
+* (a non-`weaverse.io` `WEAVERSE_HOST`) therefore don't load the root bridge on
+* content-less routes; the page-scoped {@link getStudioScriptSrc} via
+* `useStudio` still uses the configured host on content routes.
+*
+* Pure (no DOM) so the root-level connect's production gate stays unit-testable
+* and needs no loader data.
+*/
 function resolveStudioScriptSrc(search, storefrontHostname = "") {
-  let params = new URLSearchParams(search);
-  let last = (key) => params.getAll(key).at(-1);
-  let host = last("weaverseHost");
-  if (host) {
-    let allowLoopback = isLoopbackHostname(storefrontHostname);
-    if (!isTrustedStudioHost(host, { allowLoopback })) {
-      return null;
-    }
-  }
-  return getStudioScriptSrc({
-    isDesignMode: last("isDesignMode") === "true",
-    isPreviewMode: last("isPreviewMode") === "true",
-    isRevisionPreview: params.has("__revisionId"),
-    weaverseHost: host || DEFAULT_WEAVERSE_HOST,
-    weaverseVersion: last("weaverseVersion") || ""
-  });
+	let params = new URLSearchParams(search);
+	let last = (key) => params.getAll(key).at(-1);
+	let host = last("weaverseHost");
+	if (host) {
+		if (!isTrustedStudioHost(host, { allowLoopback: isLoopbackHostname(storefrontHostname) })) return null;
+	}
+	return getStudioScriptSrc({
+		isDesignMode: last("isDesignMode") === "true",
+		isPreviewMode: last("isPreviewMode") === "true",
+		isRevisionPreview: params.has("__revisionId"),
+		weaverseHost: host || DEFAULT_WEAVERSE_HOST,
+		weaverseVersion: last("weaverseVersion") || ""
+	});
 }
-
-// src/utils/index.ts
-var warnedTypes = /* @__PURE__ */ new Set();
+//#endregion
+//#region src/utils/index.ts
+let warnedTypes = /* @__PURE__ */ new Set();
 function logOnce(type, message) {
-  if (!warnedTypes.has(type)) {
-    console.warn(message);
-    warnedTypes.add(type);
-  }
+	if (!warnedTypes.has(type)) {
+		console.warn(message);
+		warnedTypes.add(type);
+	}
 }
 function deepMergeArrays(target, source) {
-  return [...target, ...source];
+	return [...target, ...source];
 }
 function mergeInspectorSettings(settings, inspector, type) {
-  if (!inspector?.length) {
-    return settings;
-  }
-  if (!settings?.length) {
-    return inspector;
-  }
-  console.info(
-    `Schema "${type}": Both 'settings' and 'inspector' found. Using 'settings' with 'inspector' as fallback.`
-  );
-  return deepMergeArrays(settings, inspector);
+	if (!inspector?.length) return settings;
+	if (!settings?.length) return inspector;
+	console.info(`Schema "${type}": Both 'settings' and 'inspector' found. Using 'settings' with 'inspector' as fallback.`);
+	return deepMergeArrays(settings, inspector);
 }
+/**
+* Extract and parse query parameters from a request URL.
+* Supports optional allowlist for security-sensitive applications.
+*
+* @param request - The incoming request
+* @param options - Optional configuration
+* @param options.allowedKeys - If provided, only these keys will be extracted
+* @returns Parsed query parameters with type coercion for booleans
+*
+* @example
+* ```typescript
+* // Extract all params
+* const queries = getRequestQueries(request)
+*
+* // Extract only allowed params (security-sensitive)
+* const queries = getRequestQueries(request, {
+*   allowedKeys: ['weaverseProjectId', 'weaverseHost']
+* })
+* ```
+*/
 function getRequestQueries(request, options) {
-  let url = new URL(request.url);
-  let queries = {};
-  for (let [key, value] of url.searchParams.entries()) {
-    if (options?.allowedKeys && !options.allowedKeys.includes(key)) {
-      continue;
-    }
-    if (value === "true") {
-      queries[key] = true;
-    } else if (value === "false") {
-      queries[key] = false;
-    } else {
-      queries[key] = value;
-    }
-  }
-  return queries;
+	let url = new URL(request.url);
+	let queries = {};
+	for (let [key, value] of url.searchParams.entries()) {
+		if (options?.allowedKeys && !options.allowedKeys.includes(key)) continue;
+		if (value === "true") queries[key] = true;
+		else if (value === "false") queries[key] = false;
+		else queries[key] = value;
+	}
+	return queries;
 }
+/**
+* Resolves project, endpoint, and Studio mode configuration for a request.
+* URL-provided Studio values take precedence over environment defaults.
+*/
 function getWeaverseConfigs(request, env) {
-  let queries = getRequestQueries(request);
-  let {
-    WEAVERSE_PROJECT_ID,
-    WEAVERSE_API_KEY,
-    WEAVERSE_HOST,
-    WEAVERSE_PUBLIC_API_BASE,
-    PUBLIC_STORE_DOMAIN,
-    PUBLIC_STOREFRONT_API_TOKEN
-  } = env || {};
-  let envFromProcess = typeof process !== "undefined" && process.env || {};
-  let {
-    weaverseProjectId,
-    weaverseHost,
-    isDesignMode,
-    isPreviewMode,
-    sectionType,
-    weaverseVersion,
-    weaverseApiKey
-  } = queries;
-  let url = new URL(request.url);
-  let isRevisionPreview = url.searchParams.has("__revisionId");
-  let configuredWeaverseHost = WEAVERSE_HOST || envFromProcess.WEAVERSE_HOST;
-  let trustedUrlHost = typeof weaverseHost === "string" && isTrustedStudioHost(weaverseHost) ? weaverseHost : "";
-  let resolvedWeaverseHost = trustedUrlHost || configuredWeaverseHost || "https://studio.weaverse.io";
-  let resolvedWeaverseApiBase = trustedUrlHost ? trustedUrlHost : WEAVERSE_PUBLIC_API_BASE || envFromProcess.WEAVERSE_PUBLIC_API_BASE || (configuredWeaverseHost && configuredWeaverseHost !== "https://studio.weaverse.io" ? configuredWeaverseHost : "https://api.weaverse.io");
-  return {
-    projectId: weaverseProjectId || WEAVERSE_PROJECT_ID || envFromProcess.WEAVERSE_PROJECT_ID || "",
-    weaverseHost: resolvedWeaverseHost,
-    weaverseApiBase: resolvedWeaverseApiBase,
-    weaversePublicApiBase: resolvedWeaverseApiBase,
-    weaverseApiKey: weaverseApiKey || WEAVERSE_API_KEY || envFromProcess.WEAVERSE_API_KEY || "",
-    weaverseVersion: weaverseVersion || "",
-    isDesignMode,
-    isPreviewMode,
-    isRevisionPreview,
-    sectionType: sectionType || "",
-    publicEnv: {
-      PUBLIC_STORE_DOMAIN: PUBLIC_STORE_DOMAIN || "",
-      PUBLIC_STOREFRONT_API_TOKEN: PUBLIC_STOREFRONT_API_TOKEN || ""
-    }
-  };
+	let queries = getRequestQueries(request);
+	let { WEAVERSE_PROJECT_ID, WEAVERSE_API_KEY, WEAVERSE_HOST, WEAVERSE_PUBLIC_API_BASE, PUBLIC_STORE_DOMAIN, PUBLIC_STOREFRONT_API_TOKEN } = env || {};
+	let envFromProcess = typeof process !== "undefined" && process.env || {};
+	let { weaverseProjectId, weaverseHost, isDesignMode, isPreviewMode, sectionType, weaverseVersion, weaverseApiKey } = queries;
+	let isRevisionPreview = new URL(request.url).searchParams.has("__revisionId");
+	let configuredWeaverseHost = WEAVERSE_HOST || envFromProcess.WEAVERSE_HOST;
+	let trustedUrlHost = typeof weaverseHost === "string" && isTrustedStudioHost(weaverseHost) ? weaverseHost : "";
+	let resolvedWeaverseHost = trustedUrlHost || configuredWeaverseHost || "https://studio.weaverse.io";
+	let resolvedWeaverseApiBase = trustedUrlHost ? trustedUrlHost : WEAVERSE_PUBLIC_API_BASE || envFromProcess.WEAVERSE_PUBLIC_API_BASE || (configuredWeaverseHost && configuredWeaverseHost !== "https://studio.weaverse.io" ? configuredWeaverseHost : "https://api.weaverse.io");
+	return {
+		projectId: weaverseProjectId || WEAVERSE_PROJECT_ID || envFromProcess.WEAVERSE_PROJECT_ID || "",
+		weaverseHost: resolvedWeaverseHost,
+		weaverseApiBase: resolvedWeaverseApiBase,
+		weaversePublicApiBase: resolvedWeaverseApiBase,
+		weaverseApiKey: weaverseApiKey || WEAVERSE_API_KEY || envFromProcess.WEAVERSE_API_KEY || "",
+		weaverseVersion: weaverseVersion || "",
+		isDesignMode,
+		isPreviewMode,
+		isRevisionPreview,
+		sectionType: sectionType || "",
+		publicEnv: {
+			PUBLIC_STORE_DOMAIN: PUBLIC_STORE_DOMAIN || "",
+			PUBLIC_STOREFRONT_API_TOKEN: PUBLIC_STOREFRONT_API_TOKEN || ""
+		}
+	};
 }
-var schemaDefaultsCache = /* @__PURE__ */ new WeakMap();
-function generateDataFromSchema(schema2) {
-  const cached = schemaDefaultsCache.get(schema2);
-  if (cached) {
-    return cached;
-  }
-  let data = {};
-  let inspectorGroups = [];
-  const isComponentSchema = (s) => "type" in s && typeof s.type === "string";
-  if (isComponentSchema(schema2)) {
-    if (schema2.settings) {
-      inspectorGroups = schema2.settings;
-    }
-    if (schema2.inspector) {
-      if (schema2.settings?.length) {
-        inspectorGroups = mergeInspectorSettings(
-          schema2.settings,
-          schema2.inspector,
-          schema2.type || "unknown"
-        );
-      } else {
-        inspectorGroups = schema2.inspector;
-        if (schema2.type) {
-          logOnce(
-            schema2.type,
-            `\u26A0\uFE0F  Schema "${schema2.type}": The 'inspector' property is deprecated. Please use 'settings' instead.`
-          );
-        }
-      }
-    }
-  } else {
-    if (schema2.settings) {
-      inspectorGroups = schema2.settings;
-    }
-    if (schema2.inspector) {
-      if (schema2.settings?.length) {
-        inspectorGroups = mergeInspectorSettings(
-          schema2.settings,
-          schema2.inspector,
-          "Theme Schema"
-        );
-      } else {
-        inspectorGroups = schema2.inspector;
-        logOnce(
-          "ThemeSchema",
-          `\u26A0\uFE0F  Theme Schema: The 'inspector' property is deprecated. Please use 'settings' instead.`
-        );
-      }
-    }
-  }
-  if (inspectorGroups?.length) {
-    for (let group of inspectorGroups) {
-      for (let input of group.inputs) {
-        let { name, defaultValue } = input;
-        if (name && defaultValue !== null && defaultValue !== void 0) {
-          data[name] = defaultValue;
-        }
-      }
-    }
-  }
-  schemaDefaultsCache.set(schema2, data);
-  return data;
+/**
+* Cache for generateDataFromSchema results using WeakMap.
+* WeakMap allows garbage collection when schema objects are no longer referenced.
+*/
+const schemaDefaultsCache = /* @__PURE__ */ new WeakMap();
+/**
+* Generate default data from component or theme schema.
+* Results are memoized using WeakMap for performance.
+*
+* @param schema - Component or theme schema
+* @returns Default data object extracted from schema inputs
+*/
+function generateDataFromSchema(schema) {
+	const cached = schemaDefaultsCache.get(schema);
+	if (cached) return cached;
+	let data = {};
+	let inspectorGroups = [];
+	const isComponentSchema = (s) => "type" in s && typeof s.type === "string";
+	if (isComponentSchema(schema)) {
+		if (schema.settings) inspectorGroups = schema.settings;
+		if (schema.inspector) if (schema.settings?.length) inspectorGroups = mergeInspectorSettings(schema.settings, schema.inspector, schema.type || "unknown");
+		else {
+			inspectorGroups = schema.inspector;
+			if (schema.type) logOnce(schema.type, `⚠️  Schema "${schema.type}": The 'inspector' property is deprecated. Please use 'settings' instead.`);
+		}
+	} else {
+		if (schema.settings) inspectorGroups = schema.settings;
+		if (schema.inspector) if (schema.settings?.length) inspectorGroups = mergeInspectorSettings(schema.settings, schema.inspector, "Theme Schema");
+		else {
+			inspectorGroups = schema.inspector;
+			logOnce("ThemeSchema", `⚠️  Theme Schema: The 'inspector' property is deprecated. Please use 'settings' instead.`);
+		}
+	}
+	if (inspectorGroups?.length) for (let group of inspectorGroups) for (let input of group.inputs) {
+		let { name, defaultValue } = input;
+		if (name && defaultValue !== null && defaultValue !== void 0) data[name] = defaultValue;
+	}
+	schemaDefaultsCache.set(schema, data);
+	return data;
 }
 function recursivelyAddDataItem(type, components, items, initData) {
-  let component = components.find((c) => c.schema.type === type);
-  if (!component) {
-    return;
-  }
-  let childIds = [];
-  let id = crypto.randomUUID();
-  let { children, ...data } = component.schema?.presets || {};
-  if (children) {
-    for (let c of children) {
-      let { type: type2, children: children2, ...data2 } = c;
-      let childId = recursivelyAddDataItem(type2, components, items, data2);
-      childIds.push({ id: childId });
-    }
-  }
-  items.push({
-    data: { ...data, ...initData },
-    id,
-    type,
-    children: childIds
-  });
-  return id;
+	let component = components.find((c) => c.schema.type === type);
+	if (!component) return;
+	let childIds = [];
+	let id = crypto.randomUUID();
+	let { children, ...data } = component.schema?.presets || {};
+	if (children) for (let c of children) {
+		let { type, children, ...data } = c;
+		let childId = recursivelyAddDataItem(type, components, items, data);
+		childIds.push({ id: childId });
+	}
+	items.push({
+		data: {
+			...data,
+			...initData
+		},
+		id,
+		type,
+		children: childIds
+	});
+	return id;
 }
+/** Creates synthetic loader data for previewing one registered component type. */
 function getPreviewData(type, components, weaverseHost) {
-  let items = [];
-  return {
-    project: { id: "x", weaverseShopId: "shop-id", name: "Section Preview" },
-    configs: {
-      projectId: "x",
-      weaverseHost,
-      isDesignMode: false,
-      isPreviewMode: true,
-      requestInfo: {
-        i18n: {
-          label: "United States (USD $)",
-          language: "EN",
-          country: "US",
-          currency: "USD",
-          pathPrefix: ""
-        },
-        queries: {},
-        pathname: "/",
-        search: ""
-      }
-    },
-    page: {
-      id: "weaverse-preview-page",
-      name: "Preview section",
-      rootId: "1",
-      items: [
-        {
-          data: {},
-          id: "1",
-          type: "main",
-          children: [{ id: recursivelyAddDataItem(type, components, items) }]
-        },
-        ...items
-      ]
-    }
-  };
+	let items = [];
+	return {
+		project: {
+			id: "x",
+			weaverseShopId: "shop-id",
+			name: "Section Preview"
+		},
+		configs: {
+			projectId: "x",
+			weaverseHost,
+			isDesignMode: false,
+			isPreviewMode: true,
+			requestInfo: {
+				i18n: {
+					label: "United States (USD $)",
+					language: "EN",
+					country: "US",
+					currency: "USD",
+					pathPrefix: ""
+				},
+				queries: {},
+				pathname: "/",
+				search: ""
+			}
+		},
+		page: {
+			id: "weaverse-preview-page",
+			name: "Preview section",
+			rootId: "1",
+			items: [{
+				data: {},
+				id: "1",
+				type: "main",
+				children: [{ id: recursivelyAddDataItem(type, components, items) }]
+			}, ...items]
+		}
+	};
 }
-
-// src/utils/translation-store.ts
+//#endregion
+//#region src/utils/translation-store.ts
+/**
+* Minimal mutable store for design-mode static text overrides.
+*
+* useSyncExternalStore-compatible. Passed into TranslationProvider which
+* subscribes internally and merges overrides into merchantOverrides.
+* The studio bridge calls updateOverrides() via weaverse.internal.translationStore
+* (also exposed as the deprecated weaverse.internal.themeTextStore alias).
+*
+* Shape: flat Record<string, string> — dot-notation keys map to values
+* (e.g. "cart.title" → "Shopping Cart").
+*/
 var TranslationStore = class {
-  /** Current flat translation overrides keyed by dot-path. */
-  overrides = {};
-  listeners = /* @__PURE__ */ new Set();
-  /** Replaces all overrides and notifies subscribers. */
-  setOverrides = (overrides) => {
-    this.overrides = { ...overrides };
-    this.emit();
-  };
-  /** Merges changed overrides and notifies subscribers. */
-  updateOverrides = (newOverrides) => {
-    this.overrides = { ...this.overrides, ...newOverrides };
-    this.emit();
-  };
-  /** Returns the current client snapshot for `useSyncExternalStore`. */
-  getSnapshot = () => this.overrides;
-  /** Returns the current server snapshot for `useSyncExternalStore`. */
-  getServerSnapshot = () => this.overrides;
-  /** Subscribes to override changes and returns an unsubscribe callback. */
-  subscribe = (callback) => {
-    this.listeners.add(callback);
-    return () => {
-      this.listeners.delete(callback);
-    };
-  };
-  emit = () => {
-    for (const listener of Array.from(this.listeners)) {
-      try {
-        listener();
-      } catch (error) {
-        console.error("TranslationStore: Listener error", error);
-      }
-    }
-  };
+	/** Current flat translation overrides keyed by dot-path. */
+	overrides = {};
+	listeners = /* @__PURE__ */ new Set();
+	/** Replaces all overrides and notifies subscribers. */
+	setOverrides = (overrides) => {
+		this.overrides = { ...overrides };
+		this.emit();
+	};
+	/** Merges changed overrides and notifies subscribers. */
+	updateOverrides = (newOverrides) => {
+		this.overrides = {
+			...this.overrides,
+			...newOverrides
+		};
+		this.emit();
+	};
+	/** Returns the current client snapshot for `useSyncExternalStore`. */
+	getSnapshot = () => this.overrides;
+	/** Returns the current server snapshot for `useSyncExternalStore`. */
+	getServerSnapshot = () => this.overrides;
+	/** Subscribes to override changes and returns an unsubscribe callback. */
+	subscribe = (callback) => {
+		this.listeners.add(callback);
+		return () => {
+			this.listeners.delete(callback);
+		};
+	};
+	emit = () => {
+		for (const listener of Array.from(this.listeners)) try {
+			listener();
+		} catch (error) {
+			console.error("TranslationStore: Listener error", error);
+		}
+	};
 };
-var ThemeTextStore = TranslationStore;
-
-// src/utils/pick-weaverse-data.ts
+/**
+* Legacy constructor alias retained for existing theme text integrations.
+* @deprecated Use {@link TranslationStore} instead. This alias remains available
+* for backward compatibility.
+*/
+const ThemeTextStore = TranslationStore;
+//#endregion
+//#region src/utils/pick-weaverse-data.ts
+/**
+* Resolve the `weaverseData` payload for a `<WeaverseHydrogenRoot>` instance.
+*
+* Resolution order (first match wins):
+*
+*  1. **Explicit prop** — the caller passed `data` directly. Used as-is,
+*     including when it is a `Promise` (handled upstream via `<Await>`) or
+*     an explicit `null` (suppresses rendering).
+*  2. **Own route's loader data** — the loader data for the route that
+*     rendered this component, obtained via `useLoaderData()`. This is
+*     React Router's route-scoped primitive and is what makes nested
+*     layout + child Weaverse pages work: each `<WeaverseContent />`
+*     resolves to *its own* route's `weaverseData` regardless of siblings.
+*  3. **Ancestor match fallback** — walk `useMatches()` from leaf to root
+*     and return the first ancestor whose `loaderData` exposes a
+*     `weaverseData` key. This preserves the long-standing behaviour where
+*     a child route with no loader (e.g. an `index.tsx` that omits
+*     `weaverseData`) still renders its layout's Weaverse page.
+*
+* The helper is intentionally pure (no hook calls) so it can be unit-tested
+* without a React Router context. Hook calls happen in the component.
+*
+* ## Back-compat contract
+*
+* Themes that pre-date the `data` prop addition pass `dataProp === undefined`,
+* so resolution starts at Tier 2. For the canonical single-instance pattern
+* (one `<WeaverseContent />` inside a route whose loader returns
+* `{ weaverseData }`), Tier 2 returns the same value the old `useMatches()`
+* walk did. For the index-without-loader pattern (leaf route exposes no
+* `weaverseData`, layout does), Tier 3's leaf→root walk produces an
+* identical result to the pre-fix code. The only intentional behaviour
+* change is the issue #451 case: two `<WeaverseContent />` instances on the
+* same URL (layout + child, both with their own `weaverseData`) now each
+* render their own page instead of both rendering the deepest one.
+*/
 function pickWeaverseData(dataProp, ownLoaderData, matches) {
-  if (dataProp !== void 0) {
-    return dataProp;
-  }
-  if (hasWeaverseData(ownLoaderData)) {
-    return ownLoaderData.weaverseData;
-  }
-  for (let i = matches.length - 1; i >= 0; i--) {
-    const loaderData = matches[i].loaderData;
-    if (hasWeaverseData(loaderData)) {
-      return loaderData.weaverseData;
-    }
-  }
-  return null;
+	if (dataProp !== void 0) return dataProp;
+	if (hasWeaverseData(ownLoaderData)) return ownLoaderData.weaverseData;
+	for (let i = matches.length - 1; i >= 0; i--) {
+		const loaderData = matches[i].loaderData;
+		if (hasWeaverseData(loaderData)) return loaderData.weaverseData;
+	}
+	return null;
 }
 function hasWeaverseData(value) {
-  if (typeof value !== "object" || value === null || !("weaverseData" in value)) {
-    return false;
-  }
-  return value.weaverseData !== void 0;
+	if (typeof value !== "object" || value === null || !("weaverseData" in value)) return false;
+	return value.weaverseData !== void 0;
 }
-
-// src/utils/studio-request-info.ts
+//#endregion
+//#region src/utils/studio-request-info.ts
 function getBrowserLocation() {
-  if (typeof window === "undefined") {
-    return;
-  }
-  return window.location;
+	if (typeof window === "undefined") return;
+	return window.location;
 }
 function getQueriesFromSearch(search) {
-  let queries = {};
-  let params = new URLSearchParams(search);
-  for (let [key, value] of params.entries()) {
-    if (value === "true") {
-      queries[key] = true;
-    } else if (value === "false") {
-      queries[key] = false;
-    } else {
-      queries[key] = value;
-    }
-  }
-  return queries;
+	let queries = {};
+	let params = new URLSearchParams(search);
+	for (let [key, value] of params.entries()) if (value === "true") queries[key] = true;
+	else if (value === "false") queries[key] = false;
+	else queries[key] = value;
+	return queries;
 }
+/**
+* React Router v7 single-fetch revalidation can render client data returned
+* from a `*.data` request while the browser is still on the canonical URL.
+* Instance identity must follow the browser URL, not the transient data
+* endpoint, otherwise the SDK creates a fresh Weaverse instance mid-session:
+* in design mode that drops the existing Studio bridge/interactions, and in
+* the live theme it resets every section's runtime state after any
+* revalidation (cart mutations, locale switches, `revalidate()`). See #451.
+*/
 function normalizeRequestInfo(params, browserLocation = getBrowserLocation()) {
-  if (!browserLocation) {
-    return params;
-  }
-  let { pathname, search } = browserLocation;
-  if (params.requestInfo.pathname === pathname && params.requestInfo.search === search) {
-    return params;
-  }
-  return {
-    ...params,
-    requestInfo: {
-      ...params.requestInfo,
-      pathname,
-      queries: getQueriesFromSearch(search),
-      search
-    }
-  };
+	if (!browserLocation) return params;
+	let { pathname, search } = browserLocation;
+	if (params.requestInfo.pathname === pathname && params.requestInfo.search === search) return params;
+	return {
+		...params,
+		requestInfo: {
+			...params.requestInfo,
+			pathname,
+			queries: getQueriesFromSearch(search),
+			search
+		}
+	};
 }
-
-// src/utils/is-same-loader-payload.ts
+//#endregion
+//#region src/utils/is-same-loader-payload.ts
+/**
+* Structural comparison used to detect whether a reused Weaverse instance
+* must adopt a fresh loader payload.
+*
+* `JSON.stringify` cannot do this job on the client:
+*
+* - Route loader data reaches `dataContext` unserialized, so deferred values
+*   are still `Promise`s. React 19 development builds hang an enumerable,
+*   self-referencing `_debugInfo` off those promises, and stringifying one
+*   throws `TypeError: Converting circular structure to JSON` during render
+*   (issue #511).
+* - In production every promise stringifies to `{}`, so a *fresh* deferred
+*   value looks unchanged and the reused instance keeps serving the previous
+*   render's promise. Tokenizing promises to a constant (`'[[promise]]'`) has
+*   the same defect — it is stable by construction, therefore blind to
+*   identity.
+*
+* Semantics, chosen deliberately:
+*
+* - **Promises/thenables are atomic**: compared by identity, never traversed.
+*   A fresh promise is a change; the same promise is not. Debug metadata is
+*   invisible to the comparison.
+* - **Opaque objects are atomic**: anything that is not a plain object, an
+*   array, or `toJSON`-serializable (`Map`, `Set`, `URL`, `RegExp`, streams,
+*   async iterators, cross-realm promises, class instances) is compared by
+*   identity. `JSON.stringify` flattens all of them to `{}`, which would
+*   silently collapse two distinct async values into "unchanged".
+* - **Cyclic graphs are compared coinductively**: a pair already being
+*   compared is assumed equal, so equal self/mutual cycles are equal while a
+*   differing leaf anywhere still reports a change. Nothing throws.
+* - **JSON-visible fields only**: `undefined`/function/symbol properties are
+*   omitted from objects and read as `null` in arrays, and NaN/±Infinity read
+*   as `null` — matching the previous `JSON.stringify` behavior for plain wire
+*   payloads. Key order is irrelevant, which removes the old "false mismatch
+*   costs a re-render" caveat.
+*/
+/** `JSON.stringify` drops these from objects and nulls them inside arrays. */
 function isJsonOmitted(value) {
-  return value === void 0 || typeof value === "function" || typeof value === "symbol";
+	return value === void 0 || typeof value === "function" || typeof value === "symbol";
 }
 function isObjectLike(value) {
-  return value !== null && typeof value === "object";
+	return value !== null && typeof value === "object";
 }
+/** Duck-typed so cross-realm promises and hand-rolled thenables also match. */
 function isThenable(value) {
-  return typeof value.then === "function";
+	return typeof value.then === "function";
 }
-function isPlainObject(value) {
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
+function isPlainObject$1(value) {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
 }
+/** Returns the `toJSON()` projection, or the value itself when there is none. */
 function toJsonValue(value) {
-  return typeof value.toJSON === "function" ? value.toJSON() : value;
+	return typeof value.toJSON === "function" ? value.toJSON() : value;
 }
+/** Maps NaN/±Infinity to `null`, matching how `JSON.stringify` renders them. */
 function toFiniteOrNull(value) {
-  return typeof value === "number" && !Number.isFinite(value) ? null : value;
+	return typeof value === "number" && !Number.isFinite(value) ? null : value;
 }
+/** Compares two loader payloads for JSON-visible structural equality. */
 function isSameLoaderPayload(left, right) {
-  const activePairs = [];
-  function isSame(rawA, rawB) {
-    if (Object.is(rawA, rawB)) {
-      return true;
-    }
-    const a = toFiniteOrNull(rawA);
-    const b = toFiniteOrNull(rawB);
-    if (a === b) {
-      return true;
-    }
-    if (!(isObjectLike(a) && isObjectLike(b))) {
-      return false;
-    }
-    if (isThenable(a) || isThenable(b)) {
-      return false;
-    }
-    for (let index = 0; index < activePairs.length; index += 2) {
-      if (activePairs[index] === a && activePairs[index + 1] === b) {
-        return true;
-      }
-    }
-    activePairs.push(a, b);
-    try {
-      return isSameOpenPair(a, b);
-    } finally {
-      activePairs.length -= 2;
-    }
-  }
-  function isSameOpenPair(a, b) {
-    const aJson = toJsonValue(a);
-    const bJson = toJsonValue(b);
-    if (aJson !== a || bJson !== b) {
-      return isSame(aJson, bJson);
-    }
-    if (Array.isArray(a) !== Array.isArray(b)) {
-      return false;
-    }
-    if (Array.isArray(a) && Array.isArray(b)) {
-      return isSameArray(a, b);
-    }
-    if (!(isPlainObject(a) && isPlainObject(b))) {
-      return false;
-    }
-    return isSameObject(a, b);
-  }
-  function isSameArray(a, b) {
-    if (a.length !== b.length) {
-      return false;
-    }
-    for (let index = 0; index < a.length; index++) {
-      const aItem = isJsonOmitted(a[index]) ? null : a[index];
-      const bItem = isJsonOmitted(b[index]) ? null : b[index];
-      if (!isSame(aItem, bItem)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  function isSameObject(a, b) {
-    let aKeyCount = 0;
-    for (const key of Object.keys(a)) {
-      if (isJsonOmitted(a[key])) {
-        continue;
-      }
-      aKeyCount++;
-      if (!isSame(a[key], b[key])) {
-        return false;
-      }
-    }
-    let bKeyCount = 0;
-    for (const key of Object.keys(b)) {
-      if (!isJsonOmitted(b[key])) {
-        bKeyCount++;
-      }
-    }
-    return aKeyCount === bKeyCount;
-  }
-  return isSame(left, right);
+	const activePairs = [];
+	function isSame(rawA, rawB) {
+		if (Object.is(rawA, rawB)) return true;
+		const a = toFiniteOrNull(rawA);
+		const b = toFiniteOrNull(rawB);
+		if (a === b) return true;
+		if (!(isObjectLike(a) && isObjectLike(b))) return false;
+		if (isThenable(a) || isThenable(b)) return false;
+		for (let index = 0; index < activePairs.length; index += 2) if (activePairs[index] === a && activePairs[index + 1] === b) return true;
+		activePairs.push(a, b);
+		try {
+			return isSameOpenPair(a, b);
+		} finally {
+			activePairs.length -= 2;
+		}
+	}
+	function isSameOpenPair(a, b) {
+		const aJson = toJsonValue(a);
+		const bJson = toJsonValue(b);
+		if (aJson !== a || bJson !== b) return isSame(aJson, bJson);
+		if (Array.isArray(a) !== Array.isArray(b)) return false;
+		if (Array.isArray(a) && Array.isArray(b)) return isSameArray(a, b);
+		if (!(isPlainObject$1(a) && isPlainObject$1(b))) return false;
+		return isSameObject(a, b);
+	}
+	function isSameArray(a, b) {
+		if (a.length !== b.length) return false;
+		for (let index = 0; index < a.length; index++) if (!isSame(isJsonOmitted(a[index]) ? null : a[index], isJsonOmitted(b[index]) ? null : b[index])) return false;
+		return true;
+	}
+	function isSameObject(a, b) {
+		let aKeyCount = 0;
+		for (const key of Object.keys(a)) {
+			if (isJsonOmitted(a[key])) continue;
+			aKeyCount++;
+			if (!isSame(a[key], b[key])) return false;
+		}
+		let bKeyCount = 0;
+		for (const key of Object.keys(b)) if (!isJsonOmitted(b[key])) bKeyCount++;
+		return aKeyCount === bKeyCount;
+	}
+	return isSame(left, right);
 }
-
-// src/utils/sync-reused-instance.ts
+//#endregion
+//#region src/utils/sync-reused-instance.ts
+/**
+* Apply a fresh loader payload to a reused Weaverse instance.
+*
+* With requestInfo normalized to the browser URL, same-URL revalidations
+* (cart mutations, `useRevalidator()`, locale-neutral re-fetches) reuse the
+* cached `window.__weaverses[pageId]` instance instead of constructing a new
+* one — which preserves section state, but would silently drop the fresh
+* `data`/`dataContext` the loaders just returned. Sync them here.
+*
+* Design mode is excluded by the caller: Studio owns the instance data there
+* (unsaved drafts must not be clobbered) and applies updates via
+* `refreshStudio` instead.
+*
+* Change detection uses {@link isSameLoaderPayload}: a structural comparison
+* that treats promises/thenables and other opaque objects as atomic values
+* compared by identity, and tolerates cyclic graphs. `dataContext` carries
+* live route loader data — including unresolved deferred promises whose React
+* development metadata is cyclic — so it cannot be JSON-serialized here.
+*/
 function syncReusedInstance(weaverse, params) {
-  weaverse.requestInfo = params.requestInfo;
-  weaverse.internal = params.internal;
-  let dataChanged = !isSameLoaderPayload(weaverse.data, params.data);
-  let contextChanged = !isSameLoaderPayload(
-    weaverse.dataContext ?? null,
-    params.dataContext ?? null
-  );
-  if (contextChanged) {
-    weaverse.dataContext = params.dataContext ?? null;
-  }
-  if (dataChanged) {
-    weaverse.setProjectData(params.data);
-  } else if (contextChanged) {
-    for (const { id } of params.data?.items || []) {
-      weaverse.itemInstances.get(id)?.setData({});
-    }
-  }
-  if (dataChanged || contextChanged) {
-    weaverse.triggerUpdate();
-  }
+	weaverse.requestInfo = params.requestInfo;
+	weaverse.internal = params.internal;
+	let dataChanged = !isSameLoaderPayload(weaverse.data, params.data);
+	let contextChanged = !isSameLoaderPayload(weaverse.dataContext ?? null, params.dataContext ?? null);
+	if (contextChanged) weaverse.dataContext = params.dataContext ?? null;
+	if (dataChanged) weaverse.setProjectData(params.data);
+	else if (contextChanged) for (const { id } of params.data?.items || []) weaverse.itemInstances.get(id)?.setData({});
+	if (dataChanged || contextChanged) weaverse.triggerUpdate();
 }
+//#endregion
+//#region src/utils/use-theme-settings-store.ts
+/** Mutable, subscribable store for theme settings received from the root loader. */
 var ThemeSettingsStore = class {
-  /** Current merged theme setting values. */
-  settings = {};
-  /** Theme schema exposed to Studio, when available. */
-  schema;
-  /** Storefront-safe environment values, when available. */
-  publicEnv;
-  listeners = /* @__PURE__ */ new Set();
-  hasWarnedListenerCount = false;
-  isDestroyed = false;
-  /** Creates a theme settings store from root-loader theme data. */
-  constructor(data) {
-    const { theme, schema: schema2, publicEnv } = data || {};
-    this.settings = { ...theme };
-    this.schema = schema2;
-    this.publicEnv = publicEnv;
-    if (react.isBrowser) {
-      window.__weaverseThemeSettingsStore = this;
-    }
-  }
-  /** Merges setting changes into the current snapshot and notifies subscribers. */
-  updateThemeSettings = (newSettings) => {
-    if (this.isDestroyed) {
-      console.warn("ThemeSettingsStore: Cannot update destroyed store");
-      return;
-    }
-    this.settings = {
-      ...this.settings,
-      ...newSettings
-    };
-    this.emit();
-  };
-  /** Returns the current client snapshot for `useSyncExternalStore`. */
-  getSnapshot = () => this.settings;
-  /** Returns the current server snapshot for `useSyncExternalStore`. */
-  getServerSnapshot = () => this.settings;
-  /** Subscribes to setting changes and returns an unsubscribe callback. */
-  subscribe = (callback) => {
-    if (this.isDestroyed) {
-      console.warn("ThemeSettingsStore: Cannot subscribe to destroyed store");
-      return () => {
-      };
-    }
-    this.listeners.add(callback);
-    if (!this.hasWarnedListenerCount && this.listeners.size > 500) {
-      this.hasWarnedListenerCount = true;
-      console.warn(
-        `ThemeSettingsStore: ${this.listeners.size} listeners detected. This may indicate a performance issue. Consider using fewer useThemeSettings() calls.`
-      );
-    }
-    return () => {
-      this.listeners.delete(callback);
-    };
-  };
-  emit = () => {
-    if (this.isDestroyed) {
-      return;
-    }
-    const currentListeners = Array.from(this.listeners);
-    for (const listener of currentListeners) {
-      try {
-        listener();
-      } catch (error) {
-        console.error("ThemeSettingsStore: Listener error", error);
-      }
-    }
-  };
-  /** Clears subscribers and detaches the browser-global store reference. */
-  destroy = () => {
-    if (this.isDestroyed) {
-      return;
-    }
-    this.listeners.clear();
-    this.isDestroyed = true;
-    if (react.isBrowser && window.__weaverseThemeSettingsStore === this) {
-      window.__weaverseThemeSettingsStore = void 0;
-    }
-  };
+	/** Current merged theme setting values. */
+	settings = {};
+	/** Theme schema exposed to Studio, when available. */
+	schema;
+	/** Storefront-safe environment values, when available. */
+	publicEnv;
+	listeners = /* @__PURE__ */ new Set();
+	hasWarnedListenerCount = false;
+	isDestroyed = false;
+	/** Creates a theme settings store from root-loader theme data. */
+	constructor(data) {
+		const { theme, schema, publicEnv } = data || {};
+		this.settings = { ...theme };
+		this.schema = schema;
+		this.publicEnv = publicEnv;
+		if (_weaverse_react.isBrowser) window.__weaverseThemeSettingsStore = this;
+	}
+	/** Merges setting changes into the current snapshot and notifies subscribers. */
+	updateThemeSettings = (newSettings) => {
+		if (this.isDestroyed) {
+			console.warn("ThemeSettingsStore: Cannot update destroyed store");
+			return;
+		}
+		this.settings = {
+			...this.settings,
+			...newSettings
+		};
+		this.emit();
+	};
+	/** Returns the current client snapshot for `useSyncExternalStore`. */
+	getSnapshot = () => this.settings;
+	/** Returns the current server snapshot for `useSyncExternalStore`. */
+	getServerSnapshot = () => this.settings;
+	/** Subscribes to setting changes and returns an unsubscribe callback. */
+	subscribe = (callback) => {
+		if (this.isDestroyed) {
+			console.warn("ThemeSettingsStore: Cannot subscribe to destroyed store");
+			return () => {};
+		}
+		this.listeners.add(callback);
+		if (!this.hasWarnedListenerCount && this.listeners.size > 500) {
+			this.hasWarnedListenerCount = true;
+			console.warn(`ThemeSettingsStore: ${this.listeners.size} listeners detected. This may indicate a performance issue. Consider using fewer useThemeSettings() calls.`);
+		}
+		return () => {
+			this.listeners.delete(callback);
+		};
+	};
+	emit = () => {
+		if (this.isDestroyed) return;
+		const currentListeners = Array.from(this.listeners);
+		for (const listener of currentListeners) try {
+			listener();
+		} catch (error) {
+			console.error("ThemeSettingsStore: Listener error", error);
+		}
+	};
+	/** Clears subscribers and detaches the browser-global store reference. */
+	destroy = () => {
+		if (this.isDestroyed) return;
+		this.listeners.clear();
+		this.isDestroyed = true;
+		if (_weaverse_react.isBrowser && window.__weaverseThemeSettingsStore === this) window.__weaverseThemeSettingsStore = void 0;
+	};
 };
-var ThemeSettingsStoreContext = react$1.createContext(null);
+const ThemeSettingsStoreContext = (0, react.createContext)(null);
 ThemeSettingsStoreContext.displayName = "ThemeSettingsStoreContext";
 function useCreateThemeSettingsStore() {
-  const data = reactRouter.useRouteLoaderData("root");
-  const storeRef = react$1.useRef(null);
-  if (!storeRef.current) {
-    storeRef.current = new ThemeSettingsStore(data?.weaverseTheme);
-  }
-  const theme = data?.weaverseTheme?.theme;
-  react$1.useEffect(() => {
-    if (storeRef.current && theme) {
-      storeRef.current.updateThemeSettings(theme);
-    }
-  }, [theme]);
-  return storeRef.current;
+	const data = (0, react_router.useRouteLoaderData)("root");
+	const storeRef = (0, react.useRef)(null);
+	if (!storeRef.current) storeRef.current = new ThemeSettingsStore(data?.weaverseTheme);
+	const theme = data?.weaverseTheme?.theme;
+	(0, react.useEffect)(() => {
+		if (storeRef.current && theme) storeRef.current.updateThemeSettings(theme);
+	}, [theme]);
+	return storeRef.current;
 }
 function useThemeSettingsStore() {
-  const fromContext = react$1.useContext(ThemeSettingsStoreContext);
-  const data = reactRouter.useRouteLoaderData("root");
-  const fallbackRef = react$1.useRef(null);
-  if (!(fallbackRef.current || fromContext)) {
-    fallbackRef.current = new ThemeSettingsStore(data?.weaverseTheme);
-  }
-  const store = fromContext ?? fallbackRef.current;
-  const theme = data?.weaverseTheme?.theme;
-  react$1.useEffect(() => {
-    if (!fromContext && theme) {
-      store.updateThemeSettings(theme);
-    }
-  }, [fromContext, store, theme]);
-  return store;
+	const fromContext = (0, react.useContext)(ThemeSettingsStoreContext);
+	const data = (0, react_router.useRouteLoaderData)("root");
+	const fallbackRef = (0, react.useRef)(null);
+	if (!(fallbackRef.current || fromContext)) fallbackRef.current = new ThemeSettingsStore(data?.weaverseTheme);
+	const store = fromContext ?? fallbackRef.current;
+	const theme = data?.weaverseTheme?.theme;
+	(0, react.useEffect)(() => {
+		if (!fromContext && theme) store.updateThemeSettings(theme);
+	}, [
+		fromContext,
+		store,
+		theme
+	]);
+	return store;
 }
-
-// src/utils/use-studio.ts
-var STUDIO_READY_POLL_MS = 50;
-var STUDIO_READY_TIMEOUT_MS = 5e3;
+//#endregion
+//#region src/utils/use-studio.ts
+const STUDIO_READY_POLL_MS = 50;
+const STUDIO_READY_TIMEOUT_MS = 5e3;
+/**
+* Resolve once `window.weaverseStudio` is available, or `null` on timeout.
+* The studio script sets the global when it *executes*; `loadScript` can
+* resolve earlier for tags it did not create (e.g. SSR-injected markup),
+* so never assume readiness right after the script promise settles.
+*/
 function waitForStudio() {
-  return new Promise((resolve) => {
-    let startedAt = Date.now();
-    function check() {
-      if (hasWeaverseStudio(window)) {
-        return resolve(window.weaverseStudio);
-      }
-      if (Date.now() - startedAt >= STUDIO_READY_TIMEOUT_MS) {
-        console.warn("[Weaverse] Studio script did not initialize in time");
-        return resolve(null);
-      }
-      setTimeout(check, STUDIO_READY_POLL_MS);
-    }
-    check();
-  });
+	return new Promise((resolve) => {
+		let startedAt = Date.now();
+		function check() {
+			if (hasWeaverseStudio(window)) return resolve(window.weaverseStudio);
+			if (Date.now() - startedAt >= STUDIO_READY_TIMEOUT_MS) {
+				console.warn("[Weaverse] Studio script did not initialize in time");
+				return resolve(null);
+			}
+			setTimeout(check, STUDIO_READY_POLL_MS);
+		}
+		check();
+	});
 }
+/**
+* Load the Studio bridge script on every design/preview render so Studio's
+* `checkWeaversePage()` handshake is answered instead of timing out — crucially
+* on routes where the page-scoped {@link useStudio} never mounts: 404s, error
+* boundaries, and non-Weaverse routes. The bridge registers its RPC endpoint
+* and `window.weaverseStudio` the moment the script executes, independent of any
+* page binding. Without this, a content-less route never loads the script and
+* Studio reports a false "Connection lost" instead of "this page has no Weaverse
+* content set up".
+*
+* `loadScript` is idempotent, so on content routes this coexists with the
+* page-scoped {@link useStudio} (same src) — that hook still binds the page via
+* `init`. Gating this on whether a route "has Weaverse data" is deliberately
+* avoided: route matches can't tell whether the page-scoped bridge actually
+* mounts (an `ErrorBoundary` replacing a data route, or data passed via the
+* `data` prop), and suppressing the script there would reintroduce the timeout
+* this fixes. Loading the script is harmless; it only registers the responder.
+*
+* Known limitation: on a route whose `weaverseData` is a deferred Promise, the
+* script can load before the page streams in, so `checkWeaversePage()` may
+* briefly observe `NOT_WEAVERSE_PAGE`. The complete fix is a "loading" state in
+* `checkWeaversePage` so the handshake retries rather than latching — that lives
+* in the Studio script, not here. Tracked in Weaverse/builder#2515.
+*
+* Mounted via {@link withWeaverse}, which must be the root route's `Layout`
+* export so the bridge renders even when a route's `ErrorBoundary` replaces the
+* page. Outside Studio (no design/preview params) it is a no-op.
+*/
 function useStudioConnect() {
-  let { search } = reactRouter.useLocation();
-  react$1.useEffect(() => {
-    let hostname = typeof window === "undefined" ? "" : window.location.hostname;
-    let src = resolveStudioScriptSrc(search, hostname);
-    if (src) {
-      react.loadScript(src).catch(console.error);
-    }
-  }, [search]);
+	let { search } = (0, react_router.useLocation)();
+	(0, react.useEffect)(() => {
+		let src = resolveStudioScriptSrc(search, typeof window === "undefined" ? "" : window.location.hostname);
+		if (src) (0, _weaverse_react.loadScript)(src).catch(console.error);
+	}, [search]);
 }
 function useStudio(weaverse) {
-  let { revalidate } = reactRouter.useRevalidator();
-  let navigation = reactRouter.useNavigation();
-  let { pathname, search } = reactRouter.useLocation();
-  let navigate = reactRouter.useNavigate();
-  let themeSettingsStore = useThemeSettingsStore();
-  let { translationStore, themeTextStore, merchantOverrides } = useTranslation();
-  let {
-    isDesignMode,
-    weaverseHost,
-    weaverseVersion,
-    isPreviewMode,
-    isRevisionPreview
-  } = weaverse;
-  react$1.useEffect(() => {
-    if (navigation.state !== "idle") {
-      return;
-    }
-    let src = getStudioScriptSrc({
-      isDesignMode,
-      isPreviewMode,
-      isRevisionPreview,
-      weaverseHost,
-      weaverseVersion
-    });
-    if (!src) {
-      return;
-    }
-    if (isRevisionPreview || isPreviewMode) {
-      react.loadScript(src).catch(console.error);
-    } else {
-      weaverse.internal = {
-        ...weaverse.internal,
-        navigate,
-        revalidate,
-        merchantOverrides,
-        themeSettingsStore,
-        translationStore,
-        // Deprecated alias for existing Studio bridge integrations.
-        themeTextStore
-      };
-      react.loadScript(src).then(waitForStudio).then((studio) => studio?.init(weaverse)).catch(console.error);
-    }
-  }, [pathname, search, navigation.state]);
+	let { revalidate } = (0, react_router.useRevalidator)();
+	let navigation = (0, react_router.useNavigation)();
+	let { pathname, search } = (0, react_router.useLocation)();
+	let navigate = (0, react_router.useNavigate)();
+	let themeSettingsStore = useThemeSettingsStore();
+	let { translationStore, themeTextStore, merchantOverrides } = useTranslation();
+	let { isDesignMode, weaverseHost, weaverseVersion, isPreviewMode, isRevisionPreview } = weaverse;
+	(0, react.useEffect)(() => {
+		if (navigation.state !== "idle") return;
+		let src = getStudioScriptSrc({
+			isDesignMode,
+			isPreviewMode,
+			isRevisionPreview,
+			weaverseHost,
+			weaverseVersion
+		});
+		if (!src) return;
+		if (isRevisionPreview || isPreviewMode) (0, _weaverse_react.loadScript)(src).catch(console.error);
+		else {
+			weaverse.internal = {
+				...weaverse.internal,
+				navigate,
+				revalidate,
+				merchantOverrides,
+				themeSettingsStore,
+				translationStore,
+				themeTextStore
+			};
+			(0, _weaverse_react.loadScript)(src).then(waitForStudio).then((studio) => studio?.init(weaverse)).catch(console.error);
+		}
+	}, [
+		pathname,
+		search,
+		navigation.state
+	]);
 }
-var WeaverseHydrogenItem = class extends react.WeaverseItemStore {
-  /**
-   * Cached merged snapshot (base + translations).
-   * Reset to `null` whenever `_store` or the item's translation entry changes.
-   */
-  _cachedSnapshot = null;
-  _snapshotStoreRef = null;
-  _snapshotTranslationRef = null;
-  /** Creates an item store from serialized component data and its owner. */
-  constructor(initialData, weaverse) {
-    super(initialData, weaverse);
-    const { data, ...rest } = initialData;
-    if (!this.Element?.schema) {
-      console.error("Element is missing schema or not found!");
-      return;
-    }
-    const schemaData = generateDataFromSchema(this.Element.schema);
-    Object.assign(this._store, schemaData, data, rest);
-  }
-  /** Registered component definition for this item's type. */
-  get Element() {
-    return super.Element;
-  }
-  /**
-   * Override setData to flatten serialized `data` the same way the constructor
-   * does. Core's `initProject()` reuses item stores keyed by item id (identical
-   * ids across locales), and the inherited setData only shallow-merges the raw
-   * item — fresh settings would land under `_store.data` while the stale
-   * flattened values keep rendering.
-   *
-   * Schema defaults are re-applied ahead of incoming settings because a
-   * serialized payload can omit fields — or the optional `data` object itself —
-   * when values equal schema defaults. The stored nested `data` is also replaced
-   * so the public serialized state does not retain the previous locale payload.
-   *
-   * An empty update is the context-only refresh from `syncReusedInstance`: swap
-   * the store reference so memoized subscribers re-render, and leave the
-   * settings untouched.
-   */
-  setData = (update) => {
-    let source = update ?? {};
-    let { data, ...rest } = source;
-    let isEmptyUpdate = Object.keys(source).length === 0;
-    if (isEmptyUpdate) {
-      this._store = { ...this._store };
-    } else {
-      let type = source.type ?? this._store.type;
-      let schema2 = this.weaverse.elementRegistry.get(type)?.schema;
-      let isSerializedItem = "id" in source && "type" in source;
-      let shouldNormalize = data !== void 0 || isSerializedItem;
-      if (schema2 && shouldNormalize) {
-        let { data: _previousData, ...store } = this._store;
-        let schemaData = generateDataFromSchema(schema2);
-        this._store = {
-          ...store,
-          ...data === void 0 ? {} : { data },
-          ...schemaData,
-          ...data,
-          ...rest
-        };
-      } else {
-        this._store = { ...this._store, ...source };
-      }
-    }
-    this.triggerUpdate();
-    return this.data;
-  };
-  /**
-   * Override getSnapShot to merge translation data when in translation mode.
-   * Memoizes the result: returns the same object reference as long as
-   * both `_store` and the translation entry haven't changed.
-   * This is critical for `useSyncExternalStore` stability.
-   */
-  getSnapShot = () => {
-    const base = this._store;
-    const translations = this.weaverse.translationMap?.[this._id];
-    if (!translations) {
-      return base;
-    }
-    if (this._cachedSnapshot && this._snapshotStoreRef === base && this._snapshotTranslationRef === translations) {
-      return this._cachedSnapshot;
-    }
-    const merged = { ...base };
-    for (const [key, entry] of Object.entries(translations)) {
-      if (entry.translatedValue !== void 0) {
-        merged[key] = entry.translatedValue;
-      }
-    }
-    this._cachedSnapshot = merged;
-    this._snapshotStoreRef = base;
-    this._snapshotTranslationRef = translations;
-    return merged;
-  };
+//#endregion
+//#region src/WeaverseHydrogenRoot.tsx
+/** Runtime store for one rendered Hydrogen component instance. */
+var WeaverseHydrogenItem = class extends _weaverse_react.WeaverseItemStore {
+	/**
+	* Cached merged snapshot (base + translations).
+	* Reset to `null` whenever `_store` or the item's translation entry changes.
+	*/
+	_cachedSnapshot = null;
+	_snapshotStoreRef = null;
+	_snapshotTranslationRef = null;
+	/** Creates an item store from serialized component data and its owner. */
+	constructor(initialData, weaverse) {
+		super(initialData, weaverse);
+		const { data, ...rest } = initialData;
+		if (!this.Element?.schema) {
+			console.error("Element is missing schema or not found!");
+			return;
+		}
+		const schemaData = generateDataFromSchema(this.Element.schema);
+		Object.assign(this._store, schemaData, data, rest);
+	}
+	/** Registered component definition for this item's type. */
+	get Element() {
+		return super.Element;
+	}
+	/**
+	* Override setData to flatten serialized `data` the same way the constructor
+	* does. Core's `initProject()` reuses item stores keyed by item id (identical
+	* ids across locales), and the inherited setData only shallow-merges the raw
+	* item — fresh settings would land under `_store.data` while the stale
+	* flattened values keep rendering.
+	*
+	* Schema defaults are re-applied ahead of incoming settings because a
+	* serialized payload can omit fields — or the optional `data` object itself —
+	* when values equal schema defaults. The stored nested `data` is also replaced
+	* so the public serialized state does not retain the previous locale payload.
+	*
+	* An empty update is the context-only refresh from `syncReusedInstance`: swap
+	* the store reference so memoized subscribers re-render, and leave the
+	* settings untouched.
+	*/
+	setData = (update) => {
+		let source = update ?? {};
+		let { data, ...rest } = source;
+		if (Object.keys(source).length === 0) this._store = { ...this._store };
+		else {
+			let type = source.type ?? this._store.type;
+			let schema = this.weaverse.elementRegistry.get(type)?.schema;
+			let isSerializedItem = "id" in source && "type" in source;
+			if (schema && (data !== void 0 || isSerializedItem)) {
+				let { data: _previousData, ...store } = this._store;
+				let schemaData = generateDataFromSchema(schema);
+				this._store = {
+					...store,
+					...data === void 0 ? {} : { data },
+					...schemaData,
+					...data,
+					...rest
+				};
+			} else this._store = {
+				...this._store,
+				...source
+			};
+		}
+		this.triggerUpdate();
+		return this.data;
+	};
+	/**
+	* Override getSnapShot to merge translation data when in translation mode.
+	* Memoizes the result: returns the same object reference as long as
+	* both `_store` and the translation entry haven't changed.
+	* This is critical for `useSyncExternalStore` stability.
+	*/
+	getSnapShot = () => {
+		const base = this._store;
+		const translations = this.weaverse.translationMap?.[this._id];
+		if (!translations) return base;
+		if (this._cachedSnapshot && this._snapshotStoreRef === base && this._snapshotTranslationRef === translations) return this._cachedSnapshot;
+		const merged = { ...base };
+		for (const [key, entry] of Object.entries(translations)) if (entry.translatedValue !== void 0) merged[key] = entry.translatedValue;
+		this._cachedSnapshot = merged;
+		this._snapshotStoreRef = base;
+		this._snapshotTranslationRef = translations;
+		return merged;
+	};
 };
-react.Weaverse.ItemConstructor = WeaverseHydrogenItem;
-var WeaverseHydrogen = class extends react.Weaverse {
-  /** Identifier of the rendered page. */
-  pageId;
-  /** Runtime services and project metadata exposed to integrations. */
-  internal;
-  /** Normalized URL and locale information for the current request. */
-  requestInfo;
-  /** Identifier of the project supplying the page. */
-  projectId;
-  /** Origin used for Studio assets and editor communication. */
-  weaverseHost;
-  /** Base URL used for public content API requests. */
-  weaverseApiBase;
-  /**
-   * API key read from environment/configuration for storefront requests or
-   * supplied by Studio requests while editing and previewing.
-   */
-  weaverseApiKey;
-  /** Studio asset version supplied by the preview request. */
-  weaverseVersion;
-  /** Whether the page is running inside the visual editor. */
-  isDesignMode;
-  /** Whether a single component preview is being rendered. */
-  isPreviewMode;
-  /** Whether a saved page revision is being previewed. */
-  isRevisionPreview;
-  /** Component type requested by section preview mode. */
-  sectionType;
-  // ─── Translation sidecar (design mode only) ────────────────────────
-  /**
-   * Translation map received from the builder in design mode.
-   * Keyed by item ID, each entry maps field names to translated values.
-   * `WeaverseHydrogenItem.getSnapShot()` merges these into the data
-   * returned to components, so translations render without monkey-patching.
-   */
-  translationMap = {};
-  /** Locale code for the active translation sidecar. */
-  translationLocale = "";
-  /** Builder language identifier for the active translation sidecar. */
-  translationLanguageId = "";
-  /** Creates a page runtime from resolved loader data and request settings. */
-  constructor(params) {
-    const { internal, pageId, requestInfo, ...coreParams } = params;
-    super({ ...coreParams });
-    this.internal = internal;
-    this.pageId = pageId;
-    this.requestInfo = requestInfo;
-    this.projectId = params.projectId;
-    this.weaverseHost = params.weaverseHost;
-    this.weaverseApiBase = params.weaverseApiBase;
-    this.weaverseApiKey = params.weaverseApiKey;
-    this.weaverseVersion = params.weaverseVersion || "";
-    this.isDesignMode = params.isDesignMode ?? false;
-    this.isPreviewMode = params.isPreviewMode ?? false;
-    this.isRevisionPreview = params.isRevisionPreview ?? false;
-    this.sectionType = params.sectionType || "";
-    this.extractTranslationSidecar();
-  }
-  /**
-   * Extract translation sidecar data from `this.data` (the page data).
-   * The builder attaches `translationMap`, `translationLocale`, and
-   * `translationLanguageId` to the page data in design mode.
-   */
-  extractTranslationSidecar = () => {
-    const pageData = this.data;
-    if (pageData?.translationMap) {
-      this.translationMap = pageData.translationMap;
-      this.translationLocale = pageData.translationLocale || "";
-      this.translationLanguageId = pageData.translationLanguageId || "";
-    }
-  };
-  /**
-   * Set the translation sidecar data.
-   * Called by the studio bridge when translation data arrives or changes.
-   * Triggers a re-render of all items so translated snapshots are recalculated.
-   */
-  setTranslationSidecar = (translationMap, locale, languageId) => {
-    this.translationMap = translationMap;
-    this.translationLocale = locale;
-    this.translationLanguageId = languageId;
-    this.refreshAllItems();
-  };
-  /**
-   * Update a single translation entry for a specific item field.
-   * Used by the studio bridge when the user edits a translatable field.
-   */
-  updateTranslation = (itemId, key, originalValue, translatedValue) => {
-    if (!this.translationMap[itemId]) {
-      this.translationMap[itemId] = {};
-    }
-    this.translationMap[itemId] = {
-      ...this.translationMap[itemId],
-      [key]: { originalValue, translatedValue }
-    };
-    const instance = this.itemInstances.get(itemId);
-    if (instance) {
-      instance.triggerUpdate();
-    }
-  };
-  /**
-   * Collect all translation changes across all weaverse instances.
-   * Used by the save flow to persist translation edits.
-   */
-  getTranslationChanges = () => {
-    const entries = [];
-    const languageId = this.translationLanguageId;
-    if (!(this.translationLocale && languageId)) {
-      return;
-    }
-    for (const [itemId, fields] of Object.entries(this.translationMap)) {
-      for (const [key, entry] of Object.entries(fields)) {
-        entries.push({
-          itemId,
-          key: `data.${key}`,
-          originalValue: entry.originalValue,
-          translatedValue: entry.translatedValue
-        });
-      }
-    }
-    if (entries.length === 0) {
-      return;
-    }
-    return { languageId, entries };
-  };
-  /**
-   * Override setProjectData to re-extract translation sidecar from new page data.
-   */
-  setProjectData = (data) => {
-    this.data = data;
-    this.extractTranslationSidecar();
-    this.initProject();
-  };
+_weaverse_react.Weaverse.ItemConstructor = WeaverseHydrogenItem;
+/**
+* Hydrogen-specific Weaverse runtime that owns page data, component stores,
+* Studio state, and translation sidecars for one rendered page.
+*/
+var WeaverseHydrogen = class extends _weaverse_react.Weaverse {
+	/** Identifier of the rendered page. */
+	pageId;
+	/** Runtime services and project metadata exposed to integrations. */
+	internal;
+	/** Normalized URL and locale information for the current request. */
+	requestInfo;
+	/** Identifier of the project supplying the page. */
+	projectId;
+	/** Origin used for Studio assets and editor communication. */
+	weaverseHost;
+	/** Base URL used for public content API requests. */
+	weaverseApiBase;
+	/**
+	* API key read from environment/configuration for storefront requests or
+	* supplied by Studio requests while editing and previewing.
+	*/
+	weaverseApiKey;
+	/** Studio asset version supplied by the preview request. */
+	weaverseVersion;
+	/** Whether the page is running inside the visual editor. */
+	isDesignMode;
+	/** Whether a single component preview is being rendered. */
+	isPreviewMode;
+	/** Whether a saved page revision is being previewed. */
+	isRevisionPreview;
+	/** Component type requested by section preview mode. */
+	sectionType;
+	/**
+	* Translation map received from the builder in design mode.
+	* Keyed by item ID, each entry maps field names to translated values.
+	* `WeaverseHydrogenItem.getSnapShot()` merges these into the data
+	* returned to components, so translations render without monkey-patching.
+	*/
+	translationMap = {};
+	/** Locale code for the active translation sidecar. */
+	translationLocale = "";
+	/** Builder language identifier for the active translation sidecar. */
+	translationLanguageId = "";
+	/** Creates a page runtime from resolved loader data and request settings. */
+	constructor(params) {
+		const { internal, pageId, requestInfo, ...coreParams } = params;
+		super({ ...coreParams });
+		this.internal = internal;
+		this.pageId = pageId;
+		this.requestInfo = requestInfo;
+		this.projectId = params.projectId;
+		this.weaverseHost = params.weaverseHost;
+		this.weaverseApiBase = params.weaverseApiBase;
+		this.weaverseApiKey = params.weaverseApiKey;
+		this.weaverseVersion = params.weaverseVersion || "";
+		this.isDesignMode = params.isDesignMode ?? false;
+		this.isPreviewMode = params.isPreviewMode ?? false;
+		this.isRevisionPreview = params.isRevisionPreview ?? false;
+		this.sectionType = params.sectionType || "";
+		this.extractTranslationSidecar();
+	}
+	/**
+	* Extract translation sidecar data from `this.data` (the page data).
+	* The builder attaches `translationMap`, `translationLocale`, and
+	* `translationLanguageId` to the page data in design mode.
+	*/
+	extractTranslationSidecar = () => {
+		const pageData = this.data;
+		if (pageData?.translationMap) {
+			this.translationMap = pageData.translationMap;
+			this.translationLocale = pageData.translationLocale || "";
+			this.translationLanguageId = pageData.translationLanguageId || "";
+		}
+	};
+	/**
+	* Set the translation sidecar data.
+	* Called by the studio bridge when translation data arrives or changes.
+	* Triggers a re-render of all items so translated snapshots are recalculated.
+	*/
+	setTranslationSidecar = (translationMap, locale, languageId) => {
+		this.translationMap = translationMap;
+		this.translationLocale = locale;
+		this.translationLanguageId = languageId;
+		this.refreshAllItems();
+	};
+	/**
+	* Update a single translation entry for a specific item field.
+	* Used by the studio bridge when the user edits a translatable field.
+	*/
+	updateTranslation = (itemId, key, originalValue, translatedValue) => {
+		if (!this.translationMap[itemId]) this.translationMap[itemId] = {};
+		this.translationMap[itemId] = {
+			...this.translationMap[itemId],
+			[key]: {
+				originalValue,
+				translatedValue
+			}
+		};
+		const instance = this.itemInstances.get(itemId);
+		if (instance) instance.triggerUpdate();
+	};
+	/**
+	* Collect all translation changes across all weaverse instances.
+	* Used by the save flow to persist translation edits.
+	*/
+	getTranslationChanges = () => {
+		const entries = [];
+		const languageId = this.translationLanguageId;
+		if (!(this.translationLocale && languageId)) return;
+		for (const [itemId, fields] of Object.entries(this.translationMap)) for (const [key, entry] of Object.entries(fields)) entries.push({
+			itemId,
+			key: `data.${key}`,
+			originalValue: entry.originalValue,
+			translatedValue: entry.translatedValue
+		});
+		if (entries.length === 0) return;
+		return {
+			languageId,
+			entries
+		};
+	};
+	/**
+	* Override setProjectData to re-extract translation sidecar from new page data.
+	*/
+	setProjectData = (data) => {
+		this.data = data;
+		this.extractTranslationSidecar();
+		this.initProject();
+	};
 };
 function createWeaverseInstance(params) {
-  const normalizedParams = normalizeRequestInfo(params);
-  if (react.isBrowser) {
-    window.__weaverses = window.__weaverses || {};
-    const existing = window.__weaverses[normalizedParams.pageId];
-    const isReused = existing?.requestInfo?.pathname === normalizedParams.requestInfo.pathname && existing?.requestInfo?.search === normalizedParams.requestInfo.search;
-    const weaverse = isReused ? existing : new WeaverseHydrogen(normalizedParams);
-    window.__weaverses[normalizedParams.pageId] = weaverse;
-    if (weaverse.isDesignMode) {
-      weaverse.requestInfo = normalizedParams.requestInfo;
-      if (hasWeaverseStudio(window)) {
-        window.weaverseStudio.refreshStudio(normalizedParams);
-      }
-    } else if (isReused) {
-      syncReusedInstance(weaverse, normalizedParams);
-    }
-    return weaverse;
-  }
-  return new WeaverseHydrogen(normalizedParams);
+	const normalizedParams = normalizeRequestInfo(params);
+	if (_weaverse_react.isBrowser) {
+		window.__weaverses = window.__weaverses || {};
+		const existing = window.__weaverses[normalizedParams.pageId];
+		const isReused = existing?.requestInfo?.pathname === normalizedParams.requestInfo.pathname && existing?.requestInfo?.search === normalizedParams.requestInfo.search;
+		const weaverse = isReused ? existing : new WeaverseHydrogen(normalizedParams);
+		window.__weaverses[normalizedParams.pageId] = weaverse;
+		if (weaverse.isDesignMode) {
+			weaverse.requestInfo = normalizedParams.requestInfo;
+			if (hasWeaverseStudio(window)) window.weaverseStudio.refreshStudio(normalizedParams);
+		} else if (isReused) syncReusedInstance(weaverse, normalizedParams);
+		return weaverse;
+	}
+	return new WeaverseHydrogen(normalizedParams);
 }
-var StudioBridge = react$1.memo(({ context }) => {
-  useStudio(context);
-  return null;
+const StudioBridge = (0, react.memo)(({ context }) => {
+	useStudio(context);
+	return null;
 });
-var StudioConnect = react$1.memo(() => {
-  useStudioConnect();
-  return null;
+const StudioConnect = (0, react.memo)(() => {
+	useStudioConnect();
+	return null;
 });
-var registeredComponentLists = /* @__PURE__ */ new WeakSet();
+/**
+* Component lists already pushed into the element registry. Registration is
+* idempotent (the registry checks `has(type)`), but walking the full list
+* allocates and loops on every render — theme component arrays are
+* module-level constants, so register each list identity once.
+*/
+const registeredComponentLists = /* @__PURE__ */ new WeakSet();
 function RenderRoot(props) {
-  const { data, components, dataContext } = props;
-  if (!registeredComponentLists.has(components)) {
-    for (const comp of [...components, ...defaultComponents]) {
-      if (comp?.schema?.type) {
-        registerComponent({
-          type: comp.schema.type,
-          Component: comp.default,
-          schema: comp.schema,
-          loader: comp.loader
-        });
-      }
-    }
-    registeredComponentLists.add(components);
-  }
-  const { page, configs, project, pageAssignment } = data || {};
-  const weaverse = createWeaverseInstance({
-    ...configs,
-    dataContext,
-    data: page,
-    pageId: page?.id,
-    internal: { project, pageAssignment }
-  });
-  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-    /* @__PURE__ */ jsxRuntime.jsx(react.WeaverseRoot, { context: weaverse }),
-    /* @__PURE__ */ jsxRuntime.jsx(StudioBridge, { context: weaverse })
-  ] });
+	const { data, components, dataContext } = props;
+	if (!registeredComponentLists.has(components)) {
+		for (const comp of [...components, ...defaultComponents]) if (comp?.schema?.type) registerComponent({
+			type: comp.schema.type,
+			Component: comp.default,
+			schema: comp.schema,
+			loader: comp.loader
+		});
+		registeredComponentLists.add(components);
+	}
+	const { page, configs, project, pageAssignment } = data || {};
+	const weaverse = createWeaverseInstance({
+		...configs,
+		dataContext,
+		data: page,
+		pageId: page?.id,
+		internal: {
+			project,
+			pageAssignment
+		}
+	});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_weaverse_react.WeaverseRoot, { context: weaverse }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StudioBridge, { context: weaverse })] });
 }
+/**
+* Register a Weaverse component with the global element registry.
+* Must be called before rendering components in WeaverseHydrogenRoot.
+*
+* @param element - Component configuration with schema, Component, and optional loader
+*
+* @example
+* ```typescript
+* import Hero from './sections/Hero'
+* import { schema } from './sections/Hero'
+*
+* registerComponent({
+*   type: 'hero',
+*   Component: Hero,
+*   schema,
+*   loader: async ({ data, weaverse }) => {
+*     return { someData: 'value' }
+*   }
+* })
+* ```
+*/
 function registerComponent(element) {
-  WeaverseHydrogen.registerElement(element);
+	WeaverseHydrogen.registerElement(element);
 }
-var WeaverseHydrogenRoot = react$1.memo(
-  ({
-    components,
-    data: dataProp,
-    errorComponent: ErrorComponent = ({ error }) => /* @__PURE__ */ jsxRuntime.jsx("div", { children: error instanceof Error ? error.message : "An unexpected error occurred" })
-  }) => {
-    const matches = reactRouter.useMatches();
-    const enhancedDataContext = react$1.useMemo(
-      () => createWeaverseDataContext(matches),
-      [matches]
-    );
-    const ownLoaderData = reactRouter.useLoaderData();
-    const weaverseData = react$1.useMemo(
-      () => pickWeaverseData(dataProp, ownLoaderData, matches),
-      [dataProp, ownLoaderData, matches]
-    );
-    if (dataProp === null) {
-      return null;
-    }
-    if (weaverseData) {
-      if (weaverseData instanceof Promise) {
-        return /* @__PURE__ */ jsxRuntime.jsx(reactErrorBoundary.ErrorBoundary, { fallbackRender: ErrorComponent, children: /* @__PURE__ */ jsxRuntime.jsx(react$1.Suspense, { children: /* @__PURE__ */ jsxRuntime.jsx(reactRouter.Await, { resolve: weaverseData, children: (resolvedData) => /* @__PURE__ */ jsxRuntime.jsx(
-          RenderRoot,
-          {
-            components,
-            data: resolvedData,
-            dataContext: enhancedDataContext
-          }
-        ) }) }) });
-      }
-      return /* @__PURE__ */ jsxRuntime.jsx(
-        RenderRoot,
-        {
-          components,
-          data: weaverseData,
-          dataContext: enhancedDataContext
-        }
-      );
-    }
-    return /* @__PURE__ */ jsxRuntime.jsx(
-      ErrorComponent,
-      {
-        error: { message: "No Weaverse data found in route matches!" }
-      }
-    );
-  }
-);
+/**
+* Renders the Weaverse page for the current React Router route.
+*
+* Pass `data` to override automatic route-loader resolution. A promise is
+* handled with React Router's `Await`, while explicit `null` suppresses output.
+*/
+const WeaverseHydrogenRoot = (0, react.memo)(({ components, data: dataProp, errorComponent: ErrorComponent = ({ error }) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: error instanceof Error ? error.message : "An unexpected error occurred" }) }) => {
+	const matches = (0, react_router.useMatches)();
+	const enhancedDataContext = (0, react.useMemo)(() => createWeaverseDataContext(matches), [matches]);
+	const ownLoaderData = (0, react_router.useLoaderData)();
+	const weaverseData = (0, react.useMemo)(() => pickWeaverseData(dataProp, ownLoaderData, matches), [
+		dataProp,
+		ownLoaderData,
+		matches
+	]);
+	if (dataProp === null) return null;
+	if (weaverseData) {
+		if (weaverseData instanceof Promise) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_error_boundary.ErrorBoundary, {
+			fallbackRender: ErrorComponent,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react.Suspense, { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_router.Await, {
+				resolve: weaverseData,
+				children: (resolvedData) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RenderRoot, {
+					components,
+					data: resolvedData,
+					dataContext: enhancedDataContext
+				})
+			}) })
+		});
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RenderRoot, {
+			components,
+			data: weaverseData,
+			dataContext: enhancedDataContext
+		});
+	}
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ErrorComponent, { error: { message: "No Weaverse data found in route matches!" } });
+});
+/**
+* Higher-order component that wraps your app with Weaverse theme settings and
+* translation context, and mounts the Studio connect bridge.
+*
+* Export the result as your root route's **`Layout`** (not the default route
+* `Component`). In React Router the root `Layout` wraps both the matched route
+* and its `ErrorBoundary`, so the Studio bridge keeps rendering on 404s and
+* loader/render errors — exactly the pages where Studio must still answer its
+* handshake instead of reporting a false "Connection lost". A default-component
+* wrapper (`export default withWeaverse(App)`) is replaced by the error
+* boundary on those routes and would drop the bridge.
+*
+* @param Component - The root layout component to wrap
+* @param options   - Optional configuration (e.g. an external `t` function)
+* @returns Wrapped component with theme settings + translation providers
+*
+* @example
+* ```typescript
+* import { withWeaverse } from '@weaverse/hydrogen'
+*
+* // Basic usage — export as the root route Layout
+* export const Layout = withWeaverse(RootLayout)
+*
+* // With an external translation function
+* export const Layout = withWeaverse(RootLayout, { t: myI18nFunction })
+* ```
+*/
 function withWeaverse(Component, options) {
-  return (props) => {
-    const themeSettingsStore = useCreateThemeSettingsStore();
-    const translationData = useTranslationData();
-    const translationStoreRef = react$1.useRef(null);
-    if (!translationStoreRef.current) {
-      translationStoreRef.current = new TranslationStore();
-    }
-    return /* @__PURE__ */ jsxRuntime.jsx(ThemeSettingsStoreContext.Provider, { value: themeSettingsStore, children: /* @__PURE__ */ jsxRuntime.jsxs(
-      TranslationProvider,
-      {
-        merchantOverrides: translationData.merchantOverrides,
-        staticContent: translationData.staticContent,
-        t: options?.t,
-        translationStore: translationStoreRef.current,
-        children: [
-          /* @__PURE__ */ jsxRuntime.jsx(StudioConnect, {}),
-          /* @__PURE__ */ jsxRuntime.jsx(Component, { ...props })
-        ]
-      }
-    ) });
-  };
+	return (props) => {
+		const themeSettingsStore = useCreateThemeSettingsStore();
+		const translationData = useTranslationData();
+		const translationStoreRef = (0, react.useRef)(null);
+		if (!translationStoreRef.current) translationStoreRef.current = new TranslationStore();
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ThemeSettingsStoreContext.Provider, {
+			value: themeSettingsStore,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(TranslationProvider, {
+				merchantOverrides: translationData.merchantOverrides,
+				staticContent: translationData.staticContent,
+				t: options?.t,
+				translationStore: translationStoreRef.current,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(StudioConnect, {}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Component, { ...props })]
+			})
+		});
+	};
 }
+/**
+* Internal hook to read staticContent and merchantOverrides from root loader data.
+* Similar pattern to useThemeSettingsStore – reads from the 'root' route loader.
+*/
 function useTranslationData() {
-  const data = reactRouter.useRouteLoaderData("root");
-  return {
-    staticContent: data?.weaverseTheme?.staticContent ?? {},
-    merchantOverrides: data?.weaverseTheme?.merchantOverrides
-  };
+	const data = (0, react_router.useRouteLoaderData)("root");
+	return {
+		staticContent: data?.weaverseTheme?.staticContent ?? {},
+		merchantOverrides: data?.weaverseTheme?.merchantOverrides
+	};
 }
+/**
+* React hook to access Weaverse theme settings from anywhere in your component tree.
+* Must be used within a component wrapped by `withWeaverse` or inside `WeaverseHydrogenRoot`.
+*
+* @returns Current theme settings object
+*
+* @example
+* ```typescript
+* function MyComponent() {
+*   const theme = useThemeSettings()
+*   const primaryColor = theme.colors?.primary
+*
+*   return <div style={{ color: primaryColor }}>Styled content</div>
+* }
+* ```
+*/
 function useThemeSettings() {
-  const themeSettingsStore = useThemeSettingsStore();
-  const settings = react.useSafeExternalStore(
-    themeSettingsStore.subscribe,
-    themeSettingsStore.getSnapshot,
-    themeSettingsStore.getServerSnapshot
-  );
-  return settings;
+	const themeSettingsStore = useThemeSettingsStore();
+	return (0, _weaverse_react.useSafeExternalStore)(themeSettingsStore.subscribe, themeSettingsStore.getSnapshot, themeSettingsStore.getServerSnapshot);
 }
-
-// src/utils/normalize-page-url.ts
-var KEPT_PARAM_RE = /^(?:__revisionId|isDesignMode|weaverse)/;
+//#endregion
+//#region src/utils/normalize-page-url.ts
+const KEPT_PARAM_RE = /^(?:__revisionId|isDesignMode|weaverse)/;
+/**
+* Normalize the storefront URL sent in the Builder page API request body.
+*
+* The POST body participates in the `withCache` cache key, so a raw
+* `request.url` fragments the cache by every marketing/tracking param:
+* each distinct `?utm_…`/`fbclid` URL is a guaranteed Builder round-trip
+* even when the resolved page is identical — precisely the paid/social
+* traffic that needs the cache most (builder#2450).
+*
+* The Builder reads only the pathname (locale/type/handle fallback) and
+* the params matched above from this URL, so keep exactly those. Params
+* are sorted for a stable cache key regardless of their order in the
+* incoming URL.
+*/
 function normalizePageUrl(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return url;
-  }
-  const kept = [...parsed.searchParams].filter(
-    ([key]) => KEPT_PARAM_RE.test(key)
-  );
-  kept.sort(([a], [b]) => a.localeCompare(b));
-  const search = new URLSearchParams(kept).toString();
-  let { pathname } = parsed;
-  if (pathname.endsWith(".data")) {
-    pathname = pathname.slice(0, -".data".length);
-  }
-  return `${parsed.origin}${pathname}${search ? `?${search}` : ""}`;
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return url;
+	}
+	const kept = [...parsed.searchParams].filter(([key]) => KEPT_PARAM_RE.test(key));
+	kept.sort(([a], [b]) => a.localeCompare(b));
+	const search = new URLSearchParams(kept).toString();
+	let { pathname } = parsed;
+	if (pathname.endsWith(".data")) pathname = pathname.slice(0, -5);
+	return `${parsed.origin}${pathname}${search ? `?${search}` : ""}`;
 }
-
-// src/weaverse-client.ts
-var CACHE_DURATIONS = {
-  /** Short browser freshness for content that can change in Builder */
-  SHORT: 60,
-  /** Shared cache freshness for anonymous storefront traffic */
-  SHARED_SHORT: 300,
-  /** Long stale window so slow Builder responses do not block storefront rendering */
-  LONG: 86400,
-  /** Extra freshness for sitemap-like index data */
-  STATIC: 3600
+//#endregion
+//#region src/weaverse-client.ts
+/**
+* Cache duration constants (in seconds).
+* These values optimize CDN hit rates while maintaining fresh content.
+*/
+const CACHE_DURATIONS = {
+	/** Short browser freshness for content that can change in Builder */
+	SHORT: 60,
+	/** Shared cache freshness for anonymous storefront traffic */
+	SHARED_SHORT: 300,
+	/** Long stale window so slow Builder responses do not block storefront rendering */
+	LONG: 86400,
+	/** Extra freshness for sitemap-like index data */
+	STATIC: 3600
 };
-var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
-var MAX_FETCH_ATTEMPTS = 2;
-var FETCH_RETRY_BACKOFF_MS = 300;
+/**
+* Network timeout for fetch requests (in milliseconds).
+* Default is 10 seconds to balance reliability and user experience.
+*/
+const DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+/**
+* Bounded retry for the public API fetch. A single slow/cold origin response,
+* a transient 5xx, or a network blip would otherwise make loadPage return null
+* — rendering the "Please add new section" placeholder or throwing a 404 in
+* the route. Two attempts (one retry) is enough: by the time the first attempt
+* times out, the edge proxy's single-flight leader has usually populated its
+* versioned cache, so the retry lands on a warm HIT.
+*/
+const MAX_FETCH_ATTEMPTS = 2;
+const FETCH_RETRY_BACKOFF_MS = 300;
+/**
+* Retry only transient failures: request timeouts, network errors, and origin
+* 5xx. A 4xx is deterministic (e.g. a genuine 404) — retrying just wastes time.
+*/
 function isRetryableFetchError(error) {
-  if (!(error instanceof WeaverseError)) {
-    return false;
-  }
-  if (error.code === "TIMEOUT_ERROR" || error.code === "NETWORK_ERROR") {
-    return true;
-  }
-  return error.code === "FETCH_ERROR" && (error.statusCode ?? 0) >= 500;
+	if (!(error instanceof WeaverseError)) return false;
+	if (error.code === "TIMEOUT_ERROR" || error.code === "NETWORK_ERROR" || error.code === "INVALID_RESPONSE") return true;
+	return error.code === "FETCH_ERROR" && (error.statusCode ?? 0) >= 500;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Whether a successful `/project` body is a page envelope.
+*
+* `page: null` is Builder's authoritative "nothing assigned at this URL" and
+* stays valid; anything without a `page` field, with an `error` field, or with
+* a page that has no item list is not an answer about this URL at all.
+*/
+function isProjectEnvelope(payload) {
+	if (!isPlainObject(payload) || hasError(payload) || !("page" in payload)) return false;
+	const { page, project } = payload;
+	return (page === null || isPlainObject(page) && Array.isArray(page.items)) && (project == null || isPlainObject(project));
 }
-var API_PATH = "v1";
-var DEFAULT_CACHE_STRATEGY = {
-  maxAge: CACHE_DURATIONS.SHORT,
-  sMaxAge: CACHE_DURATIONS.SHARED_SHORT,
-  staleWhileRevalidate: CACHE_DURATIONS.LONG,
-  staleIfError: CACHE_DURATIONS.LONG
+/**
+* Whether a successful `/project_configs` body carries theme settings.
+*
+* Builder always sends the `theme` field; `null` means the merchant never
+* saved settings, so schema defaults are the real configuration.
+*/
+function isThemeConfigsEnvelope(payload) {
+	return isPlainObject(payload) && !hasError(payload) && "theme" in payload && (payload.theme === null || isPlainObject(payload.theme));
+}
+/**
+* Classifies a page-load failure. `'absent'` is Builder's 404 for a project
+* that does not exist, which keeps resolving to `null` like before.
+*/
+function classifyPageLoadFailure(error) {
+	if (error instanceof WeaverseLoadError) return error.kind;
+	if (!(error instanceof WeaverseError)) return "invalid-response";
+	if (error.code === "TIMEOUT_ERROR" || error.code === "NETWORK_ERROR") return "unavailable";
+	if (error.code === "INVALID_RESPONSE") return "invalid-response";
+	if (error.code === "FETCH_ERROR") {
+		const status = error.statusCode ?? 0;
+		if (status === 404) return "absent";
+		if (status === 408 || status === 425 || status === 429 || status >= 500) return "unavailable";
+	}
+	return "configuration";
+}
+/**
+* Validators for Builder requests made by this client itself, keyed on the
+* exact options object (same reasoning as `bodyFreeCacheRequests`). On the
+* cached path such a request rejects a non-2xx status instead of resolving
+* to `null`, and only stores a body its validator accepts. Every other
+* `fetchWithCache` caller keeps the existing behavior.
+*/
+const builderPayloadValidators = /* @__PURE__ */ new WeakMap();
+/**
+* Gives a rejection from Hydrogen's cached fetch the code `fetchOnce` gives
+* the same failure on the direct path.
+*
+* Hydrogen calls the platform `fetch` itself, so a request that never got a
+* response rejects with the platform's error instead of a `WeaverseError`.
+* The Fetch standard rejects a network failure with a `TypeError` and an
+* aborted request with the signal's `AbortError`/`TimeoutError`; those are
+* outages. Anything else is returned unchanged, so it is not reported as one.
+*/
+function cachedTransportError(error, url) {
+	if (error instanceof WeaverseError || !(error instanceof Error)) return error;
+	if (error.name === "AbortError" || error.name === "TimeoutError") return new WeaverseError("Request timed out", "TIMEOUT_ERROR", void 0, { url });
+	if (error instanceof TypeError) return new WeaverseError("Network error during fetch", "NETWORK_ERROR", void 0, {
+		url,
+		cause: error.message
+	});
+	return error;
+}
+/**
+* Weaverse API version path
+*/
+const API_PATH = "v1";
+/**
+* Default cache strategy for Weaverse API requests.
+* Optimized for CDN performance with 23-hour stale content tolerance.
+*/
+const DEFAULT_CACHE_STRATEGY = {
+	maxAge: CACHE_DURATIONS.SHORT,
+	sMaxAge: CACHE_DURATIONS.SHARED_SHORT,
+	staleWhileRevalidate: CACHE_DURATIONS.LONG,
+	staleIfError: CACHE_DURATIONS.LONG
 };
-var SMART_CACHE_STRATEGIES = {
-  project: DEFAULT_CACHE_STRATEGY,
-  "theme-settings": DEFAULT_CACHE_STRATEGY,
-  "merchant-overrides": DEFAULT_CACHE_STRATEGY,
-  "custom-pages": {
-    maxAge: CACHE_DURATIONS.SHORT,
-    sMaxAge: CACHE_DURATIONS.STATIC,
-    staleWhileRevalidate: CACHE_DURATIONS.LONG,
-    staleIfError: CACHE_DURATIONS.LONG
-  }
+const SMART_CACHE_STRATEGIES = {
+	project: DEFAULT_CACHE_STRATEGY,
+	"theme-settings": DEFAULT_CACHE_STRATEGY,
+	"merchant-overrides": DEFAULT_CACHE_STRATEGY,
+	"custom-pages": {
+		maxAge: CACHE_DURATIONS.SHORT,
+		sMaxAge: CACHE_DURATIONS.STATIC,
+		staleWhileRevalidate: CACHE_DURATIONS.LONG,
+		staleIfError: CACHE_DURATIONS.LONG
+	}
 };
-var bodyFreeCacheRequests = /* @__PURE__ */ new WeakSet();
-var BODY_FREE_CACHE_SENTINEL = "\0weaverse:body-free";
+/**
+* Options objects created by the internal `project_configs` request whose
+* subrequest cache identity deliberately excludes the body. Theme settings
+* carry the storefront origin so Builder can attribute hostnames; hashing the
+* body would give every domain of one project its own entry.
+*
+* The SUCCESSFUL theme payload is the same for every storefront of a project,
+* which is what makes one shared entry correct. This is not a claim that
+* Builder can never answer differently per host: a hostname-blocked request
+* returns a 403 `{ error }` body, and `shouldCacheResponse` rejects anything
+* `hasError()` matches, so a refusal is never stored under (or served from)
+* the shared entry. If a future response shape ever varies by host WITHOUT an
+* `error` field, this exclusion has to be revisited.
+*
+* Keyed on the exact options object, NOT on `cacheTarget`: `fetchWithCache`
+* is public API, so gating on the target would silently collapse the cache of
+* any consumer who selects `theme-settings` with varying bodies. An outside
+* caller's options object is never in this set and keeps a body-derived key.
+*
+* The WeakSet-membership slot in the cache key (`has(options)`) is the actual
+* discriminator — no caller-supplied value can reach it. The sentinel is not
+* load-bearing for that; it only keeps the omitted body legible in cache
+* debugging instead of a bare `undefined`.
+*/
+const bodyFreeCacheRequests = /* @__PURE__ */ new WeakSet();
+const BODY_FREE_CACHE_SENTINEL = "\0weaverse:body-free";
+/**
+* Request-scoped client for loading Weaverse pages and theme settings in Hydrogen.
+*
+* Create one client from the Hydrogen app context, then call
+* {@link WeaverseClient.loadPage} from route loaders and
+* {@link WeaverseClient.loadThemeSettings} from the root loader.
+*/
 var WeaverseClient = class {
-  /** Builder API version used by this client. */
-  API = API_PATH;
-  /** Stable project configuration shared by page requests. */
-  basePageConfigs;
-  /** Stable request body fields shared by page requests. */
-  basePageRequestBody;
-  /** Resolved project and rendering-mode configuration. */
-  configs;
-  /** Hydrogen cache wrapper used for Builder API requests. */
-  withCache;
-  /** Incoming request associated with this client instance. */
-  request;
-  /** Hydrogen customer-account client, when configured. */
-  customerAccount;
-  /** Hydrogen Storefront API client and locale context. */
-  storefront;
-  /** Components registered for page rendering and component loaders. */
-  components;
-  /** Theme schema used for defaults and Studio editing. */
-  themeSchema;
-  /** Hydrogen runtime environment variables. */
-  env;
-  /** Cache storage supplied by the Hydrogen runtime. */
-  cache;
-  /** Background execution hook supplied by the Oxygen runtime. */
-  waitUntil;
-  // Performance optimizations
-  parsedUrl;
-  componentsByType;
-  // Configuration
-  fetchTimeoutMs;
-  /** Creates a request-scoped client from the Hydrogen app context. */
-  constructor(args) {
-    this.request = args.request;
-    this.storefront = args.storefront;
-    this.customerAccount = args.customerAccount;
-    this.components = args.components;
-    this.themeSchema = args.themeSchema;
-    this.env = args.env;
-    this.cache = args.cache;
-    this.waitUntil = args.waitUntil;
-    this.parsedUrl = new URL(args.request.url);
-    this.componentsByType = this.buildComponentLookupMap(args.components);
-    this.fetchTimeoutMs = args.fetchTimeoutMs || DEFAULT_FETCH_TIMEOUT_MS;
-    this.initializeCache(args);
-    this.initializeConfigs(args);
-  }
-  /**
-   * Initialize Hydrogen cache with proper configuration.
-   * Logs warning if waitUntil is missing.
-   */
-  initializeCache(args) {
-    if (!args.waitUntil) {
-      console.warn(
-        "\u26A0\uFE0F WeaverseClient: waitUntil not provided, background operations may not complete"
-      );
-    }
-    this.withCache = hydrogen.createWithCache({
-      cache: args.cache,
-      waitUntil: args.waitUntil || (() => Promise.resolve()),
-      request: args.request
-    });
-  }
-  /**
-   * Initialize configs with projectId resolution and fail-fast validation.
-   * Throws WeaverseError if projectId cannot be resolved.
-   */
-  initializeConfigs(args) {
-    const baseConfigs = getWeaverseConfigs(
-      args.request,
-      args.env
-    );
-    const resolvedProjectId = this.resolveProjectIdSync(
-      args.projectId,
-      args.request,
-      args.env,
-      baseConfigs
-    );
-    if (!resolvedProjectId || resolvedProjectId.trim() === "") {
-      throw new WeaverseError(
-        "Failed to initialize WeaverseClient: No valid projectId found. Set WEAVERSE_PROJECT_ID environment variable or provide projectId parameter.",
-        "MISSING_PROJECT_ID"
-      );
-    }
-    this.configs = {
-      ...baseConfigs,
-      projectId: resolvedProjectId
-    };
-    this.basePageConfigs = {
-      projectId: this.configs.projectId,
-      weaverseHost: this.configs.weaverseHost,
-      weaverseApiBase: this.configs.weaverseApiBase,
-      weaverseApiKey: this.configs.weaverseApiKey,
-      weaverseVersion: this.configs.weaverseVersion,
-      isDesignMode: this.configs.isDesignMode,
-      isPreviewMode: this.configs.isPreviewMode,
-      isRevisionPreview: this.configs.isRevisionPreview
-    };
-    this.basePageRequestBody = {
-      isDesignMode: this.configs.isDesignMode,
-      i18n: args.storefront.i18n,
-      projectId: this.configs.projectId
-    };
-    Object.freeze(this.configs);
-    Object.freeze(this.basePageConfigs);
-    Object.freeze(this.basePageRequestBody);
-  }
-  /**
-   * Build component lookup map for O(1) access by type.
-   * Significantly improves performance for large component lists.
-   */
-  buildComponentLookupMap(components) {
-    return new Map(components.map((comp) => [comp.schema?.type, comp]));
-  }
-  /**
-   * Extract comprehensive error information from unknown error type.
-   * Preserves error context, codes, and stack traces for debugging.
-   *
-   * @param error - Unknown error to extract information from
-   * @returns Structured error information with message, code, stack, and context
-   *
-   * @example
-   * ```typescript
-   * try {
-   *   // ... operation
-   * } catch (error) {
-   *   const errorInfo = this.extractErrorInfo(error)
-   *   console.error('Operation failed:', errorInfo.message, errorInfo.context)
-   * }
-   * ```
-   */
-  extractErrorInfo(error) {
-    if (error instanceof WeaverseError) {
-      return {
-        message: error.message,
-        code: error.code,
-        context: error.context,
-        stack: error.stack
-      };
-    }
-    if (error instanceof Error) {
-      return {
-        message: error.message,
-        stack: error.stack
-      };
-    }
-    return {
-      message: String(error)
-    };
-  }
-  /**
-   * Extract error message only (for backward compatibility).
-   * Use extractErrorInfo() for more detailed error information.
-   *
-   * @deprecated Use extractErrorInfo() instead to preserve error context
-   */
-  extractErrorMessage(error) {
-    return this.extractErrorInfo(error).message;
-  }
-  /**
-   * Validates projectId format (alphanumeric, hyphens, underscores only).
-   * Returns detailed validation result with error message.
-   *
-   * @param projectId - Project identifier to validate
-   * @returns Validation result with error message if invalid
-   */
-  validateProjectId(projectId) {
-    if (!projectId || projectId.trim() === "") {
-      return {
-        valid: false,
-        error: "Project ID cannot be empty"
-      };
-    }
-    const validPattern = /^[a-zA-Z0-9_-]+$/;
-    if (!validPattern.test(projectId)) {
-      return {
-        valid: false,
-        error: `Invalid format: "${projectId}". Only alphanumeric characters, hyphens, and underscores are allowed.`
-      };
-    }
-    return { valid: true };
-  }
-  /**
-   * Resolves projectId with multi-project architecture support.
-   * Uses priority chain to determine the correct project ID.
-   *
-   * @param projectId - Project identifier (string, function, or undefined)
-   * @param request - HTTP request for context access
-   * @param env - Hydrogen environment with variables
-   * @param baseConfigs - Pre-fetched base configs to avoid duplicate calls
-   * @returns Resolved project ID string (empty string if none found)
-   */
-  resolveProjectIdSync(projectId, request, env, baseConfigs) {
-    return this.resolveFromQueryParams(request) || this.resolveFromFunction(projectId) || this.resolveFromString(projectId) || this.resolveFromEnvironment(baseConfigs, request, env) || "";
-  }
-  /**
-   * Priority 1: Resolve projectId from URL query parameters.
-   * Used for design mode and preview mode overrides.
-   */
-  resolveFromQueryParams(request) {
-    const queries = getRequestQueries(request);
-    return queries.weaverseProjectId || null;
-  }
-  /**
-   * Priority 2: Resolve projectId from function parameter.
-   * Detects and rejects async functions with helpful error.
-   */
-  resolveFromFunction(projectId) {
-    if (!isProjectIdFunction(projectId)) {
-      return null;
-    }
-    if (projectId.constructor.name === "AsyncFunction") {
-      throw new WeaverseError(
-        "Async projectId functions must be awaited before passing to WeaverseClient. Use: projectId: await getProjectAsync() instead of: projectId: getProjectAsync",
-        "ASYNC_PROJECT_ID"
-      );
-    }
-    try {
-      const result = projectId();
-      if (result instanceof Promise) {
-        throw new WeaverseError(
-          "Async projectId functions must be awaited before passing to WeaverseClient. Use: projectId: await getProjectAsync() instead of: projectId: getProjectAsync",
-          "ASYNC_PROJECT_ID"
-        );
-      }
-      if (result && result.trim() !== "") {
-        const trimmed = result.trim();
-        const validation = this.validateProjectId(trimmed);
-        if (validation.valid) {
-          return trimmed;
-        }
-        throw new WeaverseError(
-          validation.error || "Invalid projectId format",
-          "INVALID_PROJECT_ID"
-        );
-      }
-    } catch (err) {
-      if (err instanceof WeaverseError) {
-        throw err;
-      }
-      throw new WeaverseError(
-        `Failed to evaluate projectId function: ${err instanceof Error ? err.message : String(err)}`,
-        "PROJECT_ID_FUNCTION_ERROR",
-        void 0,
-        { cause: err instanceof Error ? err.stack : String(err) }
-      );
-    }
-    return null;
-  }
-  /**
-   * Priority 3: Resolve projectId from explicit string parameter.
-   */
-  resolveFromString(projectId) {
-    if (typeof projectId !== "string") {
-      return null;
-    }
-    const trimmed = projectId.trim();
-    if (trimmed === "") {
-      return null;
-    }
-    const validation = this.validateProjectId(trimmed);
-    if (validation.valid) {
-      return trimmed;
-    }
-    throw new WeaverseError(
-      validation.error || "Invalid projectId format",
-      "INVALID_PROJECT_ID"
-    );
-  }
-  /**
-   * Priority 4: Resolve projectId from environment variables.
-   */
-  resolveFromEnvironment(baseConfigs, request, env) {
-    const configs = baseConfigs || getWeaverseConfigs(request, env);
-    if (configs.projectId && configs.projectId.trim() !== "") {
-      return configs.projectId.trim();
-    }
-    return null;
-  }
-  /**
-   * Helper method for direct fetching in design mode.
-   * Returns same format as withCache.fetch for consistency.
-   * Includes 10-second timeout to prevent hanging requests.
-   */
-  fetchOnce = async (url, options, timeoutMs) => {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(
-      () => controller.abort(),
-      timeoutMs
-    );
-    try {
-      const response = await fetch(url, {
-        ...options,
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new WeaverseError(
-          `HTTP ${response.status}: ${response.statusText}`,
-          "FETCH_ERROR",
-          response.status,
-          { url, errorText }
-        );
-      }
-      const data = await response.json();
-      return { data, response };
-    } catch (err) {
-      if (err instanceof WeaverseError) {
-        throw err;
-      }
-      if (err.name === "AbortError") {
-        throw new WeaverseError(
-          `Request timeout after ${timeoutMs}ms`,
-          "TIMEOUT_ERROR",
-          void 0,
-          { url, timeoutMs }
-        );
-      }
-      throw new WeaverseError(
-        "Network error during fetch",
-        "NETWORK_ERROR",
-        void 0,
-        { url, cause: err instanceof Error ? err.message : String(err) }
-      );
-    } finally {
-      if (timeoutId !== void 0) {
-        clearTimeout(timeoutId);
-      }
-    }
-  };
-  directFetch = async (url, options = {}, timeoutMs = this.fetchTimeoutMs) => {
-    let lastError;
-    for (let attempt = 1; attempt <= MAX_FETCH_ATTEMPTS; attempt++) {
-      try {
-        return await this.fetchOnce(url, options, timeoutMs);
-      } catch (err) {
-        lastError = err;
-        if (attempt >= MAX_FETCH_ATTEMPTS || !isRetryableFetchError(err)) {
-          throw err;
-        }
-        await new Promise(
-          (resolve) => setTimeout(resolve, FETCH_RETRY_BACKOFF_MS * attempt)
-        );
-      }
-    }
-    throw lastError;
-  };
-  // Helper method for building API URLs consistently
-  getApiUrl(endpoint) {
-    const { weaverseApiBase } = this.configs;
-    return `${weaverseApiBase}/api/public/${endpoint}`;
-  }
-  isExternalPublicApiUrl(url) {
-    const { weaverseApiBase, weaverseHost } = this.configs;
-    return weaverseApiBase !== weaverseHost && url.startsWith(`${weaverseApiBase}/api/public/`);
-  }
-  /**
-   * Fetch data with caching support for both design mode and production.
-   * Uses direct fetch in design mode, Hydrogen's withCache in production.
-   * Automatically includes projectId in cache key for multi-project isolation.
-   *
-   * @param url - The URL to fetch from
-   * @param options - Fetch options including optional cache strategy
-   * @returns Promise resolving to the fetched data
-   *
-   * @example
-   * ```typescript
-   * const data = await weaverse.fetchWithCache<MyData>(
-   *   'https://api.example.com/data',
-   *   { method: 'POST', body: JSON.stringify({ key: 'value' }) }
-   * )
-   * ```
-   */
-  fetchWithCache = async (url, options = {}) => {
-    const { cacheTarget, strategy: strategyOverride, ...fetchOptions } = options;
-    const strategy = strategyOverride || hydrogen.CacheCustom(
-      cacheTarget ? SMART_CACHE_STRATEGIES[cacheTarget] : DEFAULT_CACHE_STRATEGY
-    );
-    const cacheKey = [
-      "weaverse-fetch",
-      url,
-      options.method || "GET",
-      bodyFreeCacheRequests.has(options) ? BODY_FREE_CACHE_SENTINEL : fetchOptions.body,
-      // WeakSet-derived discriminator: this slot cannot be produced by any
-      // caller-supplied shape, so no external call can reach the marked
-      // identity — even one that happens to send the sentinel string as its
-      // body.
-      bodyFreeCacheRequests.has(options),
-      this.configs.projectId,
-      cacheTarget || "default"
-    ];
-    let result;
-    if (this.configs.isDesignMode || this.configs.isRevisionPreview || this.isExternalPublicApiUrl(url)) {
-      result = await this.directFetch(url, fetchOptions);
-    } else {
-      result = await this.withCache.fetch(url, fetchOptions, {
-        cacheKey,
-        cacheStrategy: strategy,
-        shouldCacheResponse: (response) => {
-          if (fetchOptions.signal?.aborted) {
-            return false;
-          }
-          return !hasError(response) && response !== null && response !== void 0;
-        },
-        displayName: "Weaverse API"
-      });
-    }
-    return result.data;
-  };
-  /**
-   * Safe origin of the incoming storefront request: scheme, host and explicit
-   * port. Userinfo, path, query and fragment are dropped, so no customer
-   * route or credential-bearing value leaves the storefront. Returns undefined
-   * for a non-http(s) request so the field is simply omitted.
-   */
-  safeStorefrontOrigin() {
-    const { protocol, host } = this.parsedUrl;
-    if (protocol !== "http:" && protocol !== "https:") {
-      return;
-    }
-    return host ? `${protocol}//${host}` : void 0;
-  }
-  /**
-   * Load theme settings from Weaverse API with fallback to schema defaults.
-   * Merges remote settings with local theme schema and handles design mode serialization.
-   *
-   * @param strategy - Optional cache strategy override
-   * @returns Promise resolving to theme settings response
-   *
-   * @example
-   * ```typescript
-   * const settings = await weaverse.loadThemeSettings()
-   * const primaryColor = settings.theme.colors?.primary
-   * ```
-   */
-  loadThemeSettings = async (strategy) => {
-    const defaultThemeSettings = generateDataFromSchema(this.themeSchema);
-    try {
-      const { configs } = this;
-      const { projectId, isDesignMode } = configs;
-      if (!projectId) {
-        throw new Error("Missing Weaverse projectId!");
-      }
-      const url = this.getApiUrl("project_configs");
-      const body = JSON.stringify({
-        isDesignMode,
-        projectId,
-        storefrontUrl: this.safeStorefrontOrigin()
-      });
-      const themeSettingsOptions = {
-        method: "POST",
-        cacheTarget: "theme-settings",
-        strategy,
-        body,
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-          "Accept-Encoding": "gzip, deflate, br"
-        }
-      };
-      bodyFreeCacheRequests.add(themeSettingsOptions);
-      const [data, merchantOverrides] = await Promise.all([
-        this.fetchWithCache(url, themeSettingsOptions),
-        this.fetchMerchantOverrides(strategy)
-      ]);
-      let result = data;
-      if (typeof result !== "object" || result === null) {
-        console.warn(
-          "Invalid theme settings response format, using defaults:",
-          {
-            type: typeof result,
-            isString: typeof result === "string",
-            length: typeof result === "string" ? result.length : "N/A",
-            preview: typeof result === "string" ? `${result.slice(0, 50)}...` : String(result)
-          }
-        );
-        result = { theme: defaultThemeSettings };
-      }
-      if (this.themeSchema?.settings || this.themeSchema?.inspector) {
-        if (!result.theme || typeof result.theme !== "object") {
-          result.theme = defaultThemeSettings;
-        } else {
-          result.theme = {
-            ...defaultThemeSettings,
-            ...result.theme
-          };
-        }
-      }
-      const staticContent = this.themeSchema?.i18n?.staticContent;
-      if (staticContent) {
-        result.staticContent = staticContent;
-      }
-      if (merchantOverrides) {
-        result.merchantOverrides = merchantOverrides;
-      }
-      if (this.configs.isDesignMode) {
-        result = {
-          ...result,
-          schema: this.themeSchema && typeof this.themeSchema === "object" ? {
-            ...this.themeSchema,
-            settings: this.themeSchema?.settings?.map((group) => ({
-              ...group,
-              inputs: group?.inputs?.map((input) => {
-                if (typeof input?.condition === "function") {
-                  return {
-                    ...input,
-                    condition: input.condition.toString()
-                  };
-                }
-                return input;
-              })
-            }))
-          } : void 0,
-          publicEnv: this.configs.publicEnv
-        };
-      }
-      return result;
-    } catch (error) {
-      const errorMessage = "Unable to load theme settings";
-      const errorDetails = this.extractErrorMessage(error);
-      console.error(errorMessage, errorDetails);
-      return {
-        theme: defaultThemeSettings,
-        staticContent: this.themeSchema?.i18n?.staticContent,
-        _error: errorDetails,
-        _loadFailed: true
-      };
-    }
-  };
-  /**
-   * Fetch locale-specific merchant overrides from the translation API.
-   * Returns a nested JSON object with translated values.
-   * Falls back to empty object on error to avoid blocking theme rendering.
-   */
-  fetchMerchantOverrides = async (strategy) => {
-    try {
-      const { projectId, weaverseHost } = this.configs;
-      const i18n = this.storefront.i18n;
-      if (!this.themeSchema?.i18n) {
-        return;
-      }
-      if (!(projectId && weaverseHost)) {
-        return;
-      }
-      const language = (i18n?.language || "en").toLowerCase();
-      const country = (i18n?.country || "us").toLowerCase();
-      const locale = `${language}-${country}`;
-      const url = `${weaverseHost}/api/translation/static?projectId=${projectId}&locale=${locale}`;
-      const overrides = await this.fetchWithCache(
-        url,
-        {
-          method: "GET",
-          cacheTarget: "merchant-overrides",
-          strategy,
-          headers: {
-            Accept: "application/json"
-          },
-          signal: AbortSignal.timeout(this.fetchTimeoutMs)
-        }
-      );
-      if (typeof overrides === "object" && overrides !== null) {
-        return overrides;
-      }
-      return;
-    } catch (error) {
-      console.warn(
-        "Unable to load merchant overrides, using theme defaults:",
-        this.extractErrorMessage(error)
-      );
-      return;
-    }
-  };
-  /**
-   * Generate fallback page with default structure when page data is unavailable.
-   * Used internally when API returns no page or when page needs default content.
-   *
-   * @param message - Custom message to display in the fallback page
-   * @returns HydrogenPageData with single main component containing the message
-   */
-  generateFallbackPage = (message) => {
-    const rootId = crypto.randomUUID();
-    return {
-      id: `fallback_page_${Date.now()}`,
-      rootId,
-      name: "Default Page",
-      items: [
-        {
-          type: "main",
-          id: rootId,
-          data: { dangerouslySetInnerHTML: { __html: message } }
-        }
-      ]
-    };
-  };
-  /**
-   * Fetch all published custom pages for sitemap generation.
-   * Paginates automatically, never throws, returns accumulated results on partial failure.
-   */
-  async fetchCustomPages(opts) {
-    const { weaverseApiBase, projectId } = this.configs;
-    const entries = [];
-    const MAX_PAGES = 100;
-    let cursor = null;
-    for (let i = 0; i < MAX_PAGES; i++) {
-      const params = new URLSearchParams();
-      if (opts?.locale) {
-        params.set("locale", opts.locale);
-      }
-      if (opts?.limit) {
-        params.set("limit", String(opts.limit));
-      }
-      if (cursor) {
-        params.set("cursor", cursor);
-      }
-      const qs = params.toString();
-      const url = `${weaverseApiBase}/api/public/v1/projects/${projectId}/custom-pages${qs ? `?${qs}` : ""}`;
-      try {
-        const result = await this.fetchWithCache(url, { cacheTarget: "custom-pages" });
-        entries.push(...result.data || []);
-        if (!result.nextCursor) {
-          return entries;
-        }
-        cursor = result.nextCursor;
-      } catch (err) {
-        const status = err?.status;
-        const msg = err?.message || String(err);
-        console.warn(
-          entries.length === 0 ? `[Weaverse] Failed to fetch custom pages: ${msg}${status ? ` (HTTP ${status})` : ""}` : `[Weaverse] Custom pages pagination interrupted: ${msg}`
-        );
-        return entries;
-      }
-    }
-    console.warn(
-      "[Weaverse] Custom pages pagination cap reached (100 iterations)"
-    );
-    return entries;
-  }
-  /**
-   * Load page data from Weaverse API with optional route-level project override.
-   * Fetches page content, executes component loaders, and handles empty items fallback.
-   *
-   * @param params - Optional page loading parameters
-   * @param params.type - Page type (INDEX, PAGE, PRODUCT, COLLECTION, etc.)
-   * @param params.handle - Page handle for dynamic routes
-   * @param params.locale - Locale override
-   * @param params.projectId - Route-level project ID override (for multi-project)
-   * @param params.strategy - Custom cache strategy override
-   * @returns Promise resolving to page data or null on error
-   *
-   * @example
-   * ```typescript
-   * // Basic usage
-   * const data = await weaverse.loadPage()
-   *
-   * // With page type
-   * const data = await weaverse.loadPage({ type: 'INDEX' })
-   *
-   * // Route-level project override
-   * const data = await weaverse.loadPage({
-   *   type: 'PAGE',
-   *   handle: 'about',
-   *   projectId: 'campaign-project-123'
-   * })
-   * ```
-   */
-  loadPage = async (params = {}) => {
-    try {
-      const { request, storefront, basePageRequestBody, basePageConfigs } = this;
-      const {
-        projectId: clientProjectId,
-        weaverseHost,
-        isPreviewMode,
-        sectionType
-      } = this.configs;
-      if (params.projectId !== void 0) {
-        if (typeof params.projectId !== "string") {
-          console.error(
-            `Route-level projectId validation failed: must be a string. Received: ${typeof params.projectId}`
-          );
-          return null;
-        }
-        const validation = this.validateProjectId(params.projectId);
-        if (!validation.valid) {
-          console.error(
-            `Route-level projectId validation failed: ${validation.error}`
-          );
-          return null;
-        }
-      }
-      const effectiveProjectId = params.projectId || clientProjectId;
-      if (isPreviewMode) {
-        return getPreviewData(sectionType || "", this.components, weaverseHost);
-      }
-      if (!effectiveProjectId) {
-        throw new Error("Missing Weaverse projectId!");
-      }
-      const { strategy, ...pageLoadParams } = params;
-      const body = {
-        ...basePageRequestBody,
-        projectId: effectiveProjectId,
-        // Use effective (potentially overridden) projectId
-        params: pageLoadParams,
-        // Stripped to pathname + Weaverse params — tracking params would
-        // fragment the subrequest cache key (see normalizePageUrl).
-        url: normalizePageUrl(request.url)
-      };
-      const reqInit = {
-        method: "POST",
-        body: JSON.stringify(body),
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-          "Accept-Encoding": "gzip, deflate, br",
-          "X-Visitor-UA": request.headers.get("user-agent") || ""
-        }
-      };
-      const url = this.getApiUrl("project");
-      const projectData = await this.fetchWithCache(url, {
-        ...reqInit,
-        cacheTarget: "project",
-        strategy
-      });
-      if (hasError(projectData)) {
-        throw new Error(projectData.error);
-      }
-      let page;
-      let project;
-      let pageAssignment;
-      if (isFetchProjectPayload(projectData)) {
-        page = projectData.page;
-        project = projectData.project;
-        pageAssignment = projectData.pageAssignment;
-      } else {
-        console.warn(
-          "Invalid project data structure received from API, using fallback data",
-          { projectId: effectiveProjectId }
-        );
-        const responseData = projectData;
-        page = responseData?.page;
-        project = responseData?.project;
-        pageAssignment = responseData?.pageAssignment;
-      }
-      if (!project) {
-        console.warn("Weaverse project not found. Id:", effectiveProjectId);
-        project = {
-          id: effectiveProjectId,
-          name: "Weaverse project not found.",
-          weaverseShopId: ""
-        };
-      }
-      if (!page) {
-        page = this.generateFallbackPage(
-          '<div style="text-align: center;">Please add new section to start.</div>'
-        );
-      }
-      if (page?.items?.length === 0) {
-        page.items.push({
-          type: "main",
-          id: page.rootId || crypto.randomUUID(),
-          data: {}
-        });
-      }
-      if (page?.items) {
-        const items = page.items;
-        page.items = await Promise.all(items.map(this.execComponentLoader));
-      }
-      return {
-        page,
-        project,
-        pageAssignment,
-        configs: {
-          ...basePageConfigs,
-          requestInfo: {
-            i18n: storefront.i18n,
-            queries: getRequestQueries(request),
-            pathname: this.parsedUrl.pathname,
-            search: this.parsedUrl.search
-          }
-        }
-      };
-    } catch (error) {
-      const errorMessage = "\u274C Page load failed";
-      const errorContext = {
-        projectId: params.projectId || this.configs.projectId
-      };
-      if (error instanceof WeaverseError) {
-        console.error(errorMessage, {
-          code: error.code,
-          message: error.message,
-          ...errorContext,
-          ...error.context
-        });
-      } else if (error instanceof Error) {
-        console.error(errorMessage, {
-          message: error.message,
-          stack: error.stack,
-          ...errorContext
-        });
-      } else {
-        console.error(errorMessage, {
-          error: String(error),
-          ...errorContext
-        });
-      }
-      return null;
-    }
-  };
-  /** Executes the registered loader for one component and attaches its result. */
-  execComponentLoader = async (item) => {
-    const { data = {}, type, id } = item;
-    const component = this.componentsByType.get(type);
-    const loader = component?.loader;
-    if (typeof loader === "function" && component) {
-      try {
-        return {
-          ...item,
-          loaderData: await Promise.resolve(
-            loader({
-              data: { ...generateDataFromSchema(component.schema), ...data },
-              weaverse: this
-            })
-          )
-        };
-      } catch (error) {
-        console.warn("\u274C Item loader run failed.", type, id, error);
-        return item;
-      }
-    }
-    return item;
-  };
+	/** Builder API version used by this client. */
+	API = API_PATH;
+	/** Stable project configuration shared by page requests. */
+	basePageConfigs;
+	/** Stable request body fields shared by page requests. */
+	basePageRequestBody;
+	/** Resolved project and rendering-mode configuration. */
+	configs;
+	/** Hydrogen cache wrapper used for Builder API requests. */
+	withCache;
+	/** Incoming request associated with this client instance. */
+	request;
+	/** Hydrogen customer-account client, when configured. */
+	customerAccount;
+	/** Hydrogen Storefront API client and locale context. */
+	storefront;
+	/** Components registered for page rendering and component loaders. */
+	components;
+	/** Theme schema used for defaults and Studio editing. */
+	themeSchema;
+	/** Hydrogen runtime environment variables. */
+	env;
+	/** Cache storage supplied by the Hydrogen runtime. */
+	cache;
+	/** Background execution hook supplied by the Oxygen runtime. */
+	waitUntil;
+	parsedUrl;
+	componentsByType;
+	fetchTimeoutMs;
+	throwPageLoadFailures;
+	/** Creates a request-scoped client from the Hydrogen app context. */
+	constructor(args) {
+		this.request = args.request;
+		this.storefront = args.storefront;
+		this.customerAccount = args.customerAccount;
+		this.components = args.components;
+		this.themeSchema = args.themeSchema;
+		this.env = args.env;
+		this.cache = args.cache;
+		this.waitUntil = args.waitUntil;
+		this.parsedUrl = new URL(args.request.url);
+		this.componentsByType = this.buildComponentLookupMap(args.components);
+		this.fetchTimeoutMs = args.fetchTimeoutMs || DEFAULT_FETCH_TIMEOUT_MS;
+		this.throwPageLoadFailures = args.throwPageLoadFailures === true;
+		this.initializeCache(args);
+		this.initializeConfigs(args);
+	}
+	/**
+	* Initialize Hydrogen cache with proper configuration.
+	* Logs warning if waitUntil is missing.
+	*/
+	initializeCache(args) {
+		if (!args.waitUntil) console.warn("⚠️ WeaverseClient: waitUntil not provided, background operations may not complete");
+		this.withCache = (0, _shopify_hydrogen.createWithCache)({
+			cache: args.cache,
+			waitUntil: args.waitUntil || (() => Promise.resolve()),
+			request: args.request
+		});
+	}
+	/**
+	* Initialize configs with projectId resolution and fail-fast validation.
+	* Throws WeaverseError if projectId cannot be resolved.
+	*/
+	initializeConfigs(args) {
+		const baseConfigs = getWeaverseConfigs(args.request, args.env);
+		const resolvedProjectId = this.resolveProjectIdSync(args.projectId, args.request, args.env, baseConfigs);
+		if (!resolvedProjectId || resolvedProjectId.trim() === "") throw new WeaverseError("Failed to initialize WeaverseClient: No valid projectId found. Set WEAVERSE_PROJECT_ID environment variable or provide projectId parameter.", "MISSING_PROJECT_ID");
+		this.configs = {
+			...baseConfigs,
+			projectId: resolvedProjectId
+		};
+		this.basePageConfigs = {
+			projectId: this.configs.projectId,
+			weaverseHost: this.configs.weaverseHost,
+			weaverseApiBase: this.configs.weaverseApiBase,
+			weaverseApiKey: this.configs.weaverseApiKey,
+			weaverseVersion: this.configs.weaverseVersion,
+			isDesignMode: this.configs.isDesignMode,
+			isPreviewMode: this.configs.isPreviewMode,
+			isRevisionPreview: this.configs.isRevisionPreview
+		};
+		this.basePageRequestBody = {
+			isDesignMode: this.configs.isDesignMode,
+			i18n: args.storefront.i18n,
+			projectId: this.configs.projectId
+		};
+		Object.freeze(this.configs);
+		Object.freeze(this.basePageConfigs);
+		Object.freeze(this.basePageRequestBody);
+	}
+	/**
+	* Build component lookup map for O(1) access by type.
+	* Significantly improves performance for large component lists.
+	*/
+	buildComponentLookupMap(components) {
+		return new Map(components.map((comp) => [comp.schema?.type, comp]));
+	}
+	/**
+	* Extract comprehensive error information from unknown error type.
+	* Preserves error context, codes, and stack traces for debugging.
+	*
+	* @param error - Unknown error to extract information from
+	* @returns Structured error information with message, code, stack, and context
+	*
+	* @example
+	* ```typescript
+	* try {
+	*   // ... operation
+	* } catch (error) {
+	*   const errorInfo = this.extractErrorInfo(error)
+	*   console.error('Operation failed:', errorInfo.message, errorInfo.context)
+	* }
+	* ```
+	*/
+	extractErrorInfo(error) {
+		if (error instanceof WeaverseError) return {
+			message: error.message,
+			code: error.code,
+			context: error.context,
+			stack: error.stack
+		};
+		if (error instanceof Error) return {
+			message: error.message,
+			stack: error.stack
+		};
+		return { message: String(error) };
+	}
+	/**
+	* Extract error message only (for backward compatibility).
+	* Use extractErrorInfo() for more detailed error information.
+	*
+	* @deprecated Use extractErrorInfo() instead to preserve error context
+	*/
+	extractErrorMessage(error) {
+		return this.extractErrorInfo(error).message;
+	}
+	/**
+	* Validates projectId format (alphanumeric, hyphens, underscores only).
+	* Returns detailed validation result with error message.
+	*
+	* @param projectId - Project identifier to validate
+	* @returns Validation result with error message if invalid
+	*/
+	validateProjectId(projectId) {
+		if (!projectId || projectId.trim() === "") return {
+			valid: false,
+			error: "Project ID cannot be empty"
+		};
+		if (!/^[a-zA-Z0-9_-]+$/.test(projectId)) return {
+			valid: false,
+			error: `Invalid format: "${projectId}". Only alphanumeric characters, hyphens, and underscores are allowed.`
+		};
+		return { valid: true };
+	}
+	/**
+	* Resolves projectId with multi-project architecture support.
+	* Uses priority chain to determine the correct project ID.
+	*
+	* @param projectId - Project identifier (string, function, or undefined)
+	* @param request - HTTP request for context access
+	* @param env - Hydrogen environment with variables
+	* @param baseConfigs - Pre-fetched base configs to avoid duplicate calls
+	* @returns Resolved project ID string (empty string if none found)
+	*/
+	resolveProjectIdSync(projectId, request, env, baseConfigs) {
+		return this.resolveFromQueryParams(request) || this.resolveFromFunction(projectId) || this.resolveFromString(projectId) || this.resolveFromEnvironment(baseConfigs, request, env) || "";
+	}
+	/**
+	* Priority 1: Resolve projectId from URL query parameters.
+	* Used for design mode and preview mode overrides.
+	*/
+	resolveFromQueryParams(request) {
+		return getRequestQueries(request).weaverseProjectId || null;
+	}
+	/**
+	* Priority 2: Resolve projectId from function parameter.
+	* Detects and rejects async functions with helpful error.
+	*/
+	resolveFromFunction(projectId) {
+		if (!isProjectIdFunction(projectId)) return null;
+		if (projectId.constructor.name === "AsyncFunction") throw new WeaverseError("Async projectId functions must be awaited before passing to WeaverseClient. Use: projectId: await getProjectAsync() instead of: projectId: getProjectAsync", "ASYNC_PROJECT_ID");
+		try {
+			const result = projectId();
+			if (result instanceof Promise) throw new WeaverseError("Async projectId functions must be awaited before passing to WeaverseClient. Use: projectId: await getProjectAsync() instead of: projectId: getProjectAsync", "ASYNC_PROJECT_ID");
+			if (result && result.trim() !== "") {
+				const trimmed = result.trim();
+				const validation = this.validateProjectId(trimmed);
+				if (validation.valid) return trimmed;
+				throw new WeaverseError(validation.error || "Invalid projectId format", "INVALID_PROJECT_ID");
+			}
+		} catch (err) {
+			if (err instanceof WeaverseError) throw err;
+			throw new WeaverseError(`Failed to evaluate projectId function: ${err instanceof Error ? err.message : String(err)}`, "PROJECT_ID_FUNCTION_ERROR", void 0, { cause: err instanceof Error ? err.stack : String(err) });
+		}
+		return null;
+	}
+	/**
+	* Priority 3: Resolve projectId from explicit string parameter.
+	*/
+	resolveFromString(projectId) {
+		if (typeof projectId !== "string") return null;
+		const trimmed = projectId.trim();
+		if (trimmed === "") return null;
+		const validation = this.validateProjectId(trimmed);
+		if (validation.valid) return trimmed;
+		throw new WeaverseError(validation.error || "Invalid projectId format", "INVALID_PROJECT_ID");
+	}
+	/**
+	* Priority 4: Resolve projectId from environment variables.
+	*/
+	resolveFromEnvironment(baseConfigs, request, env) {
+		const configs = baseConfigs || getWeaverseConfigs(request, env);
+		if (configs.projectId && configs.projectId.trim() !== "") return configs.projectId.trim();
+		return null;
+	}
+	/**
+	* Helper method for direct fetching in design mode.
+	* Returns same format as withCache.fetch for consistency.
+	* Includes 10-second timeout to prevent hanging requests.
+	*/
+	fetchOnce = async (url, options, timeoutMs) => {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+		try {
+			const response = await fetch(url, {
+				...options,
+				signal: controller.signal
+			});
+			if (!response.ok) {
+				const errorText = await response.text();
+				throw new WeaverseError(`HTTP ${response.status}: ${response.statusText}`, "FETCH_ERROR", response.status, {
+					url,
+					errorText
+				});
+			}
+			let data;
+			try {
+				data = await response.json();
+			} catch (parseError) {
+				if (parseError?.name === "AbortError") throw parseError;
+				throw new WeaverseError("Response body is not valid JSON", "INVALID_RESPONSE", response.status, { url });
+			}
+			return {
+				data,
+				response
+			};
+		} catch (err) {
+			if (err instanceof WeaverseError) throw err;
+			if (err.name === "AbortError") throw new WeaverseError(`Request timeout after ${timeoutMs}ms`, "TIMEOUT_ERROR", void 0, {
+				url,
+				timeoutMs
+			});
+			throw new WeaverseError("Network error during fetch", "NETWORK_ERROR", void 0, {
+				url,
+				cause: err instanceof Error ? err.message : String(err)
+			});
+		} finally {
+			if (timeoutId !== void 0) clearTimeout(timeoutId);
+		}
+	};
+	directFetch = async (url, options = {}, timeoutMs = this.fetchTimeoutMs) => {
+		let lastError;
+		for (let attempt = 1; attempt <= MAX_FETCH_ATTEMPTS; attempt++) try {
+			return await this.fetchOnce(url, options, timeoutMs);
+		} catch (err) {
+			lastError = err;
+			if (attempt >= MAX_FETCH_ATTEMPTS || !isRetryableFetchError(err)) throw err;
+			await new Promise((resolve) => setTimeout(resolve, FETCH_RETRY_BACKOFF_MS * attempt));
+		}
+		throw lastError;
+	};
+	getApiUrl(endpoint) {
+		const { weaverseApiBase } = this.configs;
+		return `${weaverseApiBase}/api/public/${endpoint}`;
+	}
+	isExternalPublicApiUrl(url) {
+		const { weaverseApiBase, weaverseHost } = this.configs;
+		return weaverseApiBase !== weaverseHost && url.startsWith(`${weaverseApiBase}/api/public/`);
+	}
+	/**
+	* Fetch data with caching support for both design mode and production.
+	* Uses direct fetch in design mode, Hydrogen's withCache in production.
+	* Automatically includes projectId in cache key for multi-project isolation.
+	*
+	* @param url - The URL to fetch from
+	* @param options - Fetch options including optional cache strategy
+	* @returns Promise resolving to the fetched data
+	*
+	* @example
+	* ```typescript
+	* const data = await weaverse.fetchWithCache<MyData>(
+	*   'https://api.example.com/data',
+	*   { method: 'POST', body: JSON.stringify({ key: 'value' }) }
+	* )
+	* ```
+	*/
+	fetchWithCache = async (url, options = {}) => {
+		const { cacheTarget, strategy: strategyOverride, ...fetchOptions } = options;
+		const strategy = strategyOverride || (0, _shopify_hydrogen.CacheCustom)(cacheTarget ? SMART_CACHE_STRATEGIES[cacheTarget] : DEFAULT_CACHE_STRATEGY);
+		const cacheKey = [
+			"weaverse-fetch",
+			url,
+			options.method || "GET",
+			bodyFreeCacheRequests.has(options) ? BODY_FREE_CACHE_SENTINEL : fetchOptions.body,
+			bodyFreeCacheRequests.has(options),
+			this.configs.projectId,
+			cacheTarget || "default"
+		];
+		let result;
+		const validateBuilderPayload = builderPayloadValidators.get(options);
+		if (this.configs.isDesignMode || this.configs.isRevisionPreview || this.isExternalPublicApiUrl(url)) result = await this.directFetch(url, fetchOptions);
+		else {
+			const cachedFetch = this.withCache.fetch(url, fetchOptions, {
+				cacheKey,
+				cacheStrategy: strategy,
+				shouldCacheResponse: (response) => {
+					if (fetchOptions.signal?.aborted) return false;
+					if (validateBuilderPayload && !validateBuilderPayload(response)) return false;
+					return !hasError(response) && response !== null && response !== void 0;
+				},
+				displayName: "Weaverse API"
+			});
+			result = await (validateBuilderPayload ? cachedFetch.catch((error) => {
+				throw cachedTransportError(error, url);
+			}) : cachedFetch);
+			const { response } = result;
+			if (validateBuilderPayload && response && !response.ok) throw new WeaverseError(`HTTP ${response.status}: ${response.statusText}`, "FETCH_ERROR", response.status, { url });
+		}
+		return result.data;
+	};
+	/**
+	* Safe origin of the incoming storefront request: scheme, host and explicit
+	* port. Userinfo, path, query and fragment are dropped, so no customer
+	* route or credential-bearing value leaves the storefront. Returns undefined
+	* for a non-http(s) request so the field is simply omitted.
+	*/
+	safeStorefrontOrigin() {
+		const { protocol, host } = this.parsedUrl;
+		if (protocol !== "http:" && protocol !== "https:") return;
+		return host ? `${protocol}//${host}` : void 0;
+	}
+	/**
+	* Load theme settings from Weaverse API with fallback to schema defaults.
+	* Merges remote settings with local theme schema and handles design mode serialization.
+	*
+	* @param strategy - Optional cache strategy override
+	* @returns Promise resolving to theme settings response
+	*
+	* @example
+	* ```typescript
+	* const settings = await weaverse.loadThemeSettings()
+	* const primaryColor = settings.theme.colors?.primary
+	* ```
+	*/
+	loadThemeSettings = async (strategy) => {
+		const defaultThemeSettings = generateDataFromSchema(this.themeSchema);
+		try {
+			const { configs } = this;
+			const { projectId, isDesignMode } = configs;
+			if (!projectId) throw new Error("Missing Weaverse projectId!");
+			const url = this.getApiUrl("project_configs");
+			const themeSettingsOptions = {
+				method: "POST",
+				cacheTarget: "theme-settings",
+				strategy,
+				body: JSON.stringify({
+					isDesignMode,
+					projectId,
+					storefrontUrl: this.safeStorefrontOrigin()
+				}),
+				headers: {
+					"Content-Type": "application/json",
+					Accept: "application/json",
+					"Accept-Encoding": "gzip, deflate, br"
+				}
+			};
+			bodyFreeCacheRequests.add(themeSettingsOptions);
+			builderPayloadValidators.set(themeSettingsOptions, isThemeConfigsEnvelope);
+			const [data, merchantOverrides] = await Promise.all([this.fetchWithCache(url, themeSettingsOptions), this.fetchMerchantOverrides(strategy)]);
+			if (!isThemeConfigsEnvelope(data)) throw new WeaverseError("Invalid theme settings response format", "INVALID_RESPONSE");
+			let result = data;
+			if (this.themeSchema?.settings || this.themeSchema?.inspector) if (!result.theme || typeof result.theme !== "object") result.theme = defaultThemeSettings;
+			else result.theme = {
+				...defaultThemeSettings,
+				...result.theme
+			};
+			const staticContent = this.themeSchema?.i18n?.staticContent;
+			if (staticContent) result.staticContent = staticContent;
+			if (merchantOverrides) result.merchantOverrides = merchantOverrides;
+			if (this.configs.isDesignMode) result = {
+				...result,
+				schema: this.themeSchema && typeof this.themeSchema === "object" ? {
+					...this.themeSchema,
+					settings: this.themeSchema?.settings?.map((group) => ({
+						...group,
+						inputs: group?.inputs?.map((input) => {
+							if (typeof input?.condition === "function") return {
+								...input,
+								condition: input.condition.toString()
+							};
+							return input;
+						})
+					}))
+				} : void 0,
+				publicEnv: this.configs.publicEnv
+			};
+			return result;
+		} catch (error) {
+			const errorMessage = "Unable to load theme settings";
+			const errorDetails = this.extractErrorMessage(error);
+			console.error(errorMessage, errorDetails);
+			return {
+				theme: defaultThemeSettings,
+				staticContent: this.themeSchema?.i18n?.staticContent,
+				_error: errorDetails,
+				_loadFailed: true
+			};
+		}
+	};
+	/**
+	* Fetch locale-specific merchant overrides from the translation API.
+	* Returns a nested JSON object with translated values.
+	* Falls back to empty object on error to avoid blocking theme rendering.
+	*/
+	fetchMerchantOverrides = async (strategy) => {
+		try {
+			const { projectId, weaverseHost } = this.configs;
+			const i18n = this.storefront.i18n;
+			if (!this.themeSchema?.i18n) return;
+			if (!(projectId && weaverseHost)) return;
+			const url = `${weaverseHost}/api/translation/static?projectId=${projectId}&locale=${`${(i18n?.language || "en").toLowerCase()}-${(i18n?.country || "us").toLowerCase()}`}`;
+			const overrides = await this.fetchWithCache(url, {
+				method: "GET",
+				cacheTarget: "merchant-overrides",
+				strategy,
+				headers: { Accept: "application/json" },
+				signal: AbortSignal.timeout(this.fetchTimeoutMs)
+			});
+			if (typeof overrides === "object" && overrides !== null) return overrides;
+			return;
+		} catch (error) {
+			console.warn("Unable to load merchant overrides, using theme defaults:", this.extractErrorMessage(error));
+			return;
+		}
+	};
+	/**
+	* Generate fallback page with default structure when page data is unavailable.
+	* Used internally when API returns no page or when page needs default content.
+	*
+	* @param message - Custom message to display in the fallback page
+	* @returns HydrogenPageData with single main component containing the message
+	*/
+	generateFallbackPage = (message) => {
+		const rootId = crypto.randomUUID();
+		return {
+			id: `fallback_page_${Date.now()}`,
+			rootId,
+			name: "Default Page",
+			items: [{
+				type: "main",
+				id: rootId,
+				data: { dangerouslySetInnerHTML: { __html: message } }
+			}]
+		};
+	};
+	/**
+	* Fetch all published custom pages for sitemap generation.
+	* Paginates automatically, never throws, returns accumulated results on partial failure.
+	*/
+	async fetchCustomPages(opts) {
+		const { weaverseApiBase, projectId } = this.configs;
+		const entries = [];
+		const MAX_PAGES = 100;
+		let cursor = null;
+		for (let i = 0; i < MAX_PAGES; i++) {
+			const params = new URLSearchParams();
+			if (opts?.locale) params.set("locale", opts.locale);
+			if (opts?.limit) params.set("limit", String(opts.limit));
+			if (cursor) params.set("cursor", cursor);
+			const qs = params.toString();
+			const url = `${weaverseApiBase}/api/public/v1/projects/${projectId}/custom-pages${qs ? `?${qs}` : ""}`;
+			try {
+				const result = await this.fetchWithCache(url, { cacheTarget: "custom-pages" });
+				entries.push(...result.data || []);
+				if (!result.nextCursor) return entries;
+				cursor = result.nextCursor;
+			} catch (err) {
+				const status = err?.status;
+				const msg = err?.message || String(err);
+				console.warn(entries.length === 0 ? `[Weaverse] Failed to fetch custom pages: ${msg}${status ? ` (HTTP ${status})` : ""}` : `[Weaverse] Custom pages pagination interrupted: ${msg}`);
+				return entries;
+			}
+		}
+		console.warn("[Weaverse] Custom pages pagination cap reached (100 iterations)");
+		return entries;
+	}
+	/**
+	* Load page data from Weaverse API with optional route-level project override.
+	* Fetches page content, executes component loaders, and handles empty items fallback.
+	*
+	* @param params - Optional page loading parameters
+	* @param params.type - Page type (INDEX, PAGE, PRODUCT, COLLECTION, etc.)
+	* @param params.handle - Page handle for dynamic routes
+	* @param params.locale - Locale override
+	* @param params.projectId - Route-level project ID override (for multi-project)
+	* @param params.strategy - Custom cache strategy override
+	* @returns Promise resolving to page data or null on error
+	*
+	* @example
+	* ```typescript
+	* // Basic usage
+	* const data = await weaverse.loadPage()
+	*
+	* // With page type
+	* const data = await weaverse.loadPage({ type: 'INDEX' })
+	*
+	* // Route-level project override
+	* const data = await weaverse.loadPage({
+	*   type: 'PAGE',
+	*   handle: 'about',
+	*   projectId: 'campaign-project-123'
+	* })
+	* ```
+	*/
+	loadPage = async (params = {}) => {
+		if (params.projectId !== void 0) {
+			const message = typeof params.projectId === "string" ? this.validateProjectId(params.projectId).error : `must be a string. Received: ${typeof params.projectId}`;
+			if (message) {
+				console.error(`Route-level projectId validation failed: ${message}`);
+				if (this.throwPageLoadFailures) throw new WeaverseLoadError("Route-level projectId validation failed", "configuration");
+				return null;
+			}
+		}
+		try {
+			const { request, storefront, basePageRequestBody, basePageConfigs } = this;
+			const { projectId: clientProjectId, weaverseHost, isPreviewMode, sectionType } = this.configs;
+			const effectiveProjectId = params.projectId || clientProjectId;
+			if (isPreviewMode) return getPreviewData(sectionType || "", this.components, weaverseHost);
+			if (!effectiveProjectId) throw new WeaverseLoadError("Missing Weaverse projectId!", "configuration");
+			const { strategy, ...pageLoadParams } = params;
+			const body = {
+				...basePageRequestBody,
+				projectId: effectiveProjectId,
+				params: pageLoadParams,
+				url: normalizePageUrl(request.url)
+			};
+			const reqInit = {
+				method: "POST",
+				body: JSON.stringify(body),
+				headers: {
+					"Content-Type": "application/json",
+					Accept: "application/json",
+					"Accept-Encoding": "gzip, deflate, br",
+					"X-Visitor-UA": request.headers.get("user-agent") || ""
+				}
+			};
+			const url = this.getApiUrl("project");
+			const projectOptions = {
+				...reqInit,
+				cacheTarget: "project",
+				strategy
+			};
+			builderPayloadValidators.set(projectOptions, isProjectEnvelope);
+			const projectData = await this.fetchWithCache(url, projectOptions);
+			if (hasError(projectData)) throw new WeaverseLoadError("Weaverse API returned an error body", "invalid-response");
+			if (!isProjectEnvelope(projectData)) {
+				if (this.throwPageLoadFailures) throw new WeaverseLoadError("Invalid project data structure received from API", "invalid-response");
+				console.warn("Invalid project data structure received from API, using fallback data", { projectId: effectiveProjectId });
+			}
+			const responseData = projectData;
+			let page = responseData?.page ?? void 0;
+			let project = responseData?.project;
+			const pageAssignment = responseData?.pageAssignment;
+			if (!project) {
+				console.warn("Weaverse project not found. Id:", effectiveProjectId);
+				project = {
+					id: effectiveProjectId,
+					name: "Weaverse project not found.",
+					weaverseShopId: ""
+				};
+			}
+			if (!page) page = this.generateFallbackPage("<div style=\"text-align: center;\">Please add new section to start.</div>");
+			if (page?.items?.length === 0) page.items.push({
+				type: "main",
+				id: page.rootId || crypto.randomUUID(),
+				data: {}
+			});
+			if (page?.items) {
+				const items = page.items;
+				page.items = await Promise.all(items.map(this.execComponentLoader));
+			}
+			return {
+				page,
+				project,
+				pageAssignment,
+				configs: {
+					...basePageConfigs,
+					requestInfo: {
+						i18n: storefront.i18n,
+						queries: getRequestQueries(request),
+						pathname: this.parsedUrl.pathname,
+						search: this.parsedUrl.search
+					}
+				}
+			};
+		} catch (error) {
+			const failure = classifyPageLoadFailure(error);
+			const errorMessage = "❌ Page load failed";
+			const errorContext = { projectId: params.projectId || this.configs.projectId };
+			if (error instanceof WeaverseError) console.error(errorMessage, {
+				code: error.code,
+				message: error.message,
+				...errorContext,
+				...error.context
+			});
+			else if (error instanceof Error) console.error(errorMessage, {
+				message: error.message,
+				stack: error.stack,
+				...errorContext
+			});
+			else console.error(errorMessage, {
+				error: String(error),
+				...errorContext
+			});
+			if (failure === "absent" || !this.throwPageLoadFailures) return null;
+			if (error instanceof WeaverseLoadError) throw error;
+			throw new WeaverseLoadError("Unable to load Weaverse page", failure, error instanceof WeaverseError ? error.statusCode : void 0);
+		}
+	};
+	/** Executes the registered loader for one component and attaches its result. */
+	execComponentLoader = async (item) => {
+		const { data = {}, type, id } = item;
+		const component = this.componentsByType.get(type);
+		const loader = component?.loader;
+		if (typeof loader === "function" && component) try {
+			return {
+				...item,
+				loaderData: await Promise.resolve(loader({
+					data: {
+						...generateDataFromSchema(component.schema),
+						...data
+					},
+					weaverse: this
+				}))
+			};
+		} catch (error) {
+			console.warn("❌ Item loader run failed.", type, id, error);
+			return item;
+		}
+		return item;
+	};
 };
-
-// src/index.ts
+//#endregion
+//#region src/index.ts
+/**
+* React and React Router integrations for rendering Weaverse content in
+* Shopify Hydrogen storefronts.
+*
+* @packageDocumentation
+*/
+/**
+* Filter out Weaverse-specific query parameters from product options.
+* Removes `isDesignMode` and any parameters starting with `weaverse` prefix.
+*
+* @param request - The incoming HTTP request
+* @returns Filtered product options for Shopify Hydrogen
+*
+* @example
+* ```typescript
+* export async function loader({ request }: LoaderFunctionArgs) {
+*   const selectedOptions = getSelectedProductOptions(request)
+*   // Use selectedOptions for product queries without Weaverse params
+* }
+* ```
+*/
 function getSelectedProductOptions(request) {
-  let options = hydrogen.getSelectedProductOptions(request);
-  return options.filter(
-    ({ name }) => name !== "isDesignMode" && !name.startsWith("weaverse")
-  );
+	return (0, _shopify_hydrogen.getSelectedProductOptions)(request).filter(({ name }) => name !== "isDesignMode" && !name.startsWith("weaverse"));
 }
-
-Object.defineProperty(exports, "isBrowser", {
-  enumerable: true,
-  get: function () { return react.isBrowser; }
-});
-Object.defineProperty(exports, "isIframe", {
-  enumerable: true,
-  get: function () { return react.isIframe; }
-});
-Object.defineProperty(exports, "useChildInstances", {
-  enumerable: true,
-  get: function () { return react.useChildInstances; }
-});
-Object.defineProperty(exports, "useItemInstance", {
-  enumerable: true,
-  get: function () { return react.useItemInstance; }
-});
-Object.defineProperty(exports, "useParentInstance", {
-  enumerable: true,
-  get: function () { return react.useParentInstance; }
-});
-Object.defineProperty(exports, "useWeaverse", {
-  enumerable: true,
-  get: function () { return react.useWeaverse; }
-});
+//#endregion
 exports.ThemeTextProvider = ThemeTextProvider;
 exports.ThemeTextStore = ThemeTextStore;
 exports.TranslationProvider = TranslationProvider;
@@ -2241,6 +2411,7 @@ exports.WeaverseError = WeaverseError;
 exports.WeaverseHydrogen = WeaverseHydrogen;
 exports.WeaverseHydrogenItem = WeaverseHydrogenItem;
 exports.WeaverseHydrogenRoot = WeaverseHydrogenRoot;
+exports.WeaverseLoadError = WeaverseLoadError;
 exports.createWeaverseDataContext = createWeaverseDataContext;
 exports.defaultComponents = defaultComponents;
 exports.formatMetaDescriptors = formatMetaDescriptors;
@@ -2254,22 +2425,30 @@ exports.getWeaverseSeoMeta = getWeaverseSeoMeta;
 exports.hasError = hasError;
 exports.hasWeaverseStudio = hasWeaverseStudio;
 exports.interpolate = interpolate;
+exports.isBrowser = _weaverse_react.isBrowser;
 exports.isFetchProjectPayload = isFetchProjectPayload;
+exports.isIframe = _weaverse_react.isIframe;
 exports.isProjectIdFunction = isProjectIdFunction;
 exports.isThemeSettingsResponse = isThemeSettingsResponse;
 exports.isValidHydrogenSchema = isValidHydrogenSchema;
 exports.isWithCacheFetchResponse = isWithCacheFetchResponse;
 exports.registerComponent = registerComponent;
+exports.useChildInstances = _weaverse_react.useChildInstances;
+exports.useItemInstance = _weaverse_react.useItemInstance;
+exports.useParentInstance = _weaverse_react.useParentInstance;
 exports.useThemeSettings = useThemeSettings;
 exports.useThemeText = useThemeText;
 exports.useTranslation = useTranslation;
+exports.useWeaverse = _weaverse_react.useWeaverse;
 exports.useWeaverseDataContext = useWeaverseDataContext;
 exports.withWeaverse = withWeaverse;
-Object.keys(schema$1).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return schema$1[k]; }
-  });
+Object.keys(_weaverse_schema).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _weaverse_schema[k];
+		}
+	});
 });
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map