@weaverse/next 0.1.0-alpha.13 → 0.1.0-alpha.15

package/dist/types/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/provider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAKf,MAAM,OAAO,CAAA;AAGd,OAAO,EACL,KAAK,iBAAiB,EAEvB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EACV,kBAAkB,EAClB,2BAA2B,EAC3B,8BAA8B,EAC/B,MAAM,SAAS,CAAA;AAKhB,iFAAiF;AACjF,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,GACd,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIzB;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC,4EAA4E;IAC5E,MAAM,CAAC,EAAE,kBAAkB,CAAA;IAC3B,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,2BAA2B,CAAA;IACtC,sEAAsE;IACtE,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC3C,uDAAuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,2CAA2C;IAC3C,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,gEAAgE;IAChE,kBAAkB,EAAE,8BAA8B,CAAA;IAClD,8EAA8E;IAC9E,gBAAgB,EAAE,gBAAgB,CAAA;CACnC;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,0DACsB,CAAA;AAEtD,gFAAgF;AAChF,MAAM,WAAW,yBAAyB;IACxC,8DAA8D;IAC9D,QAAQ,EAAE,SAAS,CAAA;IACnB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,kBAAkB,CAAA;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,EAAE,2BAA2B,CAAA;IACtC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC3C,kFAAkF;IAClF,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACvC,qFAAqF;IACrF,CAAC,CAAC,EAAE,iBAAiB,CAAA;IACrB,qEAAqE;IACrE,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACxC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,yBAAyB,2CA+GpE"}

package/dist/types/registry.d.ts

@@ -0,0 +1,15 @@
+import type { WeaverseNextComponent } from './types';
+/**
+ * Register Next adapter components with the shared Weaverse element registry.
+ *
+ * This mutates global Weaverse runtime state, so callers should run it while
+ * creating their app/client wiring, not from a React render body.
+ *
+ * A default `main` root component is always registered first so consumers don't
+ * have to register one for basic page-tree rendering. If the consumer registers
+ * their own `main`, that one is preferred: we only prepend the default when the
+ * provided components don't already include a `main`, so a user-provided `main`
+ * never collides with (or is shadowed by) the default.
+ */
+export declare function registerWeaverseNextComponents(components: WeaverseNextComponent[]): void;
+//# sourceMappingURL=registry.d.ts.map

package/dist/types/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAWpD;;;;;;;;;;;GAWG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,qBAAqB,EAAE,QAmCpC"}

package/dist/types/renderer.d.ts

@@ -0,0 +1,20 @@
+import type { WeaverseNextClient, WeaverseNextLoaderData } from './types';
+/** Page payload, client, and connector data accepted by the Next renderer. */
+export interface WeaverseNextRendererProps {
+    /** Client to render from. Defaults to the provider's client. */
+    client?: WeaverseNextClient;
+    /** Page payload to render. Defaults to `client.data`. */
+    data?: WeaverseNextLoaderData | null;
+    /** Data-connector context for `{{...}}` template replacement. */
+    dataContext?: Record<string, unknown>;
+}
+/**
+ * Render a serialized Weaverse page tree through `@weaverse/react` primitives.
+ *
+ * Reads the client/page data supplied by {@link WeaverseNextProvider} when no
+ * props are passed, or accepts an explicit `client` + `data` for standalone use. Builds a
+ * framework-neutral `Weaverse` core instance (no React Router hooks) and hands
+ * it to the shared `WeaverseRoot`.
+ */
+export declare const WeaverseNextRenderer: import("react").MemoExoticComponent<(props: WeaverseNextRendererProps) => import("react/jsx-runtime").JSX.Element | null>;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/types/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/renderer.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EAEvB,MAAM,SAAS,CAAA;AAsBhB,8EAA8E;AAC9E,MAAM,WAAW,yBAAyB;IACxC,gEAAgE;IAChE,MAAM,CAAC,EAAE,kBAAkB,CAAA;IAC3B,yDAAyD;IACzD,IAAI,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAA;IACpC,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACtC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,8CACxB,yBAAyB,oDA+ChC,CAAA"}

package/dist/types/request-info.d.ts

@@ -0,0 +1,8 @@
+import type { WeaverseNextRequestContext, WeaverseNextRequestInfo } from './types';
+/**
+ * Build the Hydrogen-like request info shape consumed by the Studio bridge.
+ * Duplicate query keys keep the last value, matching `URLSearchParams` iteration
+ * assignment and Hydrogen's practical query-object behavior.
+ */
+export declare function buildWeaverseNextRequestInfo(context?: WeaverseNextRequestContext): WeaverseNextRequestInfo;
+//# sourceMappingURL=request-info.d.ts.map

package/dist/types/request-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-info.d.ts","sourceRoot":"","sources":["../../src/request-info.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAC1B,uBAAuB,EACxB,MAAM,SAAS,CAAA;AAwEhB;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,CAAC,EAAE,0BAA0B,GACnC,uBAAuB,CAYzB"}

package/dist/types/revalidate-item.d.ts

