@weaverse/next 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/index.js

@@ -4,6 +4,7 @@ var react = require('@weaverse/react');
 var schema = require('@weaverse/schema');
 var jsxRuntime = require('react/jsx-runtime');
 var react$1 = require('react');
+var navigation = require('next/navigation');
 
 // src/index.ts
 
@@ -26,13 +27,84 @@ function generateDataFromSchema(schema) {
 }
 
 // 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 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;
   constructor(initialData, weaverse) {
     super(initialData, weaverse);
-    let { data, ...rest } = initialData;
     let schemaData = generateDataFromSchema(this.Element?.schema);
-    Object.assign(this._store, schemaData, data, rest);
+    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), and
+   * the inherited shallow merge would leave stale top-level props behind.
+   * Assigning through the inherited `data` setter swaps the `_store` ref,
+   * 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) => {
+    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 (!react.Weaverse.ItemConstructor || react.Weaverse.ItemConstructor === react.WeaverseItemStore || react.Weaverse.ItemConstructor === WeaverseNextItem) {
@@ -157,30 +229,258 @@ function createWeaverseNextThemeSettingsStore(options = {}) {
   };
   return store;
 }
+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);
+  });
+}
+var TranslationContext = react$1.createContext(null);
+TranslationContext.displayName = "WeaverseNextTranslationContext";
+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);
+  };
+}
+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 = react.useSafeExternalStore(
+    store?.subscribe ?? NOOP_SUBSCRIBE,
+    store?.getSnapshot ?? NOOP_SNAPSHOT,
+    store?.getServerSnapshot ?? NOOP_SNAPSHOT
+  );
+  let value = react$1.useMemo(
+    () => ({
+      t: createTranslate({
+        staticContent,
+        merchantOverrides,
+        designOverrides,
+        externalT
+      }),
+      translationStore: store,
+      // Deprecated alias — same instance, kept for backward compatibility.
+      themeTextStore: store,
+      merchantOverrides: merchantOverrides ?? null
+    }),
+    [staticContent, merchantOverrides, designOverrides, externalT, store]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(TranslationContext.Provider, { value, children });
+}
+function useTranslation() {
+  let ctx = react$1.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 {
+  overrides = {};
+  listeners = /* @__PURE__ */ new Set();
+  setOverrides = (overrides) => {
+    this.overrides = { ...overrides };
+    this.emit();
+  };
+  updateOverrides = (newOverrides) => {
+    this.overrides = { ...this.overrides, ...newOverrides };
+    this.emit();
+  };
+  getSnapshot = () => this.overrides;
+  getServerSnapshot = () => this.overrides;
+  subscribe = (callback) => {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  };
+  emit = () => {
+    for (const listener of Array.from(this.listeners)) {
+      try {
+        listener();
+      } catch (error) {
+        console.error("TranslationStore: Listener error", error);
+      }
+    }
+  };
+};
+var ThemeTextStore = TranslationStore;
+var WeaverseNextRootContext = react$1.createContext(null);
+function WeaverseNextRootProvider(props) {
+  let {
+    children,
+    initialThemeSettings,
+    merchantOverrides,
+    staticContent,
+    t,
+    themeSchema,
+    publicEnv
+  } = props;
+  let storeRef = react$1.useRef(null);
+  if (!storeRef.current) {
+    storeRef.current = createWeaverseNextThemeSettingsStore({
+      publicEnv,
+      schema: themeSchema,
+      settings: initialThemeSettings
+    });
+  }
+  let themeSettingsStore = storeRef.current;
+  let translationStoreRef = react$1.useRef(null);
+  if (!translationStoreRef.current) {
+    translationStoreRef.current = new TranslationStore();
+  }
+  let translationStore = translationStoreRef.current;
+  let appliedThemeSettingsRef = react$1.useRef(initialThemeSettings);
+  react$1.useEffect(() => {
+    if (initialThemeSettings && appliedThemeSettingsRef.current !== initialThemeSettings) {
+      themeSettingsStore.updateThemeSettings(initialThemeSettings);
+      appliedThemeSettingsRef.current = initialThemeSettings;
+    }
+  }, [initialThemeSettings, themeSettingsStore]);
+  let resolvedStaticContent = staticContent ?? getSchemaStaticContent(themeSchema);
+  let rootContextValue = react$1.useMemo(
+    () => ({
+      merchantOverrides,
+      staticContent: resolvedStaticContent,
+      themeSettingsStore,
+      translationStore
+    }),
+    [
+      merchantOverrides,
+      resolvedStaticContent,
+      themeSettingsStore,
+      translationStore
+    ]
+  );
+  let contextValue = react$1.useMemo(
+    () => ({
+      merchantOverrides,
+      themeSettings: themeSettingsStore.getSnapshot(),
+      themeSettingsStore,
+      translationStore
+    }),
+    [merchantOverrides, themeSettingsStore, translationStore]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(WeaverseNextRootContext.Provider, { value: rootContextValue, children: /* @__PURE__ */ jsxRuntime.jsx(WeaverseNextContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx(
+    TranslationProvider,
+    {
+      merchantOverrides,
+      staticContent: resolvedStaticContent,
+      t,
+      translationStore,
+      children
+    }
+  ) }) });
+}
 var EMPTY_THEME_SETTINGS = {};
+var EMPTY_STATIC_CONTENT = {};
+function getSchemaStaticContent(schema) {
+  let i18n = schema?.i18n;
+  return i18n?.staticContent ?? EMPTY_STATIC_CONTENT;
+}
 var WeaverseNextContext = react$1.createContext(null);
 function WeaverseNextProvider(props) {
   let { children, client, rootData, pageData, commerce, themeSettings } = props;
+  let rootContext = react$1.useContext(WeaverseNextRootContext);
   let themeSettingsValue = themeSettings ?? client?.themeSettings ?? EMPTY_THEME_SETTINGS;
-  let themeSettingsStore = react$1.useMemo(
-    () => createWeaverseNextThemeSettingsStore({
+  let ownTranslationStoreRef = react$1.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 = react$1.useMemo(() => {
+    if (rootContext) {
+      return null;
+    }
+    return createWeaverseNextThemeSettingsStore({
       schema: client?.themeSchema,
       settings: themeSettingsValue
-    }),
-    [client?.themeSchema, themeSettingsValue]
-  );
+    });
+  }, [rootContext, client?.themeSchema, themeSettingsValue]);
+  let themeSettingsStore = rootContext?.themeSettingsStore ?? ownThemeSettingsStore;
+  let mergedIntoRootRef = react$1.useRef(void 0);
+  react$1.useEffect(() => {
+    if (rootContext && themeSettingsValue !== EMPTY_THEME_SETTINGS && mergedIntoRootRef.current !== themeSettingsValue) {
+      rootContext.themeSettingsStore.updateThemeSettings(themeSettingsValue);
+      mergedIntoRootRef.current = themeSettingsValue;
+    }
+  }, [rootContext, themeSettingsValue]);
   let value = react$1.useMemo(
     () => ({
       client,
       rootData,
       pageData,
       commerce: commerce ?? client?.commerce,
+      merchantOverrides,
       themeSettings: themeSettingsStore.getSnapshot(),
-      themeSettingsStore
+      themeSettingsStore,
+      translationStore
     }),
-    [client, rootData, pageData, commerce, themeSettingsStore]
+    [
+      client,
+      rootData,
+      pageData,
+      commerce,
+      merchantOverrides,
+      themeSettingsStore,
+      translationStore
+    ]
   );
-  return /* @__PURE__ */ jsxRuntime.jsx(WeaverseNextContext.Provider, { value, children });
+  return /* @__PURE__ */ jsxRuntime.jsx(WeaverseNextContext.Provider, { value, children: /* @__PURE__ */ jsxRuntime.jsx(
+    TranslationProvider,
+    {
+      merchantOverrides,
+      staticContent,
+      t: props.t,
+      translationStore,
+      children
+    }
+  ) });
 }
 
 // src/hooks.ts
@@ -327,8 +627,22 @@ function toQueryRecord(searchParams) {
   }
   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 = getSearchParamsFromContext(context);
+  let searchParams = getRequestInfoSearchParams(context);
   let search = searchParams.toString();
   return {
     pathname: getPathnameFromContext(context),
@@ -394,9 +708,31 @@ var WeaverseNextRuntime = class extends react.Weaverse {
   isPreviewMode;
   isRevisionPreview;
   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 = {};
-  translationLocale = "";
-  translationLanguageId = "";
+  translationLocale = String();
+  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 = [];
   constructor(config) {
     let { client, data } = config;
     let page = getRenderablePage(data);
@@ -418,7 +754,9 @@ var WeaverseNextRuntime = class extends react.Weaverse {
     this.isPreviewMode = requestContext?.isPreviewMode ?? false;
     this.isRevisionPreview = requestContext?.isRevisionPreview ?? false;
     this.sectionType = requestContext?.sectionType;
+    let translationStore = config.translationStore ?? new TranslationStore();
     this.internal = {
+      merchantOverrides: config.merchantOverrides,
       navigate: config.navigate,
       pageAssignment: data.pageAssignment,
       project: data.project,
@@ -426,17 +764,119 @@ var WeaverseNextRuntime = class extends react.Weaverse {
       themeSettingsStore: config.themeSettingsStore ?? createWeaverseNextThemeSettingsStore({
         schema: client?.themeSchema,
         settings: client?.themeSettings
-      })
+      }),
+      translationStore,
+      themeTextStore: translationStore
     };
+    this.extractTranslationSidecar();
   }
-  extractTranslationSidecar = () => void 0;
+  /**
+   * 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();
+      }
+    }
   };
-  updateTranslation = () => void 0;
-  getTranslationChanges = () => void 0;
 };
 function createWeaverseNextRuntime(config) {
   let requestInfo = buildWeaverseNextRequestInfo(config.client?.requestContext);
@@ -446,9 +886,12 @@ function createWeaverseNextRuntime(config) {
   let requestKey = getRuntimeKey(page.id, requestInfo);
   if (existing?.__weaverseNextRequestKey === requestKey) {
     let nextIsDesignMode = config.client?.requestContext?.isDesignMode ?? false;
-    if (!(existing.isDesignMode || nextIsDesignMode)) {
-      existing.setProjectData(page);
+    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);
@@ -469,11 +912,20 @@ function createWeaverseNextRuntime(config) {
     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 = new WeaverseNextRuntime(config);
+  let [runtime, refreshedItems] = collectDeferredItemUpdates(
+    () => new WeaverseNextRuntime(config)
+  );
+  runtime.pendingItemUpdates = refreshedItems;
   runtime.__weaverseNextRequestKey = requestKey;
+  runtime.__weaverseNextLatestData = page;
   registerRuntime(runtime);
   return runtime;
 }
@@ -486,22 +938,48 @@ function bindWeaverseNextStudioRuntime(runtime) {
     return false;
   }
   let boundRuntime = runtime;
-  if (!boundRuntime.__weaverseNextStudioBound) {
+  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: runtime.data,
+    data: boundRuntime.__weaverseNextLatestData ?? runtime.data,
     pageId: runtime.pageId,
     requestInfo: runtime.requestInfo
   });
   return true;
 }
+
+// src/revalidate-item.ts
+var DEFAULT_REVALIDATE_ENDPOINT = "/api/weaverse/revalidate";
+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 response = await fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ draftItem })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `[weaverse-next] Revalidate endpoint responded ${response.status}.`
+    );
+  }
+  let { loaderData } = await response.json();
+  instance.setData({ loaderData: loaderData ?? null });
+}
 var STUDIO_BIND_RETRY_INTERVAL_MS = 50;
 var STUDIO_BIND_MAX_ATTEMPTS = 100;
 function WeaverseNextStudioBridge(props) {
-  let { runtime, navigate, revalidate } = props;
+  let { runtime, navigate, revalidate, revalidateItem } = props;
   let lastRuntimeRef = react$1.useRef(runtime);
   let lastRuntimeDataRef = react$1.useRef(runtime.data);
   let lastRequestInfoRef = react$1.useRef(runtime.requestInfo);
@@ -512,6 +990,9 @@ function WeaverseNextStudioBridge(props) {
     if (revalidate) {
       runtime.internal.revalidate = revalidate;
     }
+    if (revalidateItem) {
+      runtime.internal.revalidateItem = revalidateItem;
+    }
     if (bindWeaverseNextStudioRuntime(runtime) || !runtime.isDesignMode) {
       return;
     }
@@ -523,7 +1004,7 @@ function WeaverseNextStudioBridge(props) {
       }
     }, STUDIO_BIND_RETRY_INTERVAL_MS);
     return () => window.clearInterval(interval);
-  }, [runtime, navigate, revalidate]);
+  }, [runtime, navigate, revalidate, revalidateItem]);
   react$1.useEffect(() => {
     if (lastRuntimeRef.current !== runtime) {
       lastRuntimeRef.current = runtime;
@@ -540,7 +1021,65 @@ function WeaverseNextStudioBridge(props) {
   }, [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();
+    }
+  };
+}
+function useWeaverseNextStudioInternals(options) {
+  let router = navigation.useRouter();
+  let ref = react$1.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 = react$1.useRef(null);
+  if (revalidateItemRef.current?.endpoint !== endpoint || revalidateItemRef.current.runtime !== runtime) {
+    revalidateItemRef.current = {
+      endpoint,
+      revalidateItem: (draftItem) => revalidateWeaverseNextItem(runtime, draftItem, endpoint),
+      runtime
+    };
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    WeaverseNextStudioBridge,
+    {
+      navigate,
+      revalidate,
+      revalidateItem: revalidateItemRef.current.revalidateItem,
+      runtime
+    }
+  );
+}
 var EMPTY_DATA_CONTEXT = {};
+var useIsomorphicLayoutEffect = typeof window === "undefined" ? react$1.useEffect : react$1.useLayoutEffect;
 function getRenderablePage2(data) {
   let page = data?.page;
   if (!page) {
@@ -563,18 +1102,87 @@ var WeaverseNextRenderer = react$1.memo(function WeaverseNextRendererComponent(p
       client,
       data: { ...data, page },
       dataContext,
-      themeSettingsStore: context?.themeSettingsStore
+      merchantOverrides: context?.merchantOverrides,
+      themeSettingsStore: context?.themeSettingsStore,
+      translationStore: context?.translationStore
     });
-  }, [client, page, data, dataContext, context?.themeSettingsStore]);
+  }, [
+    client,
+    page,
+    data,
+    dataContext,
+    context?.merchantOverrides,
+    context?.themeSettingsStore,
+    context?.translationStore
+  ]);
+  useIsomorphicLayoutEffect(() => {
+    weaverse?.flushRenderPhaseUpdates();
+  }, [weaverse]);
   if (!weaverse) {
     return null;
   }
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsx(react.WeaverseRoot, { context: weaverse }),
-    /* @__PURE__ */ jsxRuntime.jsx(WeaverseNextStudioBridge, { runtime: weaverse })
+    /* @__PURE__ */ jsxRuntime.jsx(WeaverseNextStudio, { runtime: weaverse })
   ] });
 });
 
