@weaverse/next 0.1.0-alpha.8 → 1.0.0

package/dist/types/hooks.d.ts

@@ -0,0 +1,20 @@
+import type { WeaverseNextCommerceContext } from './types';
+/**
+ * Read explicit root/global data passed to the provider. Next-native
+ * replacement for `useRouteLoaderData('root')`.
+ */
+export declare function useWeaverseRootData<T = unknown>(): T;
+/**
+ * Read explicit page/route commerce data passed to the provider. Next-native
+ * replacement for section-level `useLoaderData()`.
+ */
+export declare function useWeaversePageData<T = unknown>(): T;
+/** Read the app-provided commerce context (storefront/cart/customer). */
+export declare function useWeaverseCommerce<T = WeaverseNextCommerceContext>(): T;
+/**
+ * Read live Weaverse theme settings. The Studio bridge updates the provider's
+ * external store via `updateThemeSettings`, so components re-render during live
+ * design-mode edits.
+ */
+export declare function useThemeSettings<T = Record<string, unknown>>(): T;
+//# sourceMappingURL=hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/hooks.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAA;AAY1D;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,GAAG,OAAO,KAAK,CAAC,CAEpD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,GAAG,OAAO,KAAK,CAAC,CAEpD;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,CAAC,GAAG,2BAA2B,KAAK,CAAC,CAExE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,CAOjE"}

package/dist/types/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Next.js App Router rendering, provider, Studio, translation, and schema APIs.
+ *
+ * When migrating from `@weaverse/hydrogen`, replace route-loader context with
+ * {@link WeaverseNextProvider} props and render page data with
+ * {@link WeaverseNextRenderer}. Import server-only fetching and route-handler
+ * helpers from `@weaverse/next/server`.
+ *
+ * @packageDocumentation
+ */
+export { isBrowser, isIframe, useChildInstances, useItemInstance, useParentInstance, useWeaverse, } from '@weaverse/react';
+export * from '@weaverse/schema';
+export { createWeaverseNextClient } from './client';
+export { useThemeSettings, useWeaverseCommerce, useWeaversePageData, useWeaverseRootData, } from './hooks';
+export type { WeaverseNextItem } from './item';
+export { type RunComponentLoadersArgs, runWeaverseComponentLoaders, } from './loader';
+export { WeaverseNextProvider, type WeaverseNextProviderProps, } from './provider';
+export { WeaverseNextRenderer, type WeaverseNextRendererProps, } from './renderer';
+export { buildWeaverseNextRequestInfo } from './request-info';
+export { buildWeaverseNextRevalidateRouteContext, DEFAULT_REVALIDATE_ENDPOINT, type RevalidateItemRuntimeLike, revalidateWeaverseNextItem, type WeaverseNextRevalidateRouteContext, } from './revalidate-item';
+export { type WeaverseNextRootContextValue, WeaverseNextRootProvider, type WeaverseNextRootProviderProps, } from './root-provider';
+export { bindWeaverseNextStudioRuntime, createWeaverseNextRuntime, type WeaverseNextRenderablePage, WeaverseNextRuntime, } from './runtime';
+export { formatWeaverseNextSeoMetadata, getWeaverseNextSeoMetadata, type NextOpenGraph, type NextTwitter, type WeaverseNextSeoInput, type WeaverseNextSeoMetadata, type WeaverseNextSeoPageContainer, } from './seo';
+export { WeaverseNextStudioBridge, type WeaverseNextStudioBridgeProps, } from './studio-bridge';
+export { type LoadWeaverseNextStudioScriptOptions, loadWeaverseNextStudioScript, WeaverseNextStudioConnect, type WeaverseNextStudioConnectProps, } from './studio-connect';
+export { type CreateWeaverseNextStudioInternalsOptions, createWeaverseNextStudioInternals, type WeaverseNextRouterLike, type WeaverseNextStudioInternals, } from './studio-router';
+export { type ResolveWeaverseNextStudioScriptSrcOptions, resolveWeaverseNextStudioScriptSrc, } from './studio-script-src';
+export { type CreateWeaverseNextThemeSettingsStoreOptions, createWeaverseNextThemeSettingsStore, } from './theme-settings-store';
+export { type CreateTranslateSources, createTranslate, getNestedKey, interpolate, ThemeTextProvider, type ThemeTextProviderProps, type ThemeTextValue, type TranslateFunction, TranslationProvider, type TranslationProviderProps, type TranslationValue, useThemeText, useTranslation, } from './translation-context';
+export { ThemeTextStore, TranslationStore } from './translation-store';
+export type { WeaverseArticle, WeaverseBlog, WeaverseCollection, WeaverseMetaObject, WeaverseNextCacheConfig, WeaverseNextClient, WeaverseNextClientConfig, WeaverseNextCommerceContext, WeaverseNextComponent, WeaverseNextComponentData, WeaverseNextComponentLoaderArgs, WeaverseNextComponentProps, WeaverseNextCustomPageEntry, WeaverseNextFetchCustomPagesOptions, WeaverseNextI18n, WeaverseNextLoaderData, WeaverseNextLoadPageInput, WeaverseNextPageAssignment, WeaverseNextPageData, WeaverseNextRequestContext, WeaverseNextRequestInfo, WeaverseNextRuntimeConfig, WeaverseNextRuntimeInternal, WeaverseNextStorefront, WeaverseNextThemeSchema, WeaverseNextThemeSchemaGroup, WeaverseNextThemeSchemaInput, WeaverseNextThemeSettingsStore, WeaverseNextTranslationChanges, WeaverseNextTranslationEntry, WeaverseNextTranslationItemEntry, WeaverseNextTranslationMap, WeaverseNextTranslationMapEntry, WeaverseProduct, } from './types';
+export { useWeaverseNextStudioInternals, WeaverseNextStudio, type WeaverseNextStudioProps, } from './use-weaverse-next-studio';
+export { generateDataFromSchema } from './utils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/types/item.d.ts