@@ -0,0 +1,81 @@
+import type { PageType } from '@weaverse/schema';
+import type { WeaverseNextComponentData, WeaverseNextI18n, WeaverseNextRequestInfo } from './types';
+/** Default App Router endpoint used for Studio item-loader revalidation. */
+export declare const DEFAULT_REVALIDATE_ENDPOINT = "/api/weaverse/revalidate";
+/**
+ * Server-owned and transient controls stripped from the revalidation route
+ * context on both sides of the trust boundary. Compared case-insensitively, so
+ * every entry is stored lowercased. Client sanitization keeps normal traffic
+ * clean; the route handler repeats this deny-list as the security boundary.
+ *
+ * - Server-owned: a crafted `?weaverseProjectId=`/`?weaverseHost=`/`?weaverseApiKey=`
+ *   must never influence server config resolution (see `getWeaverseNextConfigs`).
+ * - Transient: draft-item and RSC transport params never describe route identity.
+ */
+export declare const DENIED_ROUTE_CONTEXT_PARAMS: string[];
+/** i18n fields allowed to cross the browser boundary. */
+export declare const ROUTE_CONTEXT_I18N_KEYS: readonly ["country", "label", "language", "locale", "pathPrefix"];
+/**
+ * JSON-safe route subset that may cross the browser boundary alongside the
+ * draft item. Never carries headers, cookies, auth, env, project ID, Studio
+ * host, API keys/bases, commerce clients, the request context, runtime, or
+ * client. `search` is canonical (preserves duplicate keys); the derived
+ * `queries` record is intentionally omitted.
+ */
+export interface WeaverseNextRevalidateRouteContext {
+    /** Route handle used for page assignment. */
+    handle?: string;
+    /** Public locale and market identity allowed across the browser boundary. */
+    i18n?: Pick<WeaverseNextI18n, 'country' | 'label' | 'language' | 'locale' | 'pathPrefix'>;
+    /** Weaverse page type resolved by the active route. */
+    pageType?: PageType;
+    /** Canonical same-origin route pathname. */
+    pathname: string;
+    /** Sanitized serialized query string, including the leading `?` when set. */
+    search: string;
+}
+/**
+ * Minimal runtime surface the in-place apply needs. Structural (not the
+ * concrete `WeaverseNextRuntime` class) so unit tests can drive it with a
+ * plain mock. `requestInfo` stays optional: a real `WeaverseNextRuntime`
+ * always supplies it, but when absent the client omits `routeContext` and the
+ * legacy `{ draftItem }` request is preserved.
+ */
+export interface RevalidateItemRuntimeLike {
+    /** Live item stores keyed by Weaverse item ID. */
+    itemInstances: Map<string, {
+        /** Merge refreshed loader data into the live item store. */
+        setData: (update: Record<string, unknown>) => unknown;
+    }>;
+    /** Active route identity used to construct the optional revalidation payload. */
+    requestInfo?: WeaverseNextRequestInfo;
+}
+/**
+ * Strip denied (server-owned/transient) controls from a `search` string and
+ * re-serialize it. Preserves ordinary application queries, duplicate keys,
+ * encoded Unicode, and mode controls (`isDesignMode`, `isPreviewMode`,
+ * `__revisionId`, `sectionType`). Returns `''` or a `?`-prefixed string.
+ */
+export declare function sanitizeRouteContextSearch(search: string): string;
+/**
+ * Build the sanitized {@link WeaverseNextRevalidateRouteContext} from the
+ * active runtime's request info. Returns `undefined` without a usable pathname
+ * so the caller omits `routeContext` and keeps the legacy request. This is not
+ * the security boundary — the route handler re-validates and re-sanitizes.
+ */
+export declare function buildWeaverseNextRevalidateRouteContext(requestInfo?: WeaverseNextRequestInfo): WeaverseNextRevalidateRouteContext | undefined;
+/**
+ * Studio per-item loader revalidation: POST the unsaved draft item (and, when
+ * the runtime exposes route context, a sanitized `routeContext`) to the app's
+ * revalidate route (see `createWeaverseNextRevalidateHandler`) and apply the
+ * returned `loaderData` to the live item instance in place.
+ *
+ * No `router.refresh()` is involved, so the RSC tree is never re-applied — no
+ * page remount, no scroll reset, and the draft payload never touches the URL.
+ *
+ * Throws on any failure (missing route, non-OK response, unknown item) so the
+ * Builder Studio bridge can detect the miss and fall back to its legacy
+ * refresh-based revalidation for this window.
+ */
+export declare function revalidateWeaverseNextItem(runtime: RevalidateItemRuntimeLike, draftItem: WeaverseNextComponentData, endpoint?: string): Promise<void>;
+//# sourceMappingURL=revalidate-item.d.ts.map

package/dist/types/revalidate-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revalidate-item.d.ts","sourceRoot":"","sources":["../../src/revalidate-item.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD,OAAO,KAAK,EACV,yBAAyB,EACzB,gBAAgB,EAChB,uBAAuB,EACxB,MAAM,SAAS,CAAA;AAEhB,4EAA4E;AAC5E,eAAO,MAAM,2BAA2B,6BAA6B,CAAA;AAIrE;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,UAWvC,CAAA;AAED,yDAAyD;AACzD,eAAO,MAAM,uBAAuB,mEAM1B,CAAA;AAEV;;;;;;GAMG;AACH,MAAM,WAAW,kCAAkC;IACjD,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,6EAA6E;IAC7E,IAAI,CAAC,EAAE,IAAI,CACT,gBAAgB,EAChB,SAAS,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,GAAG,YAAY,CAC3D,CAAA;IACD,uDAAuD;IACvD,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAA;IAChB,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,kDAAkD;IAClD,aAAa,EAAE,GAAG,CAChB,MAAM,EACN;QACE,4DAA4D;QAC5D,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAA;KACtD,CACF,CAAA;IACD,iFAAiF;IACjF,WAAW,CAAC,EAAE,uBAAuB,CAAA;CACtC;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAUjE;AAED;;;;;GAKG;AACH,wBAAgB,uCAAuC,CACrD,WAAW,CAAC,EAAE,uBAAuB,GACpC,kCAAkC,GAAG,SAAS,CA4ChD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,yBAAyB,EAClC,SAAS,EAAE,yBAAyB,EACpC,QAAQ,GAAE,MAAoC,GAC7C,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/dist/types/root-provider.d.ts