+// src/seo.ts
+function hasOpenGraphContent(seo) {
+  return Boolean(seo?.title || seo?.description || seo?.image || seo?.type);
+}
+function hasTwitterContent(seo) {
+  return Boolean(seo?.title || seo?.description || seo?.image || seo?.cardType);
+}
+function formatWeaverseNextSeoMetadata(seo) {
+  let index = seo?.robots?.index !== false;
+  let follow = seo?.robots?.follow !== false;
+  let metadata = {
+    robots: { index, follow }
+  };
+  if (!seo) {
+    return metadata;
+  }
+  if (seo.title) {
+    metadata.title = seo.title;
+  }
+  if (seo.description) {
+    metadata.description = seo.description;
+  }
+  if (seo.keywords) {
+    metadata.keywords = seo.keywords;
+  }
+  if (seo.canonicalUrl) {
+    metadata.alternates = { canonical: seo.canonicalUrl };
+  }
+  let openGraph = seo.openGraph;
+  if (hasOpenGraphContent(openGraph)) {
+    metadata.openGraph = {
+      title: openGraph?.title,
+      description: openGraph?.description,
+      images: openGraph?.image ? [openGraph.image] : void 0,
+      type: openGraph?.type || "website"
+    };
+  }
+  let twitter = seo.twitter;
+  if (hasTwitterContent(twitter)) {
+    metadata.twitter = {
+      card: twitter?.cardType || "summary",
+      title: twitter?.title,
+      description: twitter?.description,
+      images: twitter?.image ? [twitter.image] : void 0
+    };
+  }
+  return metadata;
+}
+function getWeaverseNextSeoMetadata(data) {
+  if (!data) {
+    return formatWeaverseNextSeoMetadata(null);
+  }
+  let page = "items" in data && "id" in data ? data : data.page ?? null;
+  return formatWeaverseNextSeoMetadata(page?.seo ?? null);
+}
+
 // src/studio-script-src.ts
 var TRUSTED_STUDIO_DOMAINS = ["weaverse.io", "weaverse.dev"];
 function isLoopbackHostname(hostname) {
@@ -638,10 +1246,9 @@ function resolveWeaverseNextStudioScriptSrc(context, options = {}) {
   if (!isTrustedStudioOrigin(origin, storefrontHostname)) {
     return null;
   }
-  let framework = options.framework ?? "hydrogen";
   let bundle = isDesignMode ? "index.js" : "preview.js";
   let version = last(searchParams, "weaverseVersion");
-  let url = `${origin}/static/studio/${framework}/${bundle}`;
+  let url = `${origin}/static/studio/next/${bundle}`;
   return version ? `${url}?v=${encodeURIComponent(version)}` : url;
 }
 
@@ -665,21 +1272,26 @@ function loadScript(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) {
   react$1.useEffect(() => {
-    let context = props.context;
-    if (!context && typeof window !== "undefined") {
-      context = {
-        searchParams: new URLSearchParams(window.location.search),
-        url: window.location.href
-      };
-    }
-    let src = resolveWeaverseNextStudioScriptSrc(context, {
-      storefrontHostname: props.storefrontHostname ?? (typeof window === "undefined" ? void 0 : window.location.hostname)
+    loadWeaverseNextStudioScript(props.context, {
+      storefrontHostname: props.storefrontHostname
     });
-    if (src) {
-      loadScript(src);
-    }
   }, [props.context, props.storefrontHostname]);
   return null;
 }
@@ -708,25 +1320,46 @@ Object.defineProperty(exports, "useWeaverse", {
   enumerable: true,
   get: function () { return react.useWeaverse; }
 });
-Object.defineProperty(exports, "createSchema", {
-  enumerable: true,
-  get: function () { return schema.createSchema; }
-});
+exports.DEFAULT_REVALIDATE_ENDPOINT = DEFAULT_REVALIDATE_ENDPOINT;
+exports.ThemeTextProvider = ThemeTextProvider;
+exports.ThemeTextStore = ThemeTextStore;
+exports.TranslationProvider = TranslationProvider;
+exports.TranslationStore = TranslationStore;
 exports.WeaverseNextProvider = WeaverseNextProvider;
 exports.WeaverseNextRenderer = WeaverseNextRenderer;
+exports.WeaverseNextRootProvider = WeaverseNextRootProvider;
 exports.WeaverseNextRuntime = WeaverseNextRuntime;
+exports.WeaverseNextStudio = WeaverseNextStudio;
 exports.WeaverseNextStudioBridge = WeaverseNextStudioBridge;
 exports.WeaverseNextStudioConnect = WeaverseNextStudioConnect;
 exports.bindWeaverseNextStudioRuntime = bindWeaverseNextStudioRuntime;
 exports.buildWeaverseNextRequestInfo = buildWeaverseNextRequestInfo;
+exports.createTranslate = createTranslate;
 exports.createWeaverseNextClient = createWeaverseNextClient;
 exports.createWeaverseNextRuntime = createWeaverseNextRuntime;
+exports.createWeaverseNextStudioInternals = createWeaverseNextStudioInternals;
 exports.createWeaverseNextThemeSettingsStore = createWeaverseNextThemeSettingsStore;
+exports.formatWeaverseNextSeoMetadata = formatWeaverseNextSeoMetadata;
+exports.generateDataFromSchema = generateDataFromSchema;
+exports.getNestedKey = getNestedKey;
+exports.getWeaverseNextSeoMetadata = getWeaverseNextSeoMetadata;
+exports.interpolate = interpolate;
+exports.loadWeaverseNextStudioScript = loadWeaverseNextStudioScript;
 exports.resolveWeaverseNextStudioScriptSrc = resolveWeaverseNextStudioScriptSrc;
+exports.revalidateWeaverseNextItem = revalidateWeaverseNextItem;
 exports.runWeaverseComponentLoaders = runWeaverseComponentLoaders;
 exports.useThemeSettings = useThemeSettings;
+exports.useThemeText = useThemeText;
+exports.useTranslation = useTranslation;
 exports.useWeaverseCommerce = useWeaverseCommerce;
+exports.useWeaverseNextStudioInternals = useWeaverseNextStudioInternals;
 exports.useWeaversePageData = useWeaversePageData;
 exports.useWeaverseRootData = useWeaverseRootData;
+Object.keys(schema).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return schema[k]; }
+  });
+});
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map