@weaverse/next 1.0.0 → 1.0.1

package/dist/client-boundary.js

@@ -0,0 +1,1425 @@
+'use client'
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client-boundary.ts
+var client_boundary_exports = {};
+__export(client_boundary_exports, {
+  ThemeTextProvider: () => ThemeTextProvider,
+  TranslationProvider: () => TranslationProvider,
+  WeaverseNextProvider: () => WeaverseNextProvider,
+  WeaverseNextRenderer: () => WeaverseNextRenderer,
+  WeaverseNextRootProvider: () => WeaverseNextRootProvider,
+  WeaverseNextRuntime: () => WeaverseNextRuntime,
+  WeaverseNextStudio: () => WeaverseNextStudio,
+  WeaverseNextStudioBridge: () => WeaverseNextStudioBridge,
+  WeaverseNextStudioConnect: () => WeaverseNextStudioConnect,
+  bindWeaverseNextStudioRuntime: () => bindWeaverseNextStudioRuntime,
+  createWeaverseNextClient: () => createWeaverseNextClient,
+  createWeaverseNextRuntime: () => createWeaverseNextRuntime,
+  loadWeaverseNextStudioScript: () => loadWeaverseNextStudioScript,
+  useChildInstances: () => import_react14.useChildInstances,
+  useItemInstance: () => import_react14.useItemInstance,
+  useParentInstance: () => import_react14.useParentInstance,
+  useThemeSettings: () => useThemeSettings,
+  useThemeText: () => useThemeText,
+  useTranslation: () => useTranslation,
+  useWeaverse: () => import_react14.useWeaverse,
+  useWeaverseCommerce: () => useWeaverseCommerce,
+  useWeaverseNextStudioInternals: () => useWeaverseNextStudioInternals,
+  useWeaversePageData: () => useWeaversePageData,
+  useWeaverseRootData: () => useWeaverseRootData
+});
+module.exports = __toCommonJS(client_boundary_exports);
+var import_react14 = require("@weaverse/react");
+
+// src/registry.ts
+var import_react2 = require("@weaverse/react");
+
+// src/item.ts
+var import_react = require("@weaverse/react");
+
+// src/utils.ts
+function generateDataFromSchema(schema) {
+  let data = {};
+  if (!schema) {
+    return data;
+  }
+  let groups = schema.settings ?? schema.inspector ?? [];
+  for (let group of groups) {
+    for (let input of group?.inputs ?? []) {
+      let { name, defaultValue } = input;
+      if (name && defaultValue !== null && defaultValue !== void 0) {
+        data[name] = defaultValue;
+      }
+    }
+  }
+  return data;
+}
+var isBrowser = typeof window !== "undefined";
+var isIframe = isBrowser && window.top !== window.self;
+
+// src/item.ts
+function flattenItemData(update) {
+  let { data, ...rest } = update;
+  if (!(data && typeof data === "object" && !Array.isArray(data))) {
+    return rest;
+  }
+  return { ...data, ...rest };
+}
+var deferredItemUpdates = null;
+function collectDeferredItemUpdates(create) {
+  let previousQueue = deferredItemUpdates;
+  let queue = /* @__PURE__ */ new Set();
+  deferredItemUpdates = queue;
+  try {
+    return [create(), [...queue]];
+  } finally {
+    deferredItemUpdates = previousQueue;
+  }
+}
+var WeaverseNextItem = class extends import_react.WeaverseItemStore {
+  /**
+   * Cached merged snapshot (base `_store` + translations). Reset whenever the
+   * `_store` ref or the item's translation entry ref changes, so
+   * `useSyncExternalStore` sees a stable object between unrelated re-renders.
+   */
+  _cachedSnapshot = null;
+  _snapshotStoreRef = null;
+  _snapshotTranslationRef = null;
+  /** Create an item store from serialized component data and its runtime. */
+  constructor(initialData, weaverse) {
+    super(initialData, weaverse);
+    let schemaData = generateDataFromSchema(this.Element?.schema);
+    Object.assign(this._store, schemaData, flattenItemData(initialData));
+  }
+  /**
+   * Flatten nested `data` on updates exactly like the constructor does. Core's
+   * `initProject()` calls `setData(item)` when a new runtime serves a page
+   * whose item instances already exist (e.g. locale/client navigation).
+   *
+   * A complete serialized item (it carries `id` and `type`; core's
+   * `initProject()` always passes one) replaces the store the way the
+   * constructor builds it: the schema defaults of the item's own `type` — the
+   * Builder can replace a section in place, keeping its id — then the item's
+   * settings. A payload omits a setting — or the whole optional `data` — when
+   * its value equals the schema default, so merging into the previous store
+   * would keep the previous locale's value visible. Partial updates still
+   * merge. Either way the `_store` ref changes, which invalidates the memoized
+   * snapshot below. The subscriber emit is queued instead of fired when a
+   * render-phase deferral is active (see `collectDeferredItemUpdates`).
+   */
+  setData = (update) => {
+    if ("id" in update && "type" in update) {
+      let { data, type } = update;
+      let schema = this.weaverse.elementRegistry.get(type)?.schema;
+      this._store = {
+        ...generateDataFromSchema(schema),
+        ...data === void 0 ? {} : { data },
+        ...flattenItemData(update)
+      };
+    } else {
+      this.data = flattenItemData(update);
+    }
+    if (deferredItemUpdates) {
+      deferredItemUpdates.add(this);
+    } else {
+      this.triggerUpdate();
+    }
+    return this.data;
+  };
+  /**
+   * Overlay item-level translations onto the base store when the runtime is in
+   * translation mode. Mirrors Hydrogen's `WeaverseHydrogenItem.getSnapShot()`:
+   * memoized by `_store` ref + translation entry ref so the returned object is
+   * referentially stable, and a fast path that returns the base store untouched
+   * when the item has no translations.
+   */
+  getSnapShot = () => {
+    let base = this._store;
+    let translations = this.weaverse.translationMap[this._id];
+    if (!translations) {
+      return base;
+    }
+    if (this._cachedSnapshot && this._snapshotStoreRef === base && this._snapshotTranslationRef === translations) {
+      return this._cachedSnapshot;
+    }
+    let merged = { ...base };
+    for (let [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;
+  };
+};
+function ensureNextItemConstructor() {
+  if (!import_react.Weaverse.ItemConstructor || import_react.Weaverse.ItemConstructor === import_react.WeaverseItemStore || import_react.Weaverse.ItemConstructor === WeaverseNextItem) {
+    import_react.Weaverse.ItemConstructor = WeaverseNextItem;
+  }
+}
+
+// src/main.tsx
+var import_schema = require("@weaverse/schema");
+var import_jsx_runtime = require("react/jsx-runtime");
+function Main(props) {
+  let { children, loaderData, ...rest } = props;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ...rest, children });
+}
+Main.displayName = "main";
+var mainSchema = (0, import_schema.createSchema)({
+  type: "main",
+  title: "Main"
+});
+var defaultMainComponent = {
+  default: Main,
+  schema: mainSchema
+};
+
+// src/registry.ts
+var MAIN_TYPE = "main";
+var registeredComponentTypes = /* @__PURE__ */ new Set();
+function registerWeaverseNextComponents(components) {
+  ensureNextItemConstructor();
+  let hasUserMain = components.some(
+    (component) => component.schema?.type === MAIN_TYPE
+  );
+  let effectiveComponents = hasUserMain ? components : [defaultMainComponent, ...components];
+  for (let component of effectiveComponents) {
+    let type = component.schema.type;
+    let element = {
+      type,
+      Component: component.default,
+      schema: component.schema,
+      loader: component.loader
+    };
+    if (type === MAIN_TYPE && hasUserMain) {
+      import_react2.Weaverse.elementRegistry.set(type, element);
+      registeredComponentTypes.add(type);
+      continue;
+    }
+    if (type && !registeredComponentTypes.has(type)) {
+      import_react2.Weaverse.registerElement(element);
+      registeredComponentTypes.add(type);
+    }
+  }
+}
+
+// src/client.ts
+var NextClient = class {
+  projectId;
+  components;
+  themeSchema;
+  themeSettings;
+  requestContext;
+  commerce;
+  data = null;
+  dataContext = {};
+  _fetchPage;
+  _fetchThemeSettings;
+  constructor(config) {
+    this.projectId = config.projectId;
+    this.components = config.components;
+    registerWeaverseNextComponents(this.components);
+    this.themeSchema = config.themeSchema;
+    this.themeSettings = {
+      ...generateDataFromSchema(config.themeSchema),
+      ...config.themeSettings
+    };
+    this.requestContext = config.requestContext;
+    this.commerce = config.commerce;
+    this._fetchPage = config.fetchPage;
+    this._fetchThemeSettings = config.fetchThemeSettings;
+  }
+  /** Compatibility alias so loaders can call `weaverse.storefront.query(...)`. */
+  get storefront() {
+    return this.commerce?.storefront;
+  }
+  loadPage = (input = {}) => {
+    if (!this._fetchPage) {
+      throw new Error(
+        "[WeaverseNextClient] loadPage requires a `fetchPage` function in client config."
+      );
+    }
+    return this._fetchPage(input);
+  };
+  loadThemeSettings = (context) => {
+    if (!this._fetchThemeSettings) {
+      throw new Error(
+        "[WeaverseNextClient] loadThemeSettings requires a `fetchThemeSettings` function in client config."
+      );
+    }
+    return this._fetchThemeSettings(context ?? this.requestContext);
+  };
+};
+function createWeaverseNextClient(config) {
+  return new NextClient(config);
+}
+
+// src/hooks.ts
+var import_react7 = require("react");
+
+// src/provider.tsx
+var import_react6 = require("react");
+
+// src/root-provider.tsx
+var import_react5 = require("react");
+
+// src/theme-settings-store.ts
+function createWeaverseNextThemeSettingsStore(options = {}) {
+  let listeners = /* @__PURE__ */ new Set();
+  let store = {
+    publicEnv: options.publicEnv,
+    schema: options.schema,
+    settings: { ...options.settings ?? {} },
+    getServerSnapshot: () => store.settings,
+    getSnapshot: () => store.settings,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    updateThemeSettings: (next) => {
+      store.settings = { ...store.settings, ...next };
+      for (let listener of listeners) {
+        listener();
+      }
+    }
+  };
+  return store;
+}
+
+// src/translation-context.tsx
+var import_react3 = require("@weaverse/react");
+var import_react4 = require("react");
+
+// src/translate.ts
+function getNestedKey(obj, path, fallback) {
+  let keys = path.split(".");
+  let current = obj;
+  for (let key of keys) {
+    if (current == null || typeof current !== "object") {
+      return fallback;
+    }
+    current = current[key];
+  }
+  if (typeof current === "string") {
+    return current;
+  }
+  return fallback;
+}
+function interpolate(template, variables) {
+  if (!variables) {
+    return template;
+  }
+  return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    let value = variables[key];
+    return value === void 0 ? match : String(value);
+  });
+}
+function createTranslate(sources) {
+  let { staticContent, merchantOverrides, designOverrides, externalT } = sources;
+  return (key, variables) => {
+    if (externalT) {
+      let external = externalT(key, variables);
+      if (external && external !== key) {
+        return external;
+      }
+    }
+    let design = designOverrides && Object.hasOwn(designOverrides, key) ? designOverrides[key] : void 0;
+    let override = merchantOverrides ? getNestedKey(merchantOverrides, key) : void 0;
+    let staticValue = getNestedKey(staticContent, key);
+    let raw = design ?? override ?? staticValue ?? key;
+    return interpolate(raw, variables);
+  };
+}
+
+// src/translation-context.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var TranslationContext = (0, import_react4.createContext)(null);
+TranslationContext.displayName = "WeaverseNextTranslationContext";
+var EMPTY = {};
+var NOOP_SUBSCRIBE = () => () => {
+};
+var NOOP_SNAPSHOT = () => EMPTY;
+function TranslationProvider({
+  staticContent,
+  merchantOverrides,
+  t: externalT,
+  translationStore,
+  themeTextStore,
+  children
+}) {
+  let store = translationStore ?? themeTextStore ?? null;
+  let designOverrides = (0, import_react3.useSafeExternalStore)(
+    store?.subscribe ?? NOOP_SUBSCRIBE,
+    store?.getSnapshot ?? NOOP_SNAPSHOT,
+    store?.getServerSnapshot ?? NOOP_SNAPSHOT
+  );
+  let value = (0, import_react4.useMemo)(
+    () => ({
+      t: createTranslate({
+        staticContent,
+        merchantOverrides,
+        designOverrides,
+        externalT
+      }),
+      translationStore: store,
+      // Deprecated alias — same instance, kept for backward compatibility.
+      themeTextStore: store,
+      merchantOverrides: merchantOverrides ?? null
+    }),
+    [staticContent, merchantOverrides, designOverrides, externalT, store]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(TranslationContext.Provider, { value, children });
+}
+function useTranslation() {
+  let ctx = (0, import_react4.useContext)(TranslationContext);
+  if (!ctx) {
+    throw new Error(
+      "useTranslation must be used within <TranslationProvider>. Wrap your app with <WeaverseNextRootProvider>."
+    );
+  }
+  return ctx;
+}
+var ThemeTextProvider = TranslationProvider;
+var useThemeText = useTranslation;
+
+// src/translation-store.ts
+var TranslationStore = class {
+  /** Current flat translation overrides keyed by dot path. */
+  overrides = {};
+  listeners = /* @__PURE__ */ new Set();
+  /** Replace every override and notify subscribers. */
+  setOverrides = (overrides) => {
+    this.overrides = { ...overrides };
+    this.emit();
+  };
+  /** Merge changed overrides into the current values and notify subscribers. */
+  updateOverrides = (newOverrides) => {
+    this.overrides = { ...this.overrides, ...newOverrides };
+    this.emit();
+  };
+  /** Return the current client-side override snapshot. */
+  getSnapshot = () => this.overrides;
+  /** Return the override snapshot used during server rendering. */
+  getServerSnapshot = () => this.overrides;
+  /** Subscribe to override changes and return an unsubscribe function. */
+  subscribe = (callback) => {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  };
+  emit = () => {
+    for (const listener of Array.from(this.listeners)) {
+      try {
+        listener();
+      } catch (error) {
+        console.error("TranslationStore: Listener error", error);
+      }
+    }
+  };
+};
+
+// src/root-provider.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var WeaverseNextRootContext = (0, import_react5.createContext)(null);
+function WeaverseNextRootProvider(props) {
+  let {
+    children,
+    initialThemeSettings,
+    merchantOverrides,
+    staticContent,
+    t,
+    themeSchema,
+    publicEnv
+  } = props;
+  let storeRef = (0, import_react5.useRef)(null);
+  if (!storeRef.current) {
+    storeRef.current = createWeaverseNextThemeSettingsStore({
+      publicEnv,
+      schema: themeSchema,
+      settings: initialThemeSettings
+    });
+  }
+  let themeSettingsStore = storeRef.current;
+  let translationStoreRef = (0, import_react5.useRef)(null);
+  if (!translationStoreRef.current) {
+    translationStoreRef.current = new TranslationStore();
+  }
+  let translationStore = translationStoreRef.current;
+  let appliedThemeSettingsRef = (0, import_react5.useRef)(initialThemeSettings);
+  (0, import_react5.useEffect)(() => {
+    if (initialThemeSettings && appliedThemeSettingsRef.current !== initialThemeSettings) {
+      themeSettingsStore.updateThemeSettings(initialThemeSettings);
+      appliedThemeSettingsRef.current = initialThemeSettings;
+    }
+  }, [initialThemeSettings, themeSettingsStore]);
+  let resolvedStaticContent = staticContent ?? getSchemaStaticContent(themeSchema);
+  let rootContextValue = (0, import_react5.useMemo)(
+    () => ({
+      merchantOverrides,
+      staticContent: resolvedStaticContent,
+      themeSettingsStore,
+      translationStore
+    }),
+    [
+      merchantOverrides,
+      resolvedStaticContent,
+      themeSettingsStore,
+      translationStore
+    ]
+  );
+  let contextValue = (0, import_react5.useMemo)(
+    () => ({
+      merchantOverrides,
+      themeSettings: themeSettingsStore.getSnapshot(),
+      themeSettingsStore,
+      translationStore
+    }),
+    [merchantOverrides, themeSettingsStore, translationStore]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(WeaverseNextRootContext.Provider, { value: rootContextValue, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(WeaverseNextContext.Provider, { value: contextValue, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    TranslationProvider,
+    {
+      merchantOverrides,
+      staticContent: resolvedStaticContent,
+      t,
+      translationStore,
+      children
+    }
+  ) }) });
+}
+
+// src/provider.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var EMPTY_THEME_SETTINGS = {};
+var EMPTY_STATIC_CONTENT = {};
+function getSchemaStaticContent(schema) {
+  let i18n = schema?.i18n;
+  return i18n?.staticContent ?? EMPTY_STATIC_CONTENT;
+}
+var WeaverseNextContext = (0, import_react6.createContext)(null);
+function WeaverseNextProvider(props) {
+  let { children, client, rootData, pageData, commerce, themeSettings } = props;
+  let rootContext = (0, import_react6.useContext)(WeaverseNextRootContext);
+  let themeSettingsValue = themeSettings ?? client?.themeSettings ?? EMPTY_THEME_SETTINGS;
+  let ownTranslationStoreRef = (0, import_react6.useRef)(null);
+  if (!(rootContext || ownTranslationStoreRef.current)) {
+    ownTranslationStoreRef.current = new TranslationStore();
+  }
+  let translationStore = rootContext?.translationStore ?? ownTranslationStoreRef.current;
+  let staticContent = props.staticContent ?? rootContext?.staticContent ?? getSchemaStaticContent(client?.themeSchema);
+  let merchantOverrides = props.merchantOverrides ?? rootContext?.merchantOverrides;
+  let ownThemeSettingsStore = (0, import_react6.useMemo)(() => {
+    if (rootContext) {
+      return null;
+    }
+    return createWeaverseNextThemeSettingsStore({
+      schema: client?.themeSchema,
+      settings: themeSettingsValue
+    });
+  }, [rootContext, client?.themeSchema, themeSettingsValue]);
+  let themeSettingsStore = rootContext?.themeSettingsStore ?? ownThemeSettingsStore;
+  let mergedIntoRootRef = (0, import_react6.useRef)(void 0);
+  (0, import_react6.useEffect)(() => {
+    if (rootContext && themeSettingsValue !== EMPTY_THEME_SETTINGS && mergedIntoRootRef.current !== themeSettingsValue) {
+      rootContext.themeSettingsStore.updateThemeSettings(themeSettingsValue);
+      mergedIntoRootRef.current = themeSettingsValue;
+    }
+  }, [rootContext, themeSettingsValue]);
+  let value = (0, import_react6.useMemo)(
+    () => ({
+      client,
+      rootData,
+      pageData,
+      commerce: commerce ?? client?.commerce,
+      merchantOverrides,
+      themeSettings: themeSettingsStore.getSnapshot(),
+      themeSettingsStore,
+      translationStore
+    }),
+    [
+      client,
+      rootData,
+      pageData,
+      commerce,
+      merchantOverrides,
+      themeSettingsStore,
+      translationStore
+    ]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(WeaverseNextContext.Provider, { value, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    TranslationProvider,
+    {
+      merchantOverrides,
+      staticContent,
+      t: props.t,
+      translationStore,
+      children
+    }
+  ) });
+}
+
+// src/hooks.ts
+var OUTSIDE_PROVIDER_ERROR = "must be used inside a <WeaverseNextProvider>.";
+function useWeaverseNextContext(hookName) {
+  let context = (0, import_react7.useContext)(WeaverseNextContext);
+  if (!context) {
+    throw new Error(`[@weaverse/next] ${hookName} ${OUTSIDE_PROVIDER_ERROR}`);
+  }
+  return context;
+}
+function useWeaverseRootData() {
+  return useWeaverseNextContext("useWeaverseRootData").rootData;
+}
+function useWeaversePageData() {
+  return useWeaverseNextContext("useWeaversePageData").pageData;
+}
+function useWeaverseCommerce() {
+  return useWeaverseNextContext("useWeaverseCommerce").commerce;
+}
+function useThemeSettings() {
+  let { themeSettingsStore } = useWeaverseNextContext("useThemeSettings");
+  return (0, import_react7.useSyncExternalStore)(
+    themeSettingsStore.subscribe,
+    themeSettingsStore.getSnapshot,
+    themeSettingsStore.getServerSnapshot
+  );
+}
+
+// src/renderer.tsx
+var import_react11 = require("@weaverse/react");
+var import_react12 = require("react");
+
+// src/runtime.ts
+var import_react8 = require("@weaverse/react");
+
+// src/request-info.ts
+function toUrl(value) {
+  return typeof value === "string" ? new URL(value, "http://localhost") : value;
+}
+function getSearchParamsFromContext(context) {
+  if (context?.searchParams) {
+    return new URLSearchParams(context.searchParams);
+  }
+  if (context?.url) {
+    let url = toUrl(context.url);
+    return new URLSearchParams(url.searchParams);
+  }
+  return new URLSearchParams();
+}
+function withPathPrefix(pathname, i18n) {
+  let raw = typeof i18n?.pathPrefix === "string" ? i18n.pathPrefix : "";
+  let segments = raw.split("/").filter(Boolean);
+  let prefix = segments.length > 0 ? `/${segments.join("/")}` : "";
+  if (prefix === "" || pathname === prefix || pathname.startsWith(`${prefix}/`)) {
+    return pathname;
+  }
+  return pathname === "/" ? prefix : `${prefix}${pathname}`;
+}
+function getPathnameFromContext(context) {
+  if (context?.pathname) {
+    return withPathPrefix(context.pathname, context.i18n);
+  }
+  if (context?.url) {
+    let url = toUrl(context.url);
+    return withPathPrefix(url.pathname || "/", context.i18n);
+  }
+  return "/";
+}
+function coerceQueryValue(value) {
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  return value;
+}
+function toQueryRecord(searchParams) {
+  let queries = {};
+  for (let [key, value] of searchParams.entries()) {
+    queries[key] = coerceQueryValue(value);
+  }
+  return queries;
+}
+var TRANSIENT_STUDIO_PARAMS = /* @__PURE__ */ new Set([
+  "weaverseDraftItem",
+  // Legacy name from the original design-mode draft-item spike. Keep it out of
+  // runtime requestInfo too, in case an older Builder bundle is in front of a
+  // newer Next storefront.
+  "__weaverseDraftItem"
+]);
+function getRequestInfoSearchParams(context) {
+  let searchParams = new URLSearchParams(getSearchParamsFromContext(context));
+  for (let key of TRANSIENT_STUDIO_PARAMS) {
+    searchParams.delete(key);
+  }
+  return searchParams;
+}
+function buildWeaverseNextRequestInfo(context) {
+  let searchParams = getRequestInfoSearchParams(context);
+  let search = searchParams.toString();
+  return {
+    pathname: getPathnameFromContext(context),
+    search: search ? `?${search}` : "",
+    queries: toQueryRecord(searchParams),
+    ...context?.i18n ? { i18n: context.i18n } : {},
+    ...context?.pageType ? { pageType: context.pageType } : {},
+    ...context?.handle ? { handle: context.handle } : {}
+  };
+}
+
+// src/runtime.ts
+function getRuntimeWindow() {
+  return typeof window === "undefined" ? void 0 : window;
+}
+function getRenderablePage(data) {
+  let page = data.page;
+  let rootId = page.rootId ?? page.items.find((item) => item.type === "main")?.id ?? page.items[0]?.id ?? page.id;
+  return { ...page, rootId };
+}
+function getConfigString(configs, key) {
+  let value = configs?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function resolveModeFlag(config, key) {
+  return config.client?.requestContext?.[key] === true || config.data.configs?.[key] === true;
+}
+function resolveSectionType(config) {
+  return config.client?.requestContext?.sectionType || getConfigString(config.data.configs, "sectionType") || void 0;
+}
+function getRecordString(record, key) {
+  let value = record?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function resolveProjectId(client, data, fallback) {
+  let projectId = client?.projectId;
+  if (projectId) {
+    return projectId;
+  }
+  let configProjectId = getConfigString(data.configs, "projectId");
+  if (configProjectId) {
+    return configProjectId;
+  }
+  return getRecordString(data.project, "id") ?? fallback;
+}
+function resolveDataContext(config) {
+  if (config.dataContext) {
+    return config.dataContext;
+  }
+  if (config.client?.dataContext) {
+    return config.client.dataContext;
+  }
+  return {};
+}
+function getRuntimeKey(pageId, requestInfo) {
+  return `${pageId}:${requestInfo.pathname}:${requestInfo.search}`;
+}
+function registerRuntime(runtime) {
+  let runtimeWindow = getRuntimeWindow();
+  if (!runtimeWindow) {
+    return;
+  }
+  runtimeWindow.__weaverses ??= {};
+  runtimeWindow.__weaverses[runtime.pageId] = runtime;
+  runtimeWindow.__weaverse = runtime;
+}
+function rebindPageItemsToRuntime(runtime) {
+  let items = runtime.data?.items;
+  if (!items) {
+    return;
+  }
+  for (let { id } of items) {
+    let instance = runtime.itemInstances.get(id);
+    if (instance && instance.weaverse !== runtime) {
+      instance.weaverse = runtime;
+    }
+  }
+}
+var WeaverseNextRuntime = class extends import_react8.Weaverse {
+  /** Stable ID of the page owned by this runtime. */
+  pageId;
+  /** Mutable callbacks and stores consumed by the Studio bridge. */
+  internal;
+  /** Path, query, and locale metadata for Studio navigation. */
+  requestInfo;
+  /** Whether this runtime renders a component preview. */
+  isPreviewMode;
+  /** Whether this runtime renders a saved revision. */
+  isRevisionPreview;
+  /** Component type rendered in section preview mode. */
+  sectionType;
+  // ─── Item-level translation sidecar (design mode only) ─────────────
+  /**
+   * Translation map received from Builder in design mode, keyed by item ID.
+   * `WeaverseNextItem.getSnapShot()` overlays these onto the data handed to
+   * components, so translations render without mutating the base `_store`.
+   */
+  translationMap = {};
+  /** Locale associated with the item-level translation sidecar. */
+  translationLocale = String();
+  /** Weaverse language ID used when saving translation changes. */
+  translationLanguageId = String();
+  /**
+   * Fresh page data captured while React was rendering. Runtime reuse happens
+   * inside the renderer's render phase (`useMemo`), where applying it through
+   * `setProjectData()` would emit item updates to `useSyncExternalStore`
+   * subscribers mid-render. The renderer applies it post-commit via
+   * `flushRenderPhaseUpdates()`. Never set on design-mode runtimes — the live
+   * Studio tree owns the page data there.
+   */
+  pendingProjectData;
+  /**
+   * Reused item instances whose data was refreshed while this runtime was
+   * constructed during render (core `initProject()` calls `setData()` on
+   * them). Their data is already fresh; only the subscriber notification was
+   * deferred to `flushRenderPhaseUpdates()`.
+   */
+  pendingItemUpdates = [];
+  /** Create a browser runtime from a loaded page and its request context. */
+  constructor(config) {
+    let { client, data } = config;
+    let page = getRenderablePage(data);
+    let configs = data.configs;
+    let requestContext = client?.requestContext;
+    let isDesignMode = resolveModeFlag(config, "isDesignMode");
+    let isPreviewMode = resolveModeFlag(config, "isPreviewMode");
+    let isRevisionPreview = resolveModeFlag(config, "isRevisionPreview");
+    let sectionType = resolveSectionType(config);
+    let projectId = resolveProjectId(client, data, page.id);
+    ensureNextItemConstructor();
+    super({
+      projectId,
+      data: page,
+      isDesignMode,
+      weaverseHost: getConfigString(configs, "weaverseHost"),
+      weaverseVersion: getConfigString(configs, "weaverseVersion")
+    });
+    this.pageId = page.id;
+    this.dataContext = resolveDataContext(config);
+    this.requestInfo = buildWeaverseNextRequestInfo(requestContext);
+    this.isDesignMode = isDesignMode;
+    this.isPreviewMode = isPreviewMode;
+    this.isRevisionPreview = isRevisionPreview;
+    this.sectionType = sectionType;
+    let translationStore = config.translationStore ?? new TranslationStore();
+    this.internal = {
+      merchantOverrides: config.merchantOverrides,
+      navigate: config.navigate,
+      pageAssignment: data.pageAssignment,
+      project: data.project,
+      revalidate: config.revalidate,
+      themeSettingsStore: config.themeSettingsStore ?? createWeaverseNextThemeSettingsStore({
+        schema: client?.themeSchema,
+        settings: client?.themeSettings
+      }),
+      translationStore,
+      themeTextStore: translationStore
+    };
+    this.extractTranslationSidecar();
+  }
+  /**
+   * Pull `translationMap` / `translationLocale` / `translationLanguageId` off
+   * the current page data (Builder attaches them in design mode). Unlike
+   * Hydrogen, this also clears the sidecar to defaults when the new page data
+   * carries none, so a reused runtime / project-data swap can't leave a stale
+   * map overlaying the fresh tree.
+   */
+  extractTranslationSidecar = () => {
+    let pageData = this.data;
+    let translationMap = pageData?.translationMap;
+    if (translationMap) {
+      this.translationMap = translationMap;
+      this.translationLocale = pageData?.translationLocale || "";
+      this.translationLanguageId = pageData?.translationLanguageId || "";
+    } else {
+      this.translationMap = {};
+      this.translationLocale = "";
+      this.translationLanguageId = "";
+    }
+  };
+  /**
+   * Replace the translation sidecar (Builder pushes this when translation data
+   * arrives or the active language changes) and refresh every item so their
+   * merged snapshots recompute.
+   */
+  setTranslationSidecar = (map = {}, locale = "", languageId = "") => {
+    this.translationMap = map;
+    this.translationLocale = locale;
+    this.translationLanguageId = languageId;
+    this.refreshAllItems();
+  };
+  /**
+   * Update a single translatable field for one item. Assigns a new per-item
+   * entry object so `WeaverseNextItem.getSnapShot()`'s translation-ref cache
+   * invalidates, then triggers only that item's subscribers.
+   */
+  updateTranslation = (itemId, key, originalValue, translatedValue) => {
+    if (!this.translationMap[itemId]) {
+      this.translationMap[itemId] = {};
+    }
+    this.translationMap[itemId] = {
+      ...this.translationMap[itemId],
+      [key]: { originalValue, translatedValue }
+    };
+    let instance = this.itemInstances.get(itemId);
+    if (instance) {
+      instance.triggerUpdate();
+    }
+  };
+  /**
+   * Collect translation changes for the save flow. Returns `undefined` unless
+   * both the locale and language ID are set and at least one entry exists;
+   * each entry key is namespaced as `data.<field>` to match Builder.
+   */
+  getTranslationChanges = () => {
+    let languageId = this.translationLanguageId;
+    if (!(this.translationLocale && languageId)) {
+      return;
+    }
+    let entries = [];
+    for (let [itemId, fields] of Object.entries(this.translationMap)) {
+      for (let [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 };
+  };
+  /**
+   * Re-extract the translation sidecar whenever project data is replaced (route
+   * change / non-design reuse), before rebuilding item stores. Takes the
+   * renderable page shape (`rootId` resolved) that `getRenderablePage()` and
+   * the reuse branch pass in.
+   */
+  setProjectData = (data) => {
+    this.data = data;
+    this.extractTranslationSidecar();
+    this.initProject();
+  };
+  /**
+   * Apply updates deferred off the render phase: swap in any pending page data
+   * captured on runtime reuse, then notify items whose data was refreshed
+   * during construction. The renderer calls this from a layout effect right
+   * after commit, so subscribers re-render before paint (no content flash) and
+   * without React's setState-in-render warning.
+   */
+  flushRenderPhaseUpdates = () => {
+    let pendingData = this.pendingProjectData;
+    if (pendingData) {
+      this.pendingProjectData = void 0;
+      this.setProjectData(pendingData);
+    }
+    let pendingItems = this.pendingItemUpdates;
+    if (pendingItems.length > 0) {
+      this.pendingItemUpdates = [];
+      for (let item of pendingItems) {
+        item.triggerUpdate();
+      }
+    }
+  };
+};
+function createWeaverseNextRuntime(config) {
+  let requestInfo = buildWeaverseNextRequestInfo(config.client?.requestContext);
+  let page = getRenderablePage(config.data);
+  let runtimeWindow = getRuntimeWindow();
+  let existing = runtimeWindow?.__weaverses?.[page.id];
+  let requestKey = getRuntimeKey(page.id, requestInfo);
+  if (existing?.__weaverseNextRequestKey === requestKey) {
+    let configs = config.data.configs;
+    let nextIsDesignMode = resolveModeFlag(config, "isDesignMode");
+    let nextIsPreviewMode = resolveModeFlag(config, "isPreviewMode");
+    let nextIsRevisionPreview = resolveModeFlag(config, "isRevisionPreview");
+    let nextSectionType = resolveSectionType(config);
+    if (existing.isDesignMode || nextIsDesignMode) {
+      existing.pendingProjectData = void 0;
+    } else {
+      existing.pendingProjectData = page;
+    }
+    existing.__weaverseNextLatestData = page;
+    existing.dataContext = resolveDataContext(config);
+    existing.requestInfo = requestInfo;
+    existing.projectId = resolveProjectId(config.client, config.data, page.id);
+    existing.isDesignMode = nextIsDesignMode;
+    existing.isPreviewMode = nextIsPreviewMode;
+    existing.isRevisionPreview = nextIsRevisionPreview;
+    existing.sectionType = nextSectionType;
+    existing.weaverseHost = getConfigString(configs, "weaverseHost") ?? existing.weaverseHost;
+    existing.weaverseVersion = getConfigString(configs, "weaverseVersion") ?? existing.weaverseVersion;
+    existing.internal.pageAssignment = config.data.pageAssignment;
+    existing.internal.project = config.data.project;
+    if (config.navigate) {
+      existing.internal.navigate = config.navigate;
+    }
+    if (config.revalidate) {
+      existing.internal.revalidate = config.revalidate;
+    }
+    if (config.themeSettingsStore) {
+      existing.internal.themeSettingsStore = config.themeSettingsStore;
+    }
+    if (config.translationStore) {
+      existing.internal.translationStore = config.translationStore;
+      existing.internal.themeTextStore = config.translationStore;
+    }
+    existing.internal.merchantOverrides = config.merchantOverrides;
+    registerRuntime(existing);
+    return existing;
+  }
+  let [runtime, refreshedItems] = collectDeferredItemUpdates(
+    () => new WeaverseNextRuntime(config)
+  );
+  runtime.pendingItemUpdates = refreshedItems;
+  rebindPageItemsToRuntime(runtime);
+  runtime.__weaverseNextRequestKey = requestKey;
+  runtime.__weaverseNextLatestData = page;
+  registerRuntime(runtime);
+  return runtime;
+}
+function bindWeaverseNextStudioRuntime(runtime) {
+  if (!runtime.isDesignMode) {
+    return false;
+  }
+  let studio = getRuntimeWindow()?.weaverseStudio;
+  if (!studio) {
+    return false;
+  }
+  let boundRuntime = runtime;
+  let activeRuntime = studio.weaverse;
+  let activeRequestInfo = activeRuntime?.requestInfo;
+  let isActiveUrl = !activeRequestInfo || activeRequestInfo.pathname === runtime.requestInfo.pathname && activeRequestInfo.search === runtime.requestInfo.search;
+  if (!(boundRuntime.__weaverseNextStudioBound && isActiveUrl)) {
+    studio.init?.(runtime);
+    boundRuntime.__weaverseNextStudioBound = true;
+    return true;
+  }
+  studio.refreshStudio?.({
+    data: boundRuntime.__weaverseNextLatestData ?? runtime.data,
+    pageId: runtime.pageId,
+    requestInfo: runtime.requestInfo
+  });
+  return true;
+}
+
+// src/use-weaverse-next-studio.tsx
+var import_navigation = require("next/navigation");
+var import_react10 = require("react");
+
+// src/revalidate-item.ts
+var import_schema2 = require("@weaverse/schema");
+var DEFAULT_REVALIDATE_ENDPOINT = "/api/weaverse/revalidate";
+var MAX_ROUTE_CONTEXT_HANDLE_LENGTH = 512;
+var DENIED_ROUTE_CONTEXT_PARAMS = [
+  "weaverseprojectid",
+  "weaversehost",
+  "weaverseapikey",
+  "weaverseapibase",
+  "weaversepublicapibase",
+  "weaverseversion",
+  "projectid",
+  "weaversedraftitem",
+  "__weaversedraftitem",
+  "_rsc"
+];
+var ROUTE_CONTEXT_I18N_KEYS = [
+  "country",
+  "label",
+  "language",
+  "locale",
+  "pathPrefix"
+];
+function sanitizeRouteContextSearch(search) {
+  let params = new URLSearchParams(search);
+  let denied = new Set(DENIED_ROUTE_CONTEXT_PARAMS);
+  for (let key of [...new Set(params.keys())]) {
+    if (denied.has(key.toLowerCase())) {
+      params.delete(key);
+    }
+  }
+  let serialized = params.toString();
+  return serialized ? `?${serialized}` : "";
+}
+function buildWeaverseNextRevalidateRouteContext(requestInfo) {
+  if (!requestInfo || typeof requestInfo.pathname !== "string" || !requestInfo.pathname) {
+    return;
+  }
+  let routeContext = {
+    pathname: requestInfo.pathname,
+    search: sanitizeRouteContextSearch(requestInfo.search ?? "")
+  };
+  let { i18n } = requestInfo;
+  if (i18n && typeof i18n === "object") {
+    let picked = {};
+    for (let key of ROUTE_CONTEXT_I18N_KEYS) {
+      let value = i18n[key];
+      if (typeof value === "string") {
+        picked[key] = value;
+      }
+    }
+    if (Object.keys(picked).length) {
+      routeContext.i18n = picked;
+    }
+  }
+  if (requestInfo.pageType && import_schema2.PageTypeSchema.safeParse(requestInfo.pageType).success) {
+    routeContext.pageType = requestInfo.pageType;
+  }
+  if (typeof requestInfo.handle === "string" && requestInfo.handle && requestInfo.handle.length <= MAX_ROUTE_CONTEXT_HANDLE_LENGTH) {
+    routeContext.handle = requestInfo.handle;
+  }
+  return routeContext;
+}
+async function revalidateWeaverseNextItem(runtime, draftItem, endpoint = DEFAULT_REVALIDATE_ENDPOINT) {
+  let instance = runtime.itemInstances.get(draftItem.id);
+  if (!instance) {
+    throw new Error(
+      `[weaverse-next] No live item instance for "${draftItem.id}".`
+    );
+  }
+  let routeContext = buildWeaverseNextRevalidateRouteContext(
+    runtime.requestInfo
+  );
+  let body = routeContext ? { draftItem, routeContext } : { draftItem };
+  let response = await fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    throw new Error(
+      `[weaverse-next] Revalidate endpoint responded ${response.status}.`
+    );
+  }
+  let { loaderData } = await response.json();
+  instance.setData({ loaderData: loaderData ?? null });
+}
+
+// src/studio-bridge.tsx
+var import_react9 = require("react");
+var STUDIO_BIND_RETRY_INTERVAL_MS = 50;
+var STUDIO_BIND_MAX_ATTEMPTS = 100;
+function WeaverseNextStudioBridge(props) {
+  let { runtime, navigate, revalidate, revalidateItem } = props;
+  let lastRuntimeRef = (0, import_react9.useRef)(runtime);
+  let lastRuntimeDataRef = (0, import_react9.useRef)(runtime.data);
+  let lastRequestInfoRef = (0, import_react9.useRef)(runtime.requestInfo);
+  (0, import_react9.useEffect)(() => {
+    if (navigate) {
+      runtime.internal.navigate = navigate;
+    }
+    if (revalidate) {
+      runtime.internal.revalidate = revalidate;
+    }
+    if (revalidateItem) {
+      runtime.internal.revalidateItem = revalidateItem;
+    }
+    if (bindWeaverseNextStudioRuntime(runtime) || !runtime.isDesignMode) {
+      return;
+    }
+    let attempts = 0;
+    let interval = window.setInterval(() => {
+      attempts += 1;
+      if (bindWeaverseNextStudioRuntime(runtime) || attempts >= STUDIO_BIND_MAX_ATTEMPTS) {
+        window.clearInterval(interval);
+      }
+    }, STUDIO_BIND_RETRY_INTERVAL_MS);
+    return () => window.clearInterval(interval);
+  }, [runtime, navigate, revalidate, revalidateItem]);
+  (0, import_react9.useEffect)(() => {
+    if (lastRuntimeRef.current !== runtime) {
+      lastRuntimeRef.current = runtime;
+      lastRuntimeDataRef.current = runtime.data;
+      lastRequestInfoRef.current = runtime.requestInfo;
+      return;
+    }
+    if (lastRuntimeDataRef.current === runtime.data && lastRequestInfoRef.current === runtime.requestInfo) {
+      return;
+    }
+    lastRuntimeDataRef.current = runtime.data;
+    lastRequestInfoRef.current = runtime.requestInfo;
+    bindWeaverseNextStudioRuntime(runtime);
+  }, [runtime, runtime.data, runtime.requestInfo]);
+  return null;
+}
+
+// src/studio-router.ts
+function shouldResetScroll(options) {
+  if (!options || typeof options !== "object") {
+    return true;
+  }
+  return !options.preventScrollReset;
+}
+function createWeaverseNextStudioInternals(router, options = {}) {
+  return {
+    navigate: (to, navigateOptions) => {
+      let scroll = shouldResetScroll(navigateOptions);
+      if (options.replace) {
+        router.replace(to, { scroll });
+      } else {
+        router.push(to, { scroll });
+      }
+    },
+    revalidate: () => {
+      router.refresh();
+    }
+  };
+}
+
+// src/use-weaverse-next-studio.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+function useWeaverseNextStudioInternals(options) {
+  let router = (0, import_navigation.useRouter)();
+  let ref = (0, import_react10.useRef)(null);
+  if (!ref.current || ref.current.router !== router || ref.current.replace !== options?.replace) {
+    ref.current = {
+      internals: createWeaverseNextStudioInternals(router, options),
+      replace: options?.replace,
+      router
+    };
+  }
+  return ref.current.internals;
+}
+function WeaverseNextStudio(props) {
+  let { runtime, replace, revalidateEndpoint } = props;
+  let { navigate, revalidate } = useWeaverseNextStudioInternals({ replace });
+  let endpoint = revalidateEndpoint ?? DEFAULT_REVALIDATE_ENDPOINT;
+  let revalidateItemRef = (0, import_react10.useRef)(null);
+  if (revalidateItemRef.current?.endpoint !== endpoint || revalidateItemRef.current.runtime !== runtime) {
+    revalidateItemRef.current = {
+      endpoint,
+      revalidateItem: (draftItem) => revalidateWeaverseNextItem(runtime, draftItem, endpoint),
+      runtime
+    };
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+    WeaverseNextStudioBridge,
+    {
+      navigate,
+      revalidate,
+      revalidateItem: revalidateItemRef.current.revalidateItem,
+      runtime
+    }
+  );
+}
+
+// src/renderer.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var EMPTY_DATA_CONTEXT = {};
+var useIsomorphicLayoutEffect = typeof window === "undefined" ? import_react12.useEffect : import_react12.useLayoutEffect;
+function getRenderablePage2(data) {
+  let page = data?.page;
+  if (!page) {
+    return null;
+  }
+  let rootId = page.rootId ?? page.items.find((item) => item.type === "main")?.id ?? page.items[0]?.id ?? page.id;
+  return { ...page, rootId };
+}
+var WeaverseNextRenderer = (0, import_react12.memo)(function WeaverseNextRendererComponent(props) {
+  let context = (0, import_react12.useContext)(WeaverseNextContext);
+  let client = props.client ?? context?.client;
+  let data = props.data ?? client?.data ?? null;
+  let dataContext = props.dataContext ?? client?.dataContext ?? EMPTY_DATA_CONTEXT;
+  let page = (0, import_react12.useMemo)(() => getRenderablePage2(data), [data]);
+  let weaverse = (0, import_react12.useMemo)(() => {
+    if (!page) {
+      return null;
+    }
+    return createWeaverseNextRuntime({
+      client,
+      data: { ...data, page },
+      dataContext,
+      merchantOverrides: context?.merchantOverrides,
+      themeSettingsStore: context?.themeSettingsStore,
+      translationStore: context?.translationStore
+    });
+  }, [
+    client,
+    page,
+    data,
+    dataContext,
+    context?.merchantOverrides,
+    context?.themeSettingsStore,
+    context?.translationStore
+  ]);
+  useIsomorphicLayoutEffect(() => {
+    weaverse?.flushRenderPhaseUpdates();
+  }, [weaverse]);
+  if (!weaverse) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_jsx_runtime6.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react11.WeaverseRoot, { context: weaverse }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(WeaverseNextStudio, { runtime: weaverse })
+  ] });
+});
+
+// src/studio-connect.tsx
+var import_react13 = require("react");
+
+// src/studio-script-src.ts
+var TRUSTED_STUDIO_DOMAINS = ["weaverse.io", "weaverse.dev"];
+function isLoopbackHostname(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".localhost");
+}
+function normalizeOrigin(value) {
+  if (!value) {
+    return null;
+  }
+  try {
+    return new URL(value).origin;
+  } catch {
+    return null;
+  }
+}
+function isTrustedStudioOrigin(origin, storefrontHostname) {
+  let parsed;
+  try {
+    parsed = new URL(origin);
+  } catch {
+    return false;
+  }
+  let { hostname, protocol } = parsed;
+  if (isLoopbackHostname(storefrontHostname) && isLoopbackHostname(hostname)) {
+    return protocol === "http:" || protocol === "https:";
+  }
+  if (protocol !== "https:") {
+    return false;
+  }
+  return TRUSTED_STUDIO_DOMAINS.some(
+    (domain) => hostname === domain || hostname.endsWith(`.${domain}`)
+  );
+}
+function toSearchParams(context) {
+  if (context?.searchParams) {
+    return new URLSearchParams(context.searchParams);
+  }
+  if (context?.url) {
+    let url = typeof context.url === "string" ? new URL(context.url, "http://localhost") : context.url;
+    return new URLSearchParams(url.searchParams);
+  }
+  return new URLSearchParams();
+}
+function last(searchParams, key) {
+  let values = searchParams.getAll(key);
+  return values.length ? values.at(-1) ?? null : null;
+}
+function resolveWeaverseNextStudioScriptSrc(context, options = {}) {
+  let searchParams = toSearchParams(context);
+  let isDesignMode = context?.isDesignMode ?? last(searchParams, "isDesignMode") === "true";
+  let isPreviewMode = context?.isPreviewMode ?? last(searchParams, "isPreviewMode") === "true";
+  let isRevisionPreview = context?.isRevisionPreview ?? Boolean(last(searchParams, "__revisionId"));
+  if (!(isDesignMode || isPreviewMode || isRevisionPreview)) {
+    return null;
+  }
+  let origin = normalizeOrigin(last(searchParams, "weaverseHost"));
+  if (!origin) {
+    return null;
+  }
+  let storefrontHostname = options.storefrontHostname ?? "";
+  if (!isTrustedStudioOrigin(origin, storefrontHostname)) {
+    return null;
+  }
+  let bundle = isPreviewMode || isRevisionPreview ? "preview.js" : "index.js";
+  let version = last(searchParams, "weaverseVersion");
+  let url = `${origin}/static/studio/next/${bundle}`;
+  return version ? `${url}?v=${encodeURIComponent(version)}` : url;
+}
+
+// src/studio-connect.tsx
+var loadedScriptSrcs = /* @__PURE__ */ new Set();
+function loadScript(src) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  if (loadedScriptSrcs.has(src)) {
+    return;
+  }
+  let existing = document.querySelector(`script[src="${src}"]`);
+  if (existing) {
+    loadedScriptSrcs.add(src);
+    return;
+  }
+  let script = document.createElement("script");
+  script.async = true;
+  script.src = src;
+  document.head.appendChild(script);
+  loadedScriptSrcs.add(src);
+}
+function loadWeaverseNextStudioScript(context, options = {}) {
+  let resolvedContext = context;
+  if (!resolvedContext && typeof window !== "undefined") {
+    resolvedContext = {
+      searchParams: new URLSearchParams(window.location.search),
+      url: window.location.href
+    };
+  }
+  let src = resolveWeaverseNextStudioScriptSrc(resolvedContext, {
+    storefrontHostname: options.storefrontHostname ?? (typeof window === "undefined" ? void 0 : window.location.hostname)
+  });
+  if (src) {
+    loadScript(src);
+  }
+}
+function WeaverseNextStudioConnect(props) {
+  (0, import_react13.useEffect)(() => {
+    loadWeaverseNextStudioScript(props.context, {
+      storefrontHostname: props.storefrontHostname
+    });
+  }, [props.context, props.storefrontHostname]);
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ThemeTextProvider,
+  TranslationProvider,
+  WeaverseNextProvider,
+  WeaverseNextRenderer,
+  WeaverseNextRootProvider,
+  WeaverseNextRuntime,
+  WeaverseNextStudio,
+  WeaverseNextStudioBridge,
+  WeaverseNextStudioConnect,
+  bindWeaverseNextStudioRuntime,
+  createWeaverseNextClient,
+  createWeaverseNextRuntime,
+  loadWeaverseNextStudioScript,
+  useChildInstances,
+  useItemInstance,
+  useParentInstance,
+  useThemeSettings,
+  useThemeText,
+  useTranslation,
+  useWeaverse,
+  useWeaverseCommerce,
+  useWeaverseNextStudioInternals,
+  useWeaversePageData,
+  useWeaverseRootData
+});
+//# sourceMappingURL=client-boundary.js.map