@weaverse/hydrogen 5.23.0 → 6.0.0-beta.0

package/dist/weaverse-client-yC4TYuVV.js

@@ -0,0 +1,2073 @@
+const require_translation_store = require("./translation-store-BpPWqZ0B.js");
+let _weaverse_react = require("@weaverse/react");
+let _weaverse_schema = require("@weaverse/schema");
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+let _shopify_hydrogen = require("@shopify/hydrogen");
+let react_error_boundary = require("react-error-boundary");
+let react_router = require("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 = (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 ? require_translation_store.getNestedKey(merchantOverrides, key) : void 0;
+		const staticValue = require_translation_store.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 = (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 = (0, react.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(request) {
+	return (0, _shopify_hydrogen.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__ */ (0, react_jsx_runtime.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: (0, _weaverse_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((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);
+}
+//#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 (_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;
+	};
+};
+const ThemeSettingsStoreContext = (0, react.createContext)(null);
+ThemeSettingsStoreContext.displayName = "ThemeSettingsStoreContext";
+function useCreateThemeSettingsStore() {
+	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 = (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;
+}
+//#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 (require_translation_store.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 } = (0, react_router.useLocation)();
+	(0, react.useEffect)(() => {
+		let src = require_translation_store.resolveStudioScriptSrc(search, typeof window === "undefined" ? "" : window.location.hostname);
+		if (src) (0, _weaverse_react.loadScript)(src).catch(console.error);
+	}, [search]);
+}
+function useStudio(weaverse) {
+	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 = require_translation_store.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
+	]);
+}
+//#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 = require_translation_store.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 = require_translation_store.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_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 (_weaverse_react.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 (require_translation_store.hasWeaverseStudio(window)) window.weaverseStudio.refreshStudio(normalizedParams);
+		} else if (isReused) syncReusedInstance(weaverse, normalizedParams);
+		return weaverse;
+	}
+	return new WeaverseHydrogen(normalizedParams);
+}
+const StudioBridge = (0, react.memo)(({ context }) => {
+	useStudio(context);
+	return null;
+});
+const StudioConnect = (0, react.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__ */ (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);
+}
+/**
+* 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 = (0, react.useRef)(null);
+		if (!translationStoreRef.current) translationStoreRef.current = new require_translation_store.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 = (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();
+	return (0, _weaverse_react.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 require_translation_store.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) || require_translation_store.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) && !require_translation_store.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 require_translation_store.WeaverseLoadError) return error.kind;
+	if (!(error instanceof require_translation_store.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 require_translation_store.WeaverseError || !(error instanceof Error)) return error;
+	if (error.name === "AbortError" || error.name === "TimeoutError") return new require_translation_store.WeaverseError("Request timed out", "TIMEOUT_ERROR", void 0, { url });
+	if (error instanceof TypeError) return new require_translation_store.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 = (0, _shopify_hydrogen.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 = (0, _shopify_hydrogen.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 = require_translation_store.getWeaverseConfigs(args.request, args.env);
+		const resolvedProjectId = this.resolveProjectIdSync(args.projectId, args.request, args.env, baseConfigs);
+		if (!resolvedProjectId || resolvedProjectId.trim() === "") throw new require_translation_store.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 require_translation_store.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 require_translation_store.getRequestQueries(request).weaverseProjectId || null;
+	}
+	/**
+	* Priority 2: Resolve projectId from function parameter.
+	* Detects and rejects async functions with helpful error.
+	*/
+	resolveFromFunction(projectId) {
+		if (!require_translation_store.isProjectIdFunction(projectId)) return null;
+		if (projectId.constructor.name === "AsyncFunction") throw new require_translation_store.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 require_translation_store.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 require_translation_store.WeaverseError(validation.error || "Invalid projectId format", "INVALID_PROJECT_ID");
+			}
+		} catch (err) {
+			if (err instanceof require_translation_store.WeaverseError) throw err;
+			throw new require_translation_store.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 require_translation_store.WeaverseError(validation.error || "Invalid projectId format", "INVALID_PROJECT_ID");
+	}
+	/**
+	* Priority 4: Resolve projectId from environment variables.
+	*/
+	resolveFromEnvironment(baseConfigs, request, env) {
+		const configs = baseConfigs || require_translation_store.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 require_translation_store.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 require_translation_store.WeaverseError("Response body is not valid JSON", "INVALID_RESPONSE", response.status, { url });
+			}
+			return {
+				data,
+				response
+			};
+		} catch (err) {
+			if (err instanceof require_translation_store.WeaverseError) throw err;
+			if (err.name === "AbortError") throw new require_translation_store.WeaverseError(`Request timeout after ${timeoutMs}ms`, "TIMEOUT_ERROR", void 0, {
+				url,
+				timeoutMs
+			});
+			throw new require_translation_store.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 !require_translation_store.hasError(payload) && payload !== null && payload !== "";
+				}
+			});
+			text = await response.text();
+		} catch (error) {
+			throw validateBuilderPayload ? cachedTransportError(error, url) : error;
+		}
+		if (!response.ok) {
+			if (validateBuilderPayload) throw new require_translation_store.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 = require_translation_store.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 require_translation_store.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 require_translation_store.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 require_translation_store.getPreviewData(sectionType || "", this.components, weaverseHost);
+			if (!effectiveProjectId) throw new require_translation_store.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 (require_translation_store.hasError(projectData)) throw new require_translation_store.WeaverseLoadError("Weaverse API returned an error body", "invalid-response");
+			if (!isProjectEnvelope(projectData)) {
+				if (this.throwPageLoadFailures) throw new require_translation_store.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: require_translation_store.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 require_translation_store.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 require_translation_store.WeaverseLoadError) throw error;
+			throw new require_translation_store.WeaverseLoadError("Unable to load Weaverse page", failure, error instanceof require_translation_store.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: {
+						...require_translation_store.generateDataFromSchema(component.schema),
+						...data
+					},
+					weaverse: this
+				}))
+			};
+		} catch (error) {
+			console.warn("❌ Item loader run failed.", type, id, error);
+			return item;
+		}
+		return item;
+	};
+};
+//#endregion
+Object.defineProperty(exports, "ThemeTextProvider", {
+	enumerable: true,
+	get: function() {
+		return ThemeTextProvider;
+	}
+});
+Object.defineProperty(exports, "TranslationProvider", {
+	enumerable: true,
+	get: function() {
+		return TranslationProvider;
+	}
+});
+Object.defineProperty(exports, "WeaverseClient", {
+	enumerable: true,
+	get: function() {
+		return WeaverseClient;
+	}
+});
+Object.defineProperty(exports, "WeaverseHydrogen", {
+	enumerable: true,
+	get: function() {
+		return WeaverseHydrogen;
+	}
+});
+Object.defineProperty(exports, "WeaverseHydrogenItem", {
+	enumerable: true,
+	get: function() {
+		return WeaverseHydrogenItem;
+	}
+});
+Object.defineProperty(exports, "WeaverseHydrogenRoot", {
+	enumerable: true,
+	get: function() {
+		return WeaverseHydrogenRoot;
+	}
+});
+Object.defineProperty(exports, "createWeaverseDataContext", {
+	enumerable: true,
+	get: function() {
+		return createWeaverseDataContext;
+	}
+});
+Object.defineProperty(exports, "defaultComponents", {
+	enumerable: true,
+	get: function() {
+		return defaultComponents;
+	}
+});
+Object.defineProperty(exports, "formatMetaDescriptors", {
+	enumerable: true,
+	get: function() {
+		return formatMetaDescriptors;
+	}
+});
+Object.defineProperty(exports, "getSelectedProductOptions", {
+	enumerable: true,
+	get: function() {
+		return getSelectedProductOptions;
+	}
+});
+Object.defineProperty(exports, "getWeaverseSeoMeta", {
+	enumerable: true,
+	get: function() {
+		return getWeaverseSeoMeta;
+	}
+});
+Object.defineProperty(exports, "interpolate", {
+	enumerable: true,
+	get: function() {
+		return interpolate;
+	}
+});
+Object.defineProperty(exports, "registerComponent", {
+	enumerable: true,
+	get: function() {
+		return registerComponent;
+	}
+});
+Object.defineProperty(exports, "useThemeSettings", {
+	enumerable: true,
+	get: function() {
+		return useThemeSettings;
+	}
+});
+Object.defineProperty(exports, "useThemeText", {
+	enumerable: true,
+	get: function() {
+		return useThemeText;
+	}
+});
+Object.defineProperty(exports, "useTranslation", {
+	enumerable: true,
+	get: function() {
+		return useTranslation;
+	}
+});
+Object.defineProperty(exports, "useWeaverseDataContext", {
+	enumerable: true,
+	get: function() {
+		return useWeaverseDataContext;
+	}
+});
+Object.defineProperty(exports, "withWeaverse", {
+	enumerable: true,
+	get: function() {
+		return withWeaverse;
+	}
+});
+
+//# sourceMappingURL=weaverse-client-yC4TYuVV.js.map