@@ -0,0 +1,60 @@
+import type { ElementData } from '@weaverse/react';
+import { Weaverse, WeaverseItemStore } from '@weaverse/react';
+import type { WeaverseNextRuntime } from './runtime';
+import type { WeaverseNextComponentData } from './types';
+/**
+ * Run `create` with item update emissions deferred, returning its result and
+ * the items whose `setData()` fired meanwhile. The caller is responsible for
+ * calling `triggerUpdate()` on them once React has committed.
+ */
+export declare function collectDeferredItemUpdates<T>(create: () => T): [T, WeaverseNextItem[]];
+/**
+ * Item store that flattens the serialized item's nested `data` field onto the
+ * store and seeds schema defaults — same shape Hydrogen produces, so the
+ * shared `@weaverse/react` renderer can spread props at the top level.
+ */
+export declare class WeaverseNextItem extends WeaverseItemStore {
+    /** Browser runtime that owns this item store. */
+    weaverse: WeaverseNextRuntime;
+    /**
+     * 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.
+     */
+    private _cachedSnapshot;
+    private _snapshotStoreRef;
+    private _snapshotTranslationRef;
+    /** Create an item store from serialized component data and its runtime. */
+    constructor(initialData: WeaverseNextComponentData, weaverse: Weaverse);
+    /**
+     * 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: Omit<ElementData, "id" | "type">) => ElementData;
+    /**
+     * 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: () => ElementData;
+}
+/**
+ * Register the Next item constructor globally. Idempotent: calling it more than
+ * once is safe. Invoked by the renderer before it builds a Weaverse instance.
+ */
+export declare function ensureNextItemConstructor(): void;
+//# sourceMappingURL=item.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../src/item.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AACpD,OAAO,KAAK,EACV,yBAAyB,EAE1B,MAAM,SAAS,CAAA;AA6BhB;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,MAAM,EAAE,MAAM,CAAC,GACd,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,CASzB;AAED;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,iBAAiB;IACrD,iDAAiD;IACzC,QAAQ,EAAE,mBAAmB,CAAA;IAErC;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAA2B;IAClD,OAAO,CAAC,iBAAiB,CAA2B;IACpD,OAAO,CAAC,uBAAuB,CACzB;IAEN,2EAA2E;gBAC/D,WAAW,EAAE,yBAAyB,EAAE,QAAQ,EAAE,QAAQ;IAMtE;;;;;;;;;;;;;;;OAeG;IACH,OAAO,GAAI,QAAQ,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,MAAM,CAAC,iBAkBlD;IAED;;;;;;OAMG;IACH,WAAW,QAAO,WAAW,CA6B5B;CACF;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,SAQxC"}

package/dist/types/loader.d.ts

@@ -0,0 +1,25 @@
+import type { WeaverseNextClient, WeaverseNextCommerceContext, WeaverseNextLoaderData, WeaverseNextRequestContext } from './types';
+/** Inputs for running registered component loaders over a page tree. */
+export interface RunComponentLoadersArgs {
+    /** Weaverse client containing the component registry. */
+    client: WeaverseNextClient;
+    /** Request-scoped commerce override; defaults to `client.commerce`. */
+    commerce?: WeaverseNextCommerceContext;
+    /** Request-context override; defaults to `client.requestContext`. */
+    context?: WeaverseNextRequestContext;
+    /** Page payload to walk; defaults to `client.data`. */
+    data?: WeaverseNextLoaderData | null;
+}
+/**
+ * Walk a serialized page tree and run each registered component's `loader`,
+ * attaching the result to the item as `loaderData`.
+ *
+ * Loaders receive explicit `commerce.storefront` (and `weaverse.storefront` as
+ * a compatibility alias via the client). Children are walked recursively when
+ * they are inline item objects; flat `items` arrays are covered by the
+ * top-level walk.
+ *
+ * @returns a cloned `data` object with `loaderData` attached to cloned items.
+ */
+export declare function runWeaverseComponentLoaders(args: RunComponentLoadersArgs): Promise<WeaverseNextLoaderData | null>;
+//# sourceMappingURL=loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,2BAA2B,EAG3B,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,SAAS,CAAA;AAGhB,wEAAwE;AACxE,MAAM,WAAW,uBAAuB;IACtC,yDAAyD;IACzD,MAAM,EAAE,kBAAkB,CAAA;IAC1B,uEAAuE;IACvE,QAAQ,CAAC,EAAE,2BAA2B,CAAA;IACtC,qEAAqE;IACrE,OAAO,CAAC,EAAE,0BAA0B,CAAA;IACpC,uDAAuD;IACvD,IAAI,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAA;CACrC;AAqBD;;;;;;;;;;GAUG;AACH,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAgFxC"}

package/dist/types/main.d.ts

@@ -0,0 +1,11 @@
+import { type SchemaType } from '@weaverse/schema';
+import type { WeaverseNextComponent } from './types';
+/** Schema for the default {@link Main} root component. Type is exactly `main`. */
+export declare const mainSchema: SchemaType;
+/**
+ * Default `main` component module, registered ahead of user components by
+ * {@link registerWeaverseNextComponents}. Kept package-internal — consumers
+ * override it simply by registering their own component with `type: 'main'`.
+ */
+export declare const defaultMainComponent: WeaverseNextComponent;
+//# sourceMappingURL=main.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAEhE,OAAO,KAAK,EAAE,qBAAqB,EAA8B,MAAM,SAAS,CAAA;AA4BhF,kFAAkF;AAClF,eAAO,MAAM,UAAU,EAAE,UAGvB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,qBAGlC,CAAA"}

package/dist/types/provider.d.ts

@@ -0,0 +1,82 @@
+import { type ReactNode } from 'react';
+import { type TranslateFunction } from './translation-context';
+import { TranslationStore } from './translation-store';
+import type { WeaverseNextClient, WeaverseNextCommerceContext, WeaverseNextThemeSettingsStore } from './types';
+/** Read `themeSchema.i18n.staticContent` for the fallback (no-root) provider. */
+export declare function getSchemaStaticContent(schema: unknown): Record<string, unknown>;
+/**
+ * Value carried by {@link WeaverseNextContext}. Holds the explicit data
+ * boundaries that replace React Router's `useLoaderData` /
+ * `useRouteLoaderData` inside sections.
+ */
+export interface WeaverseNextContextValue {
+    /** Client used by the renderer and component-loader compatibility hooks. */
+    client?: WeaverseNextClient;
+    /** App-provided commerce context for rendered components. */
+    commerce?: WeaverseNextCommerceContext;
+    /** Active-locale static-text overrides, threaded into the runtime. */
+    merchantOverrides?: Record<string, unknown>;
+    /** Page-scoped data exposed to rendered components. */
+    pageData?: unknown;
+    /** Root-scoped data exposed to rendered components. */
+    rootData?: unknown;
+    /** Current merged theme-setting values. */
+    themeSettings: Record<string, unknown>;
+    /** External store that publishes live theme-setting updates. */
+    themeSettingsStore: WeaverseNextThemeSettingsStore;
+    /** Live design-mode static-text override store, threaded into the runtime. */
+    translationStore: TranslationStore;
+}
+/**
+ * Null sentinel default lets hooks detect usage outside the provider and throw
+ * a clear error instead of silently returning empty data.
+ */
+export declare const WeaverseNextContext: import("react").Context<WeaverseNextContextValue | null>;
+/** Explicit page, commerce, theme, and translation data for Next components. */
+export interface WeaverseNextProviderProps {
+    /** React subtree that consumes the Weaverse Next contexts. */
+    children: ReactNode;
+    /** Client used by the renderer and component-loader compatibility hooks. */
+    client?: WeaverseNextClient;
+    /** App-provided commerce context (storefront/cart/customer). */
+    commerce?: WeaverseNextCommerceContext;
+    /**
+     * Active-locale static-text overrides (nested, from `loadThemeSettings()`).
+     * Adopts the root provider's `merchantOverrides` when omitted.
+     */
+    merchantOverrides?: Record<string, unknown>;
+    /** Explicit page/route commerce data (replaces section-level `useLoaderData`). */
+    pageData?: unknown;
+    /** Explicit root/global data (replaces `useRouteLoaderData('root')`). */
+    rootData?: unknown;
+    /**
+     * Theme default locale JSON (`loadThemeSettings().staticContent`). Adopts the
+     * root provider's `staticContent` when omitted, then falls back to
+     * `client.themeSchema.i18n.staticContent`.
+     */
+    staticContent?: Record<string, unknown>;
+    /** Optional external translation function (host i18n); highest priority in `t()`. */
+    t?: TranslateFunction;
+    /** Theme settings override; falls back to `client.themeSettings`. */
+    themeSettings?: Record<string, unknown>;
+}
+/**
+ * Client boundary that supplies explicit root/page/commerce data to Weaverse
+ * sections. Next-native replacement for `withWeaverse` + route loader data —
+ * no React Router route matches are emulated.
+ *
+ * In App Router, create/pass `client` only from a client component wrapper. A
+ * `WeaverseNextClient` contains functions and component references, so it is
+ * not serializable across a Server Component → Client Component boundary.
+ *
+ * @example
+ * ```tsx
+ * 'use client'
+ *
+ * <WeaverseNextProvider client={client} rootData={rootData} pageData={pageData} commerce={commerce}>
+ *   <WeaverseNextRenderer />
+ * </WeaverseNextProvider>
+ * ```
+ */
+export declare function WeaverseNextProvider(props: WeaverseNextProviderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=provider.d.ts.map

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,21 @@
+import type { JSX } from 'react/jsx-runtime';
+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) => 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":"AAIA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAA;AAG5C,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,KAC/B,GAAG,CAAC,OAAO,GAAG,IAAI,CA8CnB,CAAA"}

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

@@ -0,0 +1,19 @@
+import type { WeaverseNextRequestContext, WeaverseNextRequestInfo } from './types';
+/**
+ * Put the request's market prefix (`i18n.pathPrefix`, e.g. `/de-de`) on a
+ * pathname that does not carry it yet.
+ *
+ * A Next app builds its request context from the route path, and with
+ * locale-segmented routes that path is usually unprefixed. Studio's address
+ * bar follows `requestInfo.pathname`, so without the prefix it snaps back to
+ * the default market after every navigation. A path that already carries the
+ * prefix, and the default market's empty prefix, pass through unchanged.
+ */
+export declare function withPathPrefix(pathname: string, i18n?: WeaverseNextRequestContext['i18n']): string;
+/**
+ * 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;AAqBhB;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,0BAA0B,CAAC,MAAM,CAAC,GACxC,MAAM,CAcR;AAqDD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,CAAC,EAAE,0BAA0B,GACnC,uBAAuB,CAYzB"}

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

@@ -0,0 +1,82 @@
+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=` must never
+ *   influence server config resolution (see `getWeaverseNextConfigs`), and
+ *   credential-shaped params never ride along in route context.
+ * - 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;;;;;;;;;;GAUG;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,62 @@
+import type { SchemaType } from '@weaverse/schema';
+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?: SchemaType | 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,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,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,UAAU,GAAG,uBAAuB,CAAA;CACnD;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;AAgJD,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;IAuD7C;;;;;;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"}