@weaverse/hydrogen 5.24.0 → 6.0.0-beta.0

package/dist/weaverse-client-Clu3u7md.mjs

@@ -0,0 +1,1966 @@
+import { a as getPreviewData, c as getStudioScriptSrc, d as WeaverseLoadError, f as hasError, h as isProjectIdFunction, i as generateDataFromSchema, l as resolveStudioScriptSrc, n as TranslationStore, o as getRequestQueries, p as hasWeaverseStudio, r as getNestedKey, s as getWeaverseConfigs, u as WeaverseError } from "./translation-store-C42QdI0e.mjs";
+import { Weaverse, WeaverseItemStore, WeaverseRoot, isBrowser, loadScript, useSafeExternalStore } from "@weaverse/react";
+import { createSchema } from "@weaverse/schema";
+import { Suspense, createContext, memo, useContext, useEffect, useMemo, useRef } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Cache, createFetchWithCache, getSelectedProductOptions } from "@shopify/hydrogen";
+import { ErrorBoundary } from "react-error-boundary";
+import { Await, useLoaderData, useLocation, useMatches, useNavigate, useNavigation, useRevalidator, useRouteLoaderData } from "react-router";
+//#region src/hooks/translation-context.tsx
+/**
+* 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);
+	});
+}
+const TranslationContext = 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);
+		return interpolate(design ?? override ?? staticValue ?? key, variables);
+	};
+}
+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 = useSafeExternalStore(store?.subscribe ?? NOOP_SUBSCRIBE, store?.getSnapshot ?? NOOP_SNAPSHOT, store?.getServerSnapshot ?? NOOP_SNAPSHOT);
+	const value = useMemo(() => ({
+		t: createTranslate({
+			staticContent,
+			merchantOverrides,
+			designOverrides,
+			externalT
+		}),
+		translationStore: store,
+		themeTextStore: store,
+		merchantOverrides: merchantOverrides ?? null
+	}), [
+		staticContent,
+		merchantOverrides,
+		designOverrides,
+		externalT,
+		store
+	]);
+	return /* @__PURE__ */ 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 = useContext(TranslationContext);
+	if (!ctx) throw new Error("useTranslation must be used within <TranslationProvider>. Wrap your app with withWeaverse().");
+	return ctx;
+}
+/**
+* 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/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;
+}
+/**
+* Convenience accessor: pull `page.seo` out of a `WeaverseLoaderData`
+* (or `WeaversePageData`) 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);
+	return formatMetaDescriptors(("items" in data && "id" in data ? data : data.page ?? null)?.seo ?? null);
+}
+//#endregion
+//#region src/utils/product-options.ts
+/**
+* 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$1(request) {
+	return getSelectedProductOptions({ searchParams: new URL(request.url).searchParams }).filter(({ name }) => name !== "isDesignMode" && !name.startsWith("weaverse"));
+}
+//#endregion
+//#region src/components/main.tsx
+function Main(props) {
+	let { children, dangerouslySetInnerHTML, ...rest } = props;
+	return /* @__PURE__ */ jsx("div", {
+		...rest,
+		children,
+		dangerouslySetInnerHTML: children ? void 0 : dangerouslySetInnerHTML
+	});
+}
+//#endregion
+//#region src/components/index.ts
+/** Built-in components required to render the root of every Weaverse page. */
+let defaultComponents = [{
+	default: Main,
+	schema: createSchema({
+		type: "main",
+		title: "Main"
+	})
+}];
+//#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;
+}
+/**
+* Hook to get flat route-keyed data context from matches
+* Returns: {root: {...}, "routes/xxx": {...}}
+* No more useLoaderData dependency - everything comes from matches
+*/
+function useWeaverseDataContext() {
+	return createFlatDataContext(useMatches());
+}
+/**
+* Helper function to create flat route-keyed data context from useMatches() result
+* Returns: {root: {...}, "routes/xxx": {...}}
+*/
+function createWeaverseDataContext(matches) {
+	return createFlatDataContext(matches);
+}
+//#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;
+}
+function hasWeaverseData(value) {
+	if (typeof value !== "object" || value === null || !("weaverseData" in value)) return false;
+	return value.weaverseData !== void 0;
+}
+//#endregion
+//#region src/utils/studio-request-info.ts
+function getBrowserLocation() {
+	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;
+}
+/**
+* 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
+		}
+	};
+}
+//#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";
+}
+function isObjectLike(value) {
+	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";
+}
+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;
+}
+/** Maps NaN/±Infinity to `null`, matching how `JSON.stringify` renders them. */
+function toFiniteOrNull(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$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);
+}
+//#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();
+}
+//#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, publicEnv } = data || {};
+		this.settings = { ...theme };
+		this.schema = schema;
+		this.publicEnv = publicEnv;
+		if (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 (isBrowser && window.__weaverseThemeSettingsStore === this) window.__weaverseThemeSettingsStore = void 0;
+	};
+};
+const ThemeSettingsStoreContext = createContext(null);
+ThemeSettingsStoreContext.displayName = "ThemeSettingsStoreContext";
+function useCreateThemeSettingsStore() {
+	const data = useRouteLoaderData("root");
+	const storeRef = useRef(null);
+	if (!storeRef.current) storeRef.current = new ThemeSettingsStore(data?.weaverseTheme);
+	const theme = data?.weaverseTheme?.theme;
+	useEffect(() => {
+		if (storeRef.current && theme) storeRef.current.updateThemeSettings(theme);
+	}, [theme]);
+	return storeRef.current;
+}
+function useThemeSettingsStore() {
+	const fromContext = useContext(ThemeSettingsStoreContext);
+	const data = useRouteLoaderData("root");
+	const fallbackRef = useRef(null);
+	if (!(fallbackRef.current || fromContext)) fallbackRef.current = new ThemeSettingsStore(data?.weaverseTheme);
+	const store = fromContext ?? fallbackRef.current;
+	const theme = data?.weaverseTheme?.theme;
+	useEffect(() => {
+		if (!fromContext && theme) store.updateThemeSettings(theme);
+	}, [
+		fromContext,
+		store,
+		theme
+	]);
+	return store;
+}
+//#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();
+	});
+}
+/**
+* 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 } = useLocation();
+	useEffect(() => {
+		let src = resolveStudioScriptSrc(search, typeof window === "undefined" ? "" : window.location.hostname);
+		if (src) loadScript(src).catch(console.error);
+	}, [search]);
+}
+function useStudio(weaverse) {
+	let { revalidate } = useRevalidator();
+	let navigation = useNavigation();
+	let { pathname, search } = useLocation();
+	let navigate = useNavigate();
+	let themeSettingsStore = useThemeSettingsStore();
+	let { translationStore, themeTextStore, merchantOverrides } = useTranslation();
+	let { isDesignMode, weaverseHost, weaverseVersion, isPreviewMode, isRevisionPreview } = weaverse;
+	useEffect(() => {
+		if (navigation.state !== "idle") return;
+		let src = getStudioScriptSrc({
+			isDesignMode,
+			isPreviewMode,
+			isRevisionPreview,
+			weaverseHost,
+			weaverseVersion
+		});
+		if (!src) return;
+		if (isRevisionPreview || isPreviewMode) loadScript(src).catch(console.error);
+		else {
+			weaverse.internal = {
+				...weaverse.internal,
+				navigate,
+				revalidate,
+				merchantOverrides,
+				themeSettingsStore,
+				translationStore,
+				themeTextStore
+			};
+			loadScript(src).then(waitForStudio).then((studio) => studio?.init(weaverse)).catch(console.error);
+		}
+	}, [
+		pathname,
+		search,
+		navigation.state
+	]);
+}
+//#endregion
+//#region src/WeaverseHydrogenRoot.tsx
+/** Runtime store for one rendered Hydrogen component instance. */
+var WeaverseHydrogenItem = class extends 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;
+	};
+};
+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 {
+	/** 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 (isBrowser) {
+		const runtimeWindow = window;
+		runtimeWindow.__weaverses = runtimeWindow.__weaverses || {};
+		const existing = runtimeWindow.__weaverses[normalizedParams.pageId];
+		const isReused = existing?.requestInfo?.pathname === normalizedParams.requestInfo.pathname && existing?.requestInfo?.search === normalizedParams.requestInfo.search;
+		const weaverse = isReused ? existing : new WeaverseHydrogen(normalizedParams);
+		runtimeWindow.__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 StudioBridge = memo(({ context }) => {
+	useStudio(context);
+	return null;
+});
+const StudioConnect = memo(() => {
+	useStudioConnect();
+	return null;
+});
+/**
+* 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__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(WeaverseRoot, { context: weaverse }), /* @__PURE__ */ 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);
+}
+/**
+* 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 = memo(({ components, data: dataProp, errorComponent: ErrorComponent = ({ error }) => /* @__PURE__ */ jsx("div", { children: error instanceof Error ? error.message : "An unexpected error occurred" }) }) => {
+	const matches = useMatches();
+	const enhancedDataContext = useMemo(() => createWeaverseDataContext(matches), [matches]);
+	const ownLoaderData = useLoaderData();
+	const weaverseData = useMemo(() => pickWeaverseData(dataProp, ownLoaderData, matches), [
+		dataProp,
+		ownLoaderData,
+		matches
+	]);
+	if (dataProp === null) return null;
+	if (weaverseData) {
+		if (weaverseData instanceof Promise) return /* @__PURE__ */ jsx(ErrorBoundary, {
+			fallbackRender: ErrorComponent,
+			children: /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(Await, {
+				resolve: weaverseData,
+				children: (resolvedData) => /* @__PURE__ */ jsx(RenderRoot, {
+					components,
+					data: resolvedData,
+					dataContext: enhancedDataContext
+				})
+			}) })
+		});
+		return /* @__PURE__ */ jsx(RenderRoot, {
+			components,
+			data: weaverseData,
+			dataContext: enhancedDataContext
+		});
+	}
+	return /* @__PURE__ */ 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 = useRef(null);
+		if (!translationStoreRef.current) translationStoreRef.current = new TranslationStore();
+		return /* @__PURE__ */ jsx(ThemeSettingsStoreContext.Provider, {
+			value: themeSettingsStore,
+			children: /* @__PURE__ */ jsxs(TranslationProvider, {
+				merchantOverrides: translationData.merchantOverrides,
+				staticContent: translationData.staticContent,
+				t: options?.t,
+				translationStore: translationStoreRef.current,
+				children: [/* @__PURE__ */ jsx(StudioConnect, {}), /* @__PURE__ */ 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 = 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();
+	return useSafeExternalStore(themeSettingsStore.subscribe, themeSettingsStore.getSnapshot, themeSettingsStore.getServerSnapshot);
+}
+//#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 Hydrogen's cached fetch 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, -5);
+	return `${parsed.origin}${pathname}${search ? `?${search}` : ""}`;
+}
+//#endregion
+//#region src/weaverse-client.ts
+/**
+* Cache duration constants (in seconds).
+* These values optimize CDN hit rates while maintaining fresh content.
+*/
+const CACHE_DURATIONS = {
+	/** Freshness for content that can change in Builder */
+	SHORT: 60,
+	/** Long stale window so slow Builder responses do not block storefront rendering */
+	LONG: 86400
+};
+/**
+* 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" || error.code === "INVALID_RESPONSE") return true;
+	return error.code === "FETCH_ERROR" && (error.statusCode ?? 0) >= 500;
+}
+/** Parses a JSON body, or returns the raw text when it is not JSON. */
+function parseResponseText(text) {
+	if (!text) return text;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+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));
+}
+/**
+* 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";
+/**
+* Cache strategy for Weaverse API requests: fresh for a minute, then served
+* stale for a day while it refreshes or while Builder errors.
+*
+* Every Builder resource uses it. Hydrogen 2026.4's subrequest cache only read
+* `max-age` for freshness, so the old per-resource `sMaxAge` values never
+* changed how long an entry stayed fresh.
+*/
+const DEFAULT_CACHE_STRATEGY = Cache({
+	maxAge: CACHE_DURATIONS.SHORT,
+	staleWhileRevalidate: CACHE_DURATIONS.LONG,
+	staleIfError: CACHE_DURATIONS.LONG
+});
+/**
+* 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 cached fetch used for Builder API requests. */
+	cachedFetch;
+	/** Incoming request associated with this client instance. */
+	request;
+	/** Customer Account API client, when the storefront passes one. */
+	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;
+	/** Runtime environment variables. */
+	env;
+	/** Cache storage supplied by the Hydrogen runtime. */
+	cache;
+	/** Background execution hook supplied by the runtime. */
+	waitUntil;
+	parsedUrl;
+	componentsByType;
+	fetchTimeoutMs;
+	throwPageLoadFailures;
+	/** Creates a request-scoped client from the storefront's request 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.cachedFetch = createFetchWithCache({
+			cache: args.cache,
+			waitUntil: args.waitUntil
+		});
+	}
+	/**
+	* 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.
+	* 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 cached fetch 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 || DEFAULT_CACHE_STRATEGY;
+		const { body } = fetchOptions;
+		const cacheKey = [
+			"weaverse-fetch",
+			url,
+			options.method || "GET",
+			bodyFreeCacheRequests.has(options) ? BODY_FREE_CACHE_SENTINEL : body == null ? null : String(body),
+			bodyFreeCacheRequests.has(options),
+			this.configs.projectId,
+			cacheTarget || "default"
+		];
+		const validateBuilderPayload = builderPayloadValidators.get(options);
+		if (this.configs.isDesignMode || this.configs.isRevisionPreview || this.isExternalPublicApiUrl(url)) return (await this.directFetch(url, fetchOptions)).data;
+		let response;
+		let text;
+		try {
+			response = await this.cachedFetch(url, fetchOptions, {
+				key: cacheKey,
+				strategy,
+				shouldCacheResponse: async ({ text: readText }) => {
+					if (fetchOptions.signal?.aborted) return false;
+					const payload = parseResponseText(await readText());
+					if (validateBuilderPayload && !validateBuilderPayload(payload)) return false;
+					return !hasError(payload) && payload !== null && payload !== "";
+				}
+			});
+			text = await response.text();
+		} catch (error) {
+			throw validateBuilderPayload ? cachedTransportError(error, url) : error;
+		}
+		if (!response.ok) {
+			if (validateBuilderPayload) throw new WeaverseError(`HTTP ${response.status}: ${response.statusText}`, "FETCH_ERROR", response.status, { url });
+			return null;
+		}
+		return parseResponseText(text);
+	};
+	/**
+	* 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 WeaversePageData 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;
+	};
+};
+//#endregion
+export { useThemeText as _, registerComponent as a, createWeaverseDataContext as c, getSelectedProductOptions$1 as d, formatMetaDescriptors as f, interpolate as g, TranslationProvider as h, WeaverseHydrogenRoot as i, useWeaverseDataContext as l, ThemeTextProvider as m, WeaverseHydrogen as n, useThemeSettings as o, getWeaverseSeoMeta as p, WeaverseHydrogenItem as r, withWeaverse as s, WeaverseClient as t, defaultComponents as u, useTranslation as v };
+
+//# sourceMappingURL=weaverse-client-Clu3u7md.mjs.map