@@ -0,0 +1,61 @@
+import { type ReactNode } from 'react';
+import { type TranslateFunction } from './translation-context';
+import { TranslationStore } from './translation-store';
+import type { WeaverseNextThemeSchema, WeaverseNextThemeSettingsStore } from './types';
+/** Root-scoped theme and translation stores adopted by route providers. */
+export interface WeaverseNextRootContextValue {
+    /** Active-locale static-text overrides shared with route-level providers. */
+    merchantOverrides?: Record<string, unknown>;
+    /** Theme default locale JSON shared with route-level providers. */
+    staticContent: Record<string, unknown>;
+    /** Root-scoped external store shared with route-level providers. */
+    themeSettingsStore: WeaverseNextThemeSettingsStore;
+    /** Single live design-mode static-text override store for the whole session. */
+    translationStore: TranslationStore;
+}
+/**
+ * Ambient root-scoped context. Route-level `WeaverseNextProvider` reads this to
+ * adopt the shared theme settings store instead of creating its own.
+ */
+export declare const WeaverseNextRootContext: import("react").Context<WeaverseNextRootContextValue | null>;
+/** Root theme and translation data shared across the App Router tree. */
+export interface WeaverseNextRootProviderProps {
+    /** Application subtree, including global and route-level components. */
+    children: ReactNode;
+    /** Root-loaded theme settings (published-mode fetch, no design-mode context). */
+    initialThemeSettings?: Record<string, unknown>;
+    /** Active-locale static-text overrides from `loadThemeSettings().merchantOverrides`. */
+    merchantOverrides?: Record<string, unknown>;
+    /** Public environment values exposed to the theme-settings store. */
+    publicEnv?: Record<string, string | undefined>;
+    /**
+     * Theme default locale JSON (`loadThemeSettings().staticContent`). Falls back
+     * to `themeSchema.i18n.staticContent` when omitted.
+     */
+    staticContent?: Record<string, unknown>;
+    /** Optional external translation function (host i18n); highest priority in `t()`. */
+    t?: TranslateFunction;
+    /** Theme schema associated with the initial settings. */
+    themeSchema?: WeaverseNextThemeSchema;
+}
+/**
+ * Root-scoped client boundary that owns the single `WeaverseNextThemeSettingsStore`
+ * for the whole app session, matching Hydrogen's `withWeaverse()` root store.
+ * Mount once in `app/layout.tsx`, above `Header`/`Footer`/global modules and any
+ * route-level `WeaverseNextProvider`.
+ *
+ * Also renders `WeaverseNextContext` with a minimal value so `useThemeSettings()`
+ * works for components mounted directly under this provider, even without a
+ * route-level `WeaverseNextProvider` above them.
+ *
+ * @example
+ * ```tsx
+ * <WeaverseNextRootProvider initialThemeSettings={theme.theme} themeSchema={theme.schema}>
+ *   <Header />
+ *   {children}
+ *   <Footer />
+ * </WeaverseNextRootProvider>
+ * ```
+ */
+export declare function WeaverseNextRootProvider(props: WeaverseNextRootProviderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=root-provider.d.ts.map

package/dist/types/root-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-provider.d.ts","sourceRoot":"","sources":["../../src/root-provider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAIf,MAAM,OAAO,CAAA;AAOd,OAAO,EACL,KAAK,iBAAiB,EAEvB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EACV,uBAAuB,EACvB,8BAA8B,EAC/B,MAAM,SAAS,CAAA;AAEhB,2EAA2E;AAC3E,MAAM,WAAW,4BAA4B;IAC3C,6EAA6E;IAC7E,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC3C,mEAAmE;IACnE,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,oEAAoE;IACpE,kBAAkB,EAAE,8BAA8B,CAAA;IAClD,gFAAgF;IAChF,gBAAgB,EAAE,gBAAgB,CAAA;CACnC;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,8DACsB,CAAA;AAE1D,yEAAyE;AACzE,MAAM,WAAW,6BAA6B;IAC5C,wEAAwE;IACxE,QAAQ,EAAE,SAAS,CAAA;IACnB,iFAAiF;IACjF,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9C,wFAAwF;IACxF,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC3C,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;IAC9C;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACvC,qFAAqF;IACrF,CAAC,CAAC,EAAE,iBAAiB,CAAA;IACrB,yDAAyD;IACzD,WAAW,CAAC,EAAE,uBAAuB,CAAA;CACtC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,6BAA6B,2CAgG5E"}

package/dist/types/runtime.d.ts

@@ -0,0 +1,113 @@
+import { Weaverse } from '@weaverse/react';
+import { type WeaverseNextItem } from './item';
+import type { WeaverseNextPageData, WeaverseNextRequestInfo, WeaverseNextRuntimeConfig, WeaverseNextRuntimeInternal, WeaverseNextTranslationChanges, WeaverseNextTranslationMap } from './types';
+declare global {
+    interface Window {
+        __weaverse?: WeaverseNextRuntime;
+        __weaverses?: Record<string, WeaverseNextRuntime>;
+    }
+}
+/** Weaverse page data with the root component resolved for rendering. */
+export interface WeaverseNextRenderablePage extends WeaverseNextPageData {
+    /** Component item ID used as the root of the rendered page tree. */
+    rootId: string;
+}
+/**
+ * Browser runtime that adapts a Next.js loader payload to `@weaverse/react`
+ * and exposes the navigation, settings, and translation state used by Studio.
+ */
+export declare class WeaverseNextRuntime extends Weaverse {
+    /** Stable ID of the page owned by this runtime. */
+    pageId: string;
+    /** Mutable callbacks and stores consumed by the Studio bridge. */
+    internal: WeaverseNextRuntimeInternal;
+    /** Path, query, and locale metadata for Studio navigation. */
+    requestInfo: WeaverseNextRequestInfo;
+    /** Whether this runtime renders a component preview. */
+    isPreviewMode: boolean;
+    /** Whether this runtime renders a saved revision. */
+    isRevisionPreview: boolean;
+    /** Component type rendered in section preview mode. */
+    sectionType?: string;
+    /**
+     * 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: WeaverseNextTranslationMap;
+    /** 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?: WeaverseNextRenderablePage;
+    /**
+     * 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: WeaverseNextItem[];
+    /** Create a browser runtime from a loaded page and its request context. */
+    constructor(config: WeaverseNextRuntimeConfig);
+    /**
+     * 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: () => void;
+    /**
+     * 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?: WeaverseNextTranslationMap, locale?: string, languageId?: string) => void;
+    /**
+     * 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: string, key: string, originalValue: string, translatedValue: string) => void;
+    /**
+     * 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: () => WeaverseNextTranslationChanges | undefined;
+    /**
+     * 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: WeaverseNextRenderablePage) => void;
+    /**
+     * 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: () => void;
+}
+/**
+ * Create a browser runtime or reuse the runtime already registered for the
+ * same page and request. Reuse preserves unsaved Studio state in design mode.
+ */
+export declare function createWeaverseNextRuntime(config: WeaverseNextRuntimeConfig): WeaverseNextRuntime;
+/**
+ * Bind a design-mode runtime to the global Builder Studio bridge.
+ *
+ * @returns `true` when Studio was initialized or refreshed, otherwise `false`.
+ */
+export declare function bindWeaverseNextStudioRuntime(runtime: WeaverseNextRuntime): boolean;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/types/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC1C,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,QAAQ,CAAA;AAIf,OAAO,KAAK,EAGV,oBAAoB,EACpB,uBAAuB,EACvB,yBAAyB,EACzB,2BAA2B,EAC3B,8BAA8B,EAE9B,0BAA0B,EAC3B,MAAM,SAAS,CAAA;AAEhB,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,UAAU,CAAC,EAAE,mBAAmB,CAAA;QAChC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;KAClD;CACF;AAkHD,yEAAyE;AACzE,MAAM,WAAW,0BAA2B,SAAQ,oBAAoB;IACtE,oEAAoE;IACpE,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;GAGG;AACH,qBAAa,mBAAoB,SAAQ,QAAQ;IAC/C,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAA;IACd,kEAAkE;IAClE,QAAQ,EAAE,2BAA2B,CAAA;IACrC,8DAA8D;IAC9D,WAAW,EAAE,uBAAuB,CAAA;IACpC,wDAAwD;IACxD,aAAa,EAAE,OAAO,CAAA;IACtB,qDAAqD;IACrD,iBAAiB,EAAE,OAAO,CAAA;IAC1B,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAA;IAGpB;;;;OAIG;IACH,cAAc,EAAE,0BAA0B,CAAK;IAC/C,iEAAiE;IACjE,iBAAiB,SAAW;IAC5B,iEAAiE;IACjE,qBAAqB,SAAW;IAEhC;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,0BAA0B,CAAA;IAE/C;;;;;OAKG;IACH,kBAAkB,EAAE,gBAAgB,EAAE,CAAK;IAE3C,2EAA2E;gBAC/D,MAAM,EAAE,yBAAyB;IAmD7C;;;;;;OAMG;IACH,yBAAyB,aAexB;IAED;;;;OAIG;IACH,qBAAqB,GACnB,MAAK,0BAA+B,EACpC,eAAW,EACX,mBAAe,UAMhB;IAED;;;;OAIG;IACH,iBAAiB,GACf,QAAQ,MAAM,EACd,KAAK,MAAM,EACX,eAAe,MAAM,EACrB,iBAAiB,MAAM,UAcxB;IAED;;;;OAIG;IACH,qBAAqB,QAAO,8BAA8B,GAAG,SAAS,CAsBrE;IAED;;;;;OAKG;IACH,cAAc,GAAI,MAAM,0BAA0B,UAIjD;IAED;;;;;;OAMG;IACH,uBAAuB,aActB;CACF;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,yBAAyB,GAChC,mBAAmB,CA2FrB;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,mBAAmB,WAwCzE"}

package/dist/types/seo.d.ts

@@ -0,0 +1,55 @@
+import type { PageSEOData } from '@weaverse/schema';
+import type { Metadata } from 'next';
+import type { WeaverseNextLoaderData, WeaverseNextPageData } from './types';
+/** Object containing an optional Weaverse page for SEO extraction. */
+export interface WeaverseNextSeoPageContainer {
+    /** Page whose published SEO fields should be formatted. */
+    page?: WeaverseNextPageData | null;
+}
+/** Input accepted by {@link getWeaverseNextSeoMetadata}. */
+export type WeaverseNextSeoInput = WeaverseNextLoaderData | WeaverseNextPageData | WeaverseNextSeoPageContainer | null | undefined;
+/** Open Graph metadata accepted by Next.js's `Metadata` API. */
+export type NextOpenGraph = NonNullable<Metadata['openGraph']>;
+/** Twitter card metadata accepted by Next.js's `Metadata` API. */
+export type NextTwitter = NonNullable<Metadata['twitter']>;
+/**
+ * Weaverse page SEO expressed as a subset of Next's `Metadata`. Assignable to
+ * `Metadata` as-is: `const metadata: Metadata = getWeaverseNextSeoMetadata(data)`.
+ */
+export interface WeaverseNextSeoMetadata {
+    /** Canonical URL settings for Next's metadata API. */
+    alternates?: {
+        /** Preferred URL for search indexing. */
+        canonical?: string;
+    };
+    /** Page meta description. */
+    description?: string;
+    /** Page meta keywords. */
+    keywords?: string;
+    /** Open Graph metadata normalized to Next's supported union. */
+    openGraph?: NextOpenGraph;
+    /** Search crawler indexing and link-following directives. */
+    robots: {
+        /** Whether crawlers may follow links on the page. */
+        follow: boolean;
+        /** Whether crawlers may index the page. */
+        index: boolean;
+    };
+    /** Page title. */
+    title?: string;
+    /** Twitter card metadata normalized for Next's metadata API. */
+    twitter?: NextTwitter;
+}
+/**
+ * Convert Builder SEO fields into metadata accepted by Next.js.
+ *
+ * Unsupported Open Graph product types and incomplete Twitter app/player
+ * cards are safely downgraded to renderable Next.js variants.
+ */
+export declare function formatWeaverseNextSeoMetadata(seo: PageSEOData | null | undefined): WeaverseNextSeoMetadata;
+/**
+ * Read page SEO from loader data or a page payload and format it for Next.js
+ * `generateMetadata`. Missing data returns indexable/followable robot defaults.
+ */
+export declare function getWeaverseNextSeoMetadata(data: WeaverseNextSeoInput): WeaverseNextSeoMetadata;
+//# sourceMappingURL=seo.d.ts.map

package/dist/types/seo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seo.d.ts","sourceRoot":"","sources":["../../src/seo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAA;AACpC,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAE3E,sEAAsE;AACtE,MAAM,WAAW,4BAA4B;IAC3C,2DAA2D;IAC3D,IAAI,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAA;CACnC;AAED,4DAA4D;AAC5D,MAAM,MAAM,oBAAoB,GAC5B,sBAAsB,GACtB,oBAAoB,GACpB,4BAA4B,GAC5B,IAAI,GACJ,SAAS,CAAA;AAEb,gEAAgE;AAChE,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAA;AAE9D,kEAAkE;AAClE,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAA;AAE1D;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,sDAAsD;IACtD,UAAU,CAAC,EAAE;QACX,yCAAyC;QACzC,SAAS,CAAC,EAAE,MAAM,CAAA;KACnB,CAAA;IACD,6BAA6B;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gEAAgE;IAChE,SAAS,CAAC,EAAE,aAAa,CAAA;IACzB,6DAA6D;IAC7D,MAAM,EAAE;QACN,qDAAqD;QACrD,MAAM,EAAE,OAAO,CAAA;QACf,2CAA2C;QAC3C,KAAK,EAAE,OAAO,CAAA;KACf,CAAA;IACD,kBAAkB;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,gEAAgE;IAChE,OAAO,CAAC,EAAE,WAAW,CAAA;CACtB;AA+BD;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAClC,uBAAuB,CAiDzB;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,oBAAoB,GACzB,uBAAuB,CASzB"}

package/dist/types/server/configs.d.ts

@@ -0,0 +1,27 @@
+import type { WeaverseNextBaseConfigs, WeaverseNextRequestContext } from '../types';
+/**
+ * Extract the request search params from the explicit Next request context.
+ * Prefers `searchParams`, falls back to parsing `url`.
+ */
+export declare function getContextSearchParams(context?: WeaverseNextRequestContext): URLSearchParams;
+/** Overrides used while resolving request-scoped Weaverse configuration. */
+export interface ResolveConfigsOptions {
+    /** Environment values; missing keys fall back to `process.env`. */
+    env?: Record<string, string | undefined>;
+    /** Public data API base override. */
+    weaverseApiBase?: string;
+    /** Studio origin override. */
+    weaverseHost?: string;
+    /** Studio asset version override. */
+    weaverseVersion?: string;
+}
+/**
+ * Derive Weaverse configs from the request context and env, close to Hydrogen's
+ * `getWeaverseConfigs`. Resolves the trusted host, public API base, design /
+ * preview / revision flags, and public env — but never resolves the final
+ * `projectId` (that priority chain, which may call an async resolver, lives in
+ * the server client). Query/env projectId candidates are returned for the
+ * client to combine with function/string inputs.
+ */
+export declare function getWeaverseNextConfigs(context?: WeaverseNextRequestContext, options?: ResolveConfigsOptions): WeaverseNextBaseConfigs;
+//# sourceMappingURL=configs.d.ts.map

package/dist/types/server/configs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../../../src/server/configs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,0BAA0B,EAC3B,MAAM,UAAU,CAAA;AA6CjB;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,CAAC,EAAE,0BAA0B,GACnC,eAAe,CAWjB;AAkCD,4EAA4E;AAC5E,MAAM,WAAW,qBAAqB;IACpC,mEAAmE;IACnE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;IACxC,qCAAqC;IACrC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,8BAA8B;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,qCAAqC;IACrC,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,CAAC,EAAE,0BAA0B,EACpC,OAAO,GAAE,qBAA0B,GAClC,uBAAuB,CA2DzB"}

package/dist/types/server/normalize-page-url.d.ts

@@ -0,0 +1,19 @@
+import type { WeaverseNextRequestContext } from '../types';
+/**
+ * Normalize the storefront URL sent in the Builder page API request body.
+ *
+ * The Builder reads only the pathname (locale/type/handle fallback) and the
+ * Weaverse/Studio control params from this URL, so keep exactly those and drop
+ * tracking params. Params are sorted for a stable, cache-friendly string.
+ *
+ * Ported from `@weaverse/hydrogen`'s `normalizePageUrl`, but tolerant of a
+ * relative URL (Next route handlers may only know the pathname).
+ */
+export declare function normalizeNextPageUrl(url: string): string;
+/**
+ * Build an absolute-ish request URL string from the explicit request context,
+ * preferring `url`, then `pathname` + `searchParams`. Used as the input to
+ * {@link normalizeNextPageUrl}.
+ */
+export declare function resolveRequestUrl(context?: WeaverseNextRequestContext): string;
+//# sourceMappingURL=normalize-page-url.d.ts.map

package/dist/types/server/normalize-page-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-page-url.d.ts","sourceRoot":"","sources":["../../../src/server/normalize-page-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAA;AAa1D;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAqBxD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,CAAC,EAAE,0BAA0B,GACnC,MAAM,CAWR"}

package/dist/types/server/revalidate-handler.d.ts

@@ -0,0 +1,55 @@
+import { type WeaverseNextRevalidateRouteContext } from '../revalidate-item';
+import type { WeaverseNextComponentData, WeaverseNextRequestContext, WeaverseNextServerClient } from '../types';
+/** Configuration for the App Router item-revalidation handler. */
+export interface WeaverseNextRevalidateHandlerConfig {
+    /**
+     * Reuse the app's server-client factory so the loader runs with the same
+     * component registry and commerce (storefront) context as page loads.
+     *
+     * The optional second argument is the validated, same-origin route context
+     * reconstructed from the request body. It is `undefined` for legacy bodies
+     * that carry no `routeContext`, so a one-argument `(request) => client`
+     * callback remains valid. Consumers must still source project ID, Studio
+     * host, API bases/keys, and env from server config — never from this
+     * browser-provided context.
+     */
+    getClient: (request: Request, requestContext?: WeaverseNextRequestContext) => Promise<WeaverseNextServerClient> | WeaverseNextServerClient;
+}
+/** POST body accepted by the revalidate route. */
+export interface WeaverseNextRevalidateRequestBody {
+    /** Unsaved Studio item settings to pass to the registered component loader. */
+    draftItem: WeaverseNextComponentData;
+    /** Public route identity used to reconstruct the loader request context. */
+    routeContext?: WeaverseNextRevalidateRouteContext;
+}
+/** App Router handler returned for Studio item revalidation requests. */
+export interface WeaverseNextRevalidateHandler {
+    /** Handle a Studio request to rerun one registered component loader. */
+    POST: (request: Request) => Promise<Response>;
+}
+/**
+ * Create the Studio per-item revalidation route handler.
+ *
+ * Studio design-mode edits to loader-backed inputs (e.g. resource pickers) need
+ * fresh server loader data for a single item. Re-running it through
+ * `router.refresh()` re-applies the whole RSC tree — and the draft-item query
+ * rewrite changes the App Router page segment key, remounting the page and
+ * resetting scroll. This handler runs just the edited component's `loader`
+ * with the unsaved draft settings and returns the payload for an in-place
+ * client update (see the `2026-07-02--next-item-revalidation` spec).
+ *
+ * Security: only registered component types are executable, the handler never
+ * persists anything, and responses are `no-store`. Exposure is equivalent to
+ * the existing `weaverseDraftItem` URL param, which already lets any visitor
+ * run design-mode loaders with arbitrary draft settings.
+ *
+ * @example
+ * ```ts
+ * // app/api/weaverse/revalidate/route.ts
+ * export const { POST } = createWeaverseNextRevalidateHandler({
+ *   getClient: () => getWeaverseServerClient(Promise.resolve({})),
+ * })
+ * ```
+ */
+export declare function createWeaverseNextRevalidateHandler(config: WeaverseNextRevalidateHandlerConfig): WeaverseNextRevalidateHandler;
+//# sourceMappingURL=revalidate-handler.d.ts.map

package/dist/types/server/revalidate-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revalidate-handler.d.ts","sourceRoot":"","sources":["../../../src/server/revalidate-handler.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,kCAAkC,EACxC,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EACV,yBAAyB,EAEzB,0BAA0B,EAC1B,wBAAwB,EACzB,MAAM,UAAU,CAAA;AAsBjB,kEAAkE;AAClE,MAAM,WAAW,mCAAmC;IAClD;;;;;;;;;;OAUG;IACH,SAAS,EAAE,CACT,OAAO,EAAE,OAAO,EAChB,cAAc,CAAC,EAAE,0BAA0B,KACxC,OAAO,CAAC,wBAAwB,CAAC,GAAG,wBAAwB,CAAA;CAClE;AAED,kDAAkD;AAClD,MAAM,WAAW,iCAAiC;IAChD,+EAA+E;IAC/E,SAAS,EAAE,yBAAyB,CAAA;IACpC,4EAA4E;IAC5E,YAAY,CAAC,EAAE,kCAAkC,CAAA;CAClD;AAoMD,yEAAyE;AACzE,MAAM,WAAW,6BAA6B;IAC5C,wEAAwE;IACxE,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,mCAAmC,GAC1C,6BAA6B,CAqE/B"}

package/dist/types/server/server-client.d.ts

@@ -0,0 +1,21 @@
+import type { WeaverseNextServerClient, WeaverseNextServerClientConfig } from '../types';
+/**
+ * Create a server-side {@link WeaverseNextServerClient} for Next.js App Router
+ * routes / server components.
+ *
+ * @example
+ * ```ts
+ * let weaverse = createWeaverseNextServerClient({
+ *   projectId: process.env.WEAVERSE_PROJECT_ID,
+ *   components,
+ *   commerce: { storefront },
+ *   requestContext: { url, headers, searchParams, i18n },
+ *   cache: { revalidate: 60, tags: ['weaverse'] },
+ * })
+ * let data = await weaverse.loadPage({ type: 'INDEX' })
+ * let theme = await weaverse.loadThemeSettings()
+ * ```
+ */
+export declare function createWeaverseNextServerClient(config: WeaverseNextServerClientConfig): WeaverseNextServerClient;
+export { getContextSearchParams } from './configs';
+//# sourceMappingURL=server-client.d.ts.map

package/dist/types/server/server-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-client.d.ts","sourceRoot":"","sources":["../../../src/server/server-client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAgBV,wBAAwB,EACxB,8BAA8B,EAM/B,MAAM,UAAU,CAAA;AAsqBjB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,8BAA8B,GACrC,wBAAwB,CAE1B;AAED,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA"}

package/dist/types/server.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Server-only Weaverse APIs for Next.js App Router server components and route
+ * handlers.
+ *
+ * When migrating from Hydrogen's `context.weaverse`, create a request-scoped
+ * client with {@link createWeaverseNextServerClient}, then call `loadPage()` or
+ * `loadThemeSettings()`. Keep rendering providers and components imported from
+ * the root `@weaverse/next` entrypoint.
+ *
+ * @packageDocumentation
+ */
+export type { WeaverseNextRevalidateRouteContext } from './revalidate-item';
+export { formatWeaverseNextSeoMetadata, getWeaverseNextSeoMetadata, type NextOpenGraph, type NextTwitter, type WeaverseNextSeoInput, type WeaverseNextSeoMetadata, type WeaverseNextSeoPageContainer, } from './seo';
+export { getWeaverseNextConfigs, type ResolveConfigsOptions, } from './server/configs';
+export { normalizeNextPageUrl, resolveRequestUrl, } from './server/normalize-page-url';
+export { createWeaverseNextRevalidateHandler, type WeaverseNextRevalidateHandler, type WeaverseNextRevalidateHandlerConfig, type WeaverseNextRevalidateRequestBody, } from './server/revalidate-handler';
+export { createWeaverseNextServerClient } from './server/server-client';
+export type { WeaverseNextBaseConfigs, WeaverseNextCacheConfig, WeaverseNextClient, WeaverseNextCommerceContext, WeaverseNextComponent, WeaverseNextComponentData, WeaverseNextComponentLoaderArgs, WeaverseNextComponentProps, WeaverseNextConfigs, WeaverseNextCustomPageEntry, WeaverseNextFetchCustomPagesOptions, WeaverseNextFetchOptions, WeaverseNextI18n, WeaverseNextLoaderData, WeaverseNextLoadPageInput, WeaverseNextPageAssignment, WeaverseNextPageData, WeaverseNextProjectId, WeaverseNextRequestContext, WeaverseNextServerClient, WeaverseNextServerClientConfig, WeaverseNextServerLoadPageInput, WeaverseNextStorefront, WeaverseNextThemeSchema, WeaverseNextThemeSchemaGroup, WeaverseNextThemeSchemaInput, WeaverseNextThemeSettingsOptions, WeaverseNextThemeSettingsResponse, } from './types';
+//# sourceMappingURL=server.d.ts.map

package/dist/types/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,YAAY,EAAE,kCAAkC,EAAE,MAAM,mBAAmB,CAAA;AAC3E,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC1B,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,GAClC,MAAM,OAAO,CAAA;AACd,OAAO,EACL,sBAAsB,EACtB,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EACL,mCAAmC,EACnC,KAAK,6BAA6B,EAClC,KAAK,mCAAmC,EACxC,KAAK,iCAAiC,GACvC,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAA;AACvE,YAAY,EACV,uBAAuB,EACvB,uBAAuB,EACvB,kBAAkB,EAClB,2BAA2B,EAC3B,qBAAqB,EACrB,yBAAyB,EACzB,+BAA+B,EAC/B,0BAA0B,EAC1B,mBAAmB,EACnB,2BAA2B,EAC3B,mCAAmC,EACnC,wBAAwB,EACxB,gBAAgB,EAChB,sBAAsB,EACtB,yBAAyB,EACzB,0BAA0B,EAC1B,oBAAoB,EACpB,qBAAqB,EACrB,0BAA0B,EAC1B,wBAAwB,EACxB,8BAA8B,EAC9B,+BAA+B,EAC/B,sBAAsB,EACtB,uBAAuB,EACvB,4BAA4B,EAC5B,4BAA4B,EAC5B,gCAAgC,EAChC,iCAAiC,GAClC,MAAM,SAAS,CAAA"}

package/dist/types/studio-bridge.d.ts

@@ -0,0 +1,16 @@
+import { type WeaverseNextRuntime } from './runtime';
+import type { WeaverseNextRuntimeInternal } from './types';
+/** Runtime and host callbacks attached to the Builder Studio bridge. */
+export interface WeaverseNextStudioBridgeProps {
+    /** Preview navigation callback. */
+    navigate?: WeaverseNextRuntimeInternal['navigate'];
+    /** Whole-route refresh callback used as a legacy fallback. */
+    revalidate?: WeaverseNextRuntimeInternal['revalidate'];
+    /** Preferred per-item loader revalidation callback. */
+    revalidateItem?: WeaverseNextRuntimeInternal['revalidateItem'];
+    /** Browser runtime to initialize or refresh in Studio. */
+    runtime: WeaverseNextRuntime;
+}
+/** Page-level Studio runtime binder. */
+export declare function WeaverseNextStudioBridge(props: WeaverseNextStudioBridgeProps): null;
+//# sourceMappingURL=studio-bridge.d.ts.map

package/dist/types/studio-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"studio-bridge.d.ts","sourceRoot":"","sources":["../../src/studio-bridge.tsx"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,WAAW,CAAA;AAClB,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAA;AAK1D,wEAAwE;AACxE,MAAM,WAAW,6BAA6B;IAC5C,mCAAmC;IACnC,QAAQ,CAAC,EAAE,2BAA2B,CAAC,UAAU,CAAC,CAAA;IAClD,8DAA8D;IAC9D,UAAU,CAAC,EAAE,2BAA2B,CAAC,YAAY,CAAC,CAAA;IACtD,uDAAuD;IACvD,cAAc,CAAC,EAAE,2BAA2B,CAAC,gBAAgB,CAAC,CAAA;IAC9D,0DAA0D;IAC1D,OAAO,EAAE,mBAAmB,CAAA;CAC7B;AAED,wCAAwC;AACxC,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,6BAA6B,QAwD5E"}

package/dist/types/studio-connect.d.ts

@@ -0,0 +1,27 @@
+import type { WeaverseNextRequestContext } from './types';
+/** Trust context used while loading the Studio bridge script. */
+export interface LoadWeaverseNextStudioScriptOptions {
+    /** Storefront hostname; required to permit loopback Studio origins. */
+    storefrontHostname?: string;
+}
+/**
+ * Resolve and append the Next Studio bridge script for the given request
+ * context, deduping by src. SSR-safe (no-op without `document`) so it can run
+ * unconditionally from a root layout/error boundary before any page tree or
+ * runtime exists — e.g. App Router `not-found.tsx` / `error.tsx` routes.
+ */
+export declare function loadWeaverseNextStudioScript(context?: WeaverseNextRequestContext, options?: LoadWeaverseNextStudioScriptOptions): void;
+/** Props for the root-level Studio script connector. */
+export interface WeaverseNextStudioConnectProps {
+    /** Explicit request context used to resolve Studio mode and host. */
+    context?: WeaverseNextRequestContext;
+    /** Storefront hostname; required to permit loopback Studio origins. */
+    storefrontHostname?: string;
+}
+/**
+ * Root-level Studio script connector for Next client boundaries. Mount once
+ * near the app root (e.g. root layout) so it also covers routes that never
+ * render `WeaverseNextRenderer`, such as `not-found.tsx` / `error.tsx`.
+ */
+export declare function WeaverseNextStudioConnect(props: WeaverseNextStudioConnectProps): null;
+//# sourceMappingURL=studio-connect.d.ts.map

package/dist/types/studio-connect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"studio-connect.d.ts","sourceRoot":"","sources":["../../src/studio-connect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAA;AA0BzD,iEAAiE;AACjE,MAAM,WAAW,mCAAmC;IAClD,uEAAuE;IACvE,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,CAAC,EAAE,0BAA0B,EACpC,OAAO,GAAE,mCAAwC,QAkBlD;AAED,wDAAwD;AACxD,MAAM,WAAW,8BAA8B;IAC7C,qEAAqE;IACrE,OAAO,CAAC,EAAE,0BAA0B,CAAA;IACpC,uEAAuE;IACvE,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,8BAA8B,QAStC"}