@weaverse/next 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/seo-CgO21rLg.d.ts

@@ -0,0 +1,517 @@
+import { PageType, InspectorGroup, PageSEOData, SchemaType } from '@weaverse/schema';
+import { WeaverseElement, WeaverseResourcePickerData } from '@weaverse/react';
+import { ReactNode, ComponentType, ForwardRefExoticComponent } from 'react';
+
+/**
+ * Minimal mutable store for design-mode static text overrides.
+ *
+ * `useSyncExternalStore`-compatible. Passed into {@link TranslationProvider}
+ * (from `./translation-context`) which subscribes internally and layers
+ * overrides on top of `merchantOverrides`/`staticContent`. The Studio bridge
+ * calls `updateOverrides()` via `runtime.internal.translationStore` (also
+ * exposed as the deprecated `runtime.internal.themeTextStore` alias) so live
+ * static-text edits reach the runtime — identical surface to Hydrogen's store,
+ * so Builder's existing static-text RPC works with `@weaverse/next` unchanged.
+ *
+ * Shape: flat `Record<string, string>` — dot-notation keys map to values
+ * (e.g. "cart.title" → "Shopping Cart").
+ */
+declare class TranslationStore {
+    overrides: Record<string, string>;
+    private readonly listeners;
+    setOverrides: (overrides: Record<string, string>) => void;
+    updateOverrides: (newOverrides: Record<string, string>) => void;
+    getSnapshot: () => Record<string, string>;
+    getServerSnapshot: () => Record<string, string>;
+    subscribe: (callback: () => void) => () => void;
+    private readonly emit;
+}
+/**
+ * @deprecated Use {@link TranslationStore} instead. Kept as a backward-compatible
+ * alias and will remain exported for existing integrations.
+ */
+declare const ThemeTextStore: typeof TranslationStore;
+/**
+ * @deprecated Use {@link TranslationStore} instead. Kept as a backward-compatible
+ * alias and will remain exported for existing integrations.
+ */
+type ThemeTextStore = TranslationStore;
+
+interface WeaverseNextRequestInfo {
+    i18n?: WeaverseNextI18n;
+    pathname: string;
+    queries: Record<string, string | boolean>;
+    search: string;
+}
+interface WeaverseNextThemeSettingsStore {
+    getServerSnapshot: () => Record<string, unknown>;
+    getSnapshot: () => Record<string, unknown>;
+    publicEnv?: Record<string, string | undefined>;
+    schema?: WeaverseNextThemeSchema;
+    settings: Record<string, unknown>;
+    subscribe: (listener: () => void) => () => void;
+    updateThemeSettings: (next: Record<string, unknown>) => void;
+}
+/**
+ * Page assignment payload returned by `/api/public/project` and preserved on
+ * loader data so the Builder Studio save pipeline receives the same shape it
+ * gets from Hydrogen (`{ projectId, type, locale, handle }`, plus optional
+ * inherited/fallback `meta`). Kept framework-neutral: `type` accepts a known
+ * {@link PageType} or any string, and `meta` preserves inherited/fallback
+ * metadata (unknown fields included) without asserting a strict shape.
+ */
+interface WeaverseNextPageAssignment {
+    handle: string;
+    locale: string;
+    /** Inherited/fallback page metadata; unknown fields preserved as-is. */
+    meta?: {
+        depth?: number;
+        inherited?: boolean;
+        sourceProjectId?: string;
+        [key: string]: unknown;
+    };
+    projectId: string;
+    type: PageType | string;
+}
+interface WeaverseNextRuntimeInternal {
+    /** Active-locale static-text overrides fetched from the API (nested). */
+    merchantOverrides?: Record<string, unknown>;
+    navigate?: (to: string, options?: {
+        preventScrollReset?: boolean;
+    } | Record<string, unknown>) => void;
+    pageAssignment?: WeaverseNextPageAssignment;
+    project?: unknown;
+    revalidate?: (options?: unknown) => Promise<void> | void;
+    /**
+     * Studio per-item loader revalidation. Builder feature-detects this and
+     * prefers it over the legacy `revalidate()` (`router.refresh()`) flow; it
+     * must reject on failure so Builder can fall back.
+     */
+    revalidateItem?: (draftItem: WeaverseNextComponentData) => Promise<void>;
+    themeSettingsStore?: WeaverseNextThemeSettingsStore;
+    /**
+     * @deprecated Use {@link WeaverseNextRuntimeInternal.translationStore}
+     * instead. Same instance, kept so Builder's existing `updateStaticText()`
+     * RPC (which reads `internal.themeTextStore`) works with Next unchanged.
+     */
+    themeTextStore?: TranslationStore;
+    /**
+     * Live design-mode static-text override store. Builder's `updateStaticText()`
+     * RPC mutates it via `updateOverrides()`; the `TranslationProvider` observing
+     * the same instance re-renders `useTranslation()` consumers.
+     */
+    translationStore?: TranslationStore;
+}
+interface WeaverseNextRuntimeConfig {
+    client?: WeaverseNextClient;
+    data: WeaverseNextLoaderData;
+    dataContext?: Record<string, unknown>;
+    /** Active-locale static-text overrides threaded onto `internal`. */
+    merchantOverrides?: Record<string, unknown>;
+    navigate?: WeaverseNextRuntimeInternal['navigate'];
+    revalidate?: WeaverseNextRuntimeInternal['revalidate'];
+    themeSettingsStore?: WeaverseNextThemeSettingsStore;
+    /** Root/route-owned translation store to attach to `internal`. */
+    translationStore?: TranslationStore;
+}
+/** A single translated field for one item. */
+interface WeaverseNextTranslationMapEntry {
+    originalValue: string;
+    translatedValue: string;
+}
+/** Per-item translation fields, keyed by field name. */
+interface WeaverseNextTranslationItemEntry {
+    [key: string]: WeaverseNextTranslationMapEntry;
+}
+/**
+ * Translation map sent from Builder alongside page data in design mode.
+ * Keyed by item ID, each value maps field names to translation entries.
+ */
+interface WeaverseNextTranslationMap {
+    [itemId: string]: WeaverseNextTranslationItemEntry;
+}
+/** A single translation entry for save payloads. */
+interface WeaverseNextTranslationEntry {
+    deleted?: boolean;
+    itemId: string;
+    key: string;
+    originalValue: string;
+    translatedValue: string;
+}
+/** Result of collecting translation changes for the save flow. */
+interface WeaverseNextTranslationChanges {
+    entries: WeaverseNextTranslationEntry[];
+    languageId: string;
+}
+/**
+ * Locale/market info passed through to component loaders and the Storefront
+ * client. Kept structurally close to Hydrogen's `WeaverseI18n` but without the
+ * `@shopify/hydrogen` `I18nBase` dependency so the adapter stays framework
+ * neutral.
+ */
+interface WeaverseNextI18n {
+    country?: string;
+    label?: string;
+    language?: string;
+    locale?: string;
+    pathPrefix?: string;
+    [key: string]: unknown;
+}
+/**
+ * Theme schema shape accepted by the Next adapter. Mirrors Hydrogen's
+ * `HydrogenThemeSchema` but keeps locale data framework-neutral via
+ * {@link WeaverseNextI18n} instead of Shopify Hydrogen's `I18nBase`.
+ */
+interface WeaverseNextThemeSchemaInput {
+    condition?: unknown;
+    defaultValue?: unknown;
+    name?: string;
+    [key: string]: unknown;
+}
+interface WeaverseNextThemeSchemaGroup {
+    group?: string;
+    inputs?: WeaverseNextThemeSchemaInput[];
+    [key: string]: unknown;
+}
+interface WeaverseNextThemeSchema {
+    i18n?: {
+        defaultLocale?: WeaverseNextI18n;
+        shopLocales?: WeaverseNextI18n[];
+        staticContent?: Record<string, unknown>;
+        /** Enable the translation UI in Builder. */
+        translation?: boolean;
+        urlStructure?: 'url-path' | 'subdomain' | 'top-level-domain';
+        [key: string]: unknown;
+    };
+    info?: {
+        author?: string;
+        authorProfilePhoto?: string;
+        documentationUrl?: string;
+        name?: string;
+        supportUrl?: string;
+        version?: string;
+        [key: string]: unknown;
+    };
+    /** @deprecated Use settings instead. */
+    inspector?: (InspectorGroup | WeaverseNextThemeSchemaGroup)[];
+    settings?: (InspectorGroup | WeaverseNextThemeSchemaGroup)[];
+    [key: string]: unknown;
+}
+/**
+ * Minimal Storefront client shape required by component loaders. The host app
+ * provides this (public or private token mode); Weaverse never owns it.
+ */
+interface WeaverseNextStorefront {
+    i18n?: WeaverseNextI18n;
+    query: (query: string, options?: unknown) => Promise<unknown>;
+    [key: string]: unknown;
+}
+/**
+ * App-provided commerce context. `storefront` is the only v0 must-have; cart
+ * and customer-account stay app-owned and are passed through untouched.
+ */
+interface WeaverseNextCommerceContext {
+    cart?: unknown;
+    customerAccount?: unknown;
+    storefront?: WeaverseNextStorefront;
+    [key: string]: unknown;
+}
+/**
+ * Explicit, framework-neutral replacement for React Router's
+ * `LoaderFunctionArgs`. Built by the Next route/page from params + headers +
+ * searchParams instead of an implicit loader context.
+ */
+interface WeaverseNextRequestContext {
+    handle?: string;
+    headers?: Headers;
+    i18n?: WeaverseNextI18n;
+    isDesignMode?: boolean;
+    isPreviewMode?: boolean;
+    isRevisionPreview?: boolean;
+    pageType?: PageType;
+    pathname?: string;
+    searchParams?: URLSearchParams;
+    sectionType?: string;
+    url?: URL | string;
+    [key: string]: unknown;
+}
+/** A single serialized item in a Weaverse page tree. */
+interface WeaverseNextComponentData {
+    children?: WeaverseNextComponentData[] | {
+        id: string;
+    }[];
+    data?: Record<string, unknown>;
+    id: string;
+    /** Attached by {@link runWeaverseComponentLoaders} after a loader runs. */
+    loaderData?: unknown;
+    type: string;
+    [key: string]: unknown;
+}
+/** Serialized page tree fetched from Weaverse. */
+interface WeaverseNextPageData {
+    id: string;
+    items: WeaverseNextComponentData[];
+    name?: string;
+    rootId?: string;
+    /** Page-level SEO metadata published by Weaverse Builder. */
+    seo?: PageSEOData | null;
+    [key: string]: unknown;
+}
+/**
+ * Top-level payload returned by `client.loadPage`. Kept close to Hydrogen's
+ * `WeaverseLoaderData` so registered components stay portable.
+ */
+interface WeaverseNextLoaderData {
+    configs?: Record<string, unknown>;
+    page: WeaverseNextPageData;
+    pageAssignment?: WeaverseNextPageAssignment;
+    project?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/** Props injected into every registered Weaverse component. */
+interface WeaverseNextComponentProps<L = unknown> extends Partial<WeaverseElement> {
+    children?: ReactNode;
+    className?: string;
+    loaderData?: L;
+    [key: string]: unknown;
+}
+/**
+ * Arguments passed to a component `loader`. `commerce.storefront` is the
+ * explicit contract; `weaverse.storefront` exists as a compatibility alias for
+ * Pilot-style loaders that call `weaverse.storefront.query(...)`.
+ */
+interface WeaverseNextComponentLoaderArgs<TData = unknown> {
+    commerce?: WeaverseNextCommerceContext;
+    context?: WeaverseNextRequestContext;
+    data: TData;
+    weaverse: WeaverseNextClient;
+}
+/** Registered component module shape: `default` + `schema` + optional `loader`. */
+interface WeaverseNextComponent<TProps extends WeaverseNextComponentProps = WeaverseNextComponentProps> {
+    default: ComponentType<TProps> | ForwardRefExoticComponent<TProps>;
+    loader?: (args: WeaverseNextComponentLoaderArgs) => Promise<unknown>;
+    schema: SchemaType;
+}
+/** Input for `client.loadPage`. The Next route maps `params` → `type/handle`. */
+interface WeaverseNextLoadPageInput {
+    handle?: string;
+    locale?: string;
+    type?: PageType;
+    [key: string]: unknown;
+}
+interface WeaverseNextClientConfig {
+    commerce?: WeaverseNextCommerceContext;
+    components: WeaverseNextComponent[];
+    /**
+     * Injected page fetcher. v0 delegates network I/O to the host app so the
+     * adapter can be tested without real Weaverse API calls.
+     */
+    fetchPage?: (input: WeaverseNextLoadPageInput) => Promise<WeaverseNextLoaderData | null>;
+    /** Injected theme-settings fetcher. */
+    fetchThemeSettings?: (context?: WeaverseNextRequestContext) => Promise<unknown>;
+    projectId: string;
+    requestContext?: WeaverseNextRequestContext;
+    themeSchema?: WeaverseNextThemeSchema;
+    themeSettings?: Record<string, unknown>;
+}
+/**
+ * Request-safe client returned by {@link createWeaverseNextClient}. Holds the
+ * registry/config plus the currently loaded page data, and is the object passed
+ * to component loaders as `weaverse`.
+ */
+interface WeaverseNextClient {
+    commerce?: WeaverseNextCommerceContext;
+    components: WeaverseNextComponent[];
+    /** Currently loaded page payload (set by `loadPage`). */
+    data: WeaverseNextLoaderData | null;
+    /** Data-connector context handed to the React renderer. */
+    dataContext: Record<string, unknown>;
+    loadPage: (input?: WeaverseNextLoadPageInput) => Promise<WeaverseNextLoaderData | null>;
+    loadThemeSettings: (context?: WeaverseNextRequestContext) => Promise<unknown>;
+    projectId: string;
+    requestContext?: WeaverseNextRequestContext;
+    /** Compatibility alias for `commerce.storefront`. */
+    storefront?: WeaverseNextStorefront;
+    themeSchema?: WeaverseNextThemeSchema;
+    themeSettings: Record<string, unknown>;
+}
+type WeaverseProduct = WeaverseResourcePickerData;
+type WeaverseCollection = WeaverseResourcePickerData;
+type WeaverseBlog = WeaverseResourcePickerData;
+type WeaverseArticle = WeaverseResourcePickerData;
+type WeaverseMetaObject = WeaverseResourcePickerData;
+/**
+ * Project identifier accepted by {@link WeaverseNextServerClientConfig}. Either
+ * a static string or a (possibly async) resolver that reads the request
+ * context — matching Hydrogen's static/dynamic projectId support.
+ */
+type WeaverseNextProjectId = string | ((context?: WeaverseNextRequestContext) => string | Promise<string> | undefined);
+/** Simple Next.js fetch cache options used for published-mode requests. */
+interface WeaverseNextCacheConfig {
+    /** Maps to Next's `fetch(..., { next: { revalidate } })`. */
+    revalidate?: number | false;
+    /** Maps to Next's `fetch(..., { next: { tags } })`. */
+    tags?: string[];
+}
+/**
+ * Per-request fetch options for {@link WeaverseNextServerClient.fetchWithCache}.
+ * Plain `RequestInit` plus the same simple Next cache knobs as
+ * {@link WeaverseNextCacheConfig}, so callers never need to import `next/*`.
+ */
+interface WeaverseNextFetchOptions extends RequestInit {
+    revalidate?: number | false;
+    tags?: string[];
+}
+/**
+ * Public, client-safe Weaverse config bundle. Mirrors Hydrogen's
+ * `WeaverseProjectConfigs` minus server secrets — `weaverseApiKey` is never
+ * included so it cannot leak into serialized loader data.
+ */
+interface WeaverseNextConfigs {
+    isDesignMode: boolean;
+    isPreviewMode: boolean;
+    isRevisionPreview: boolean;
+    projectId: string;
+    publicEnv: Record<string, string | undefined>;
+    sectionType: string;
+    weaverseApiBase: string;
+    weaverseHost: string;
+    weaversePublicApiBase: string;
+    weaverseVersion: string;
+}
+/**
+ * Resolved base configs derived from request context + env. Includes the
+ * server-only `weaverseApiKey`, so this stays internal to the server client and
+ * is never serialized into loader data.
+ */
+interface WeaverseNextBaseConfigs {
+    envProjectId: string;
+    isDesignMode: boolean;
+    isPreviewMode: boolean;
+    isRevisionPreview: boolean;
+    publicEnv: Record<string, string | undefined>;
+    queryProjectId: string;
+    sectionType: string;
+    weaverseApiBase: string;
+    weaverseApiKey: string;
+    weaverseHost: string;
+    weaverseVersion: string;
+}
+/** Theme settings payload returned by {@link WeaverseNextServerClient.loadThemeSettings}. */
+interface WeaverseNextThemeSettingsResponse {
+    _error?: string;
+    _loadFailed?: boolean;
+    merchantOverrides?: Record<string, unknown>;
+    publicEnv?: Record<string, string | undefined>;
+    schema?: WeaverseNextThemeSchema;
+    staticContent?: Record<string, unknown>;
+    theme?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Options for {@link WeaverseNextServerClient.loadThemeSettings}. Cache knobs
+ * only — the server client always reads the request context it was created
+ * with, so there is no per-call context override.
+ */
+interface WeaverseNextThemeSettingsOptions extends WeaverseNextCacheConfig {
+}
+interface WeaverseNextCustomPageEntry {
+    changeFrequency?: 'daily' | 'weekly' | 'monthly';
+    handle: string;
+    lastModified: string;
+    locale: string | null;
+    path: string;
+    priority?: number;
+}
+interface WeaverseNextFetchCustomPagesOptions extends WeaverseNextCacheConfig {
+    limit?: number;
+    locale?: string;
+}
+/**
+ * Config for {@link createWeaverseNextServerClient}. Unlike
+ * {@link WeaverseNextClientConfig} (which delegates network I/O to injected
+ * fetchers), the server client performs the real Weaverse API fetch itself, so
+ * it accepts request context, env, and cache options instead.
+ */
+interface WeaverseNextServerClientConfig {
+    cache?: WeaverseNextCacheConfig;
+    commerce?: WeaverseNextCommerceContext;
+    components: WeaverseNextComponent[];
+    /** Plain env map; falls back to `process.env` for any missing key. */
+    env?: Record<string, string | undefined>;
+    /** Custom `fetch` (mainly for tests); defaults to the global `fetch`. */
+    fetch?: typeof fetch;
+    /** Per-request network timeout in ms. Defaults to 10s. */
+    fetchTimeoutMs?: number;
+    projectId?: WeaverseNextProjectId;
+    requestContext?: WeaverseNextRequestContext;
+    themeSchema?: WeaverseNextThemeSchema;
+    themeSettings?: Record<string, unknown>;
+    /** Optional override for the resolved Weaverse public API base. */
+    weaverseApiBase?: string;
+    /** Optional override for the resolved Weaverse host. */
+    weaverseHost?: string;
+    weaverseVersion?: string;
+}
+/**
+ * Server-side Weaverse client returned by {@link createWeaverseNextServerClient}.
+ * Closes the gap with Hydrogen's `context.weaverse.loadPage(...)` by performing
+ * the real Weaverse API fetch in Next server components/route handlers. It is
+ * also assignable to {@link WeaverseNextClient} so it can be passed straight to
+ * `runWeaverseComponentLoaders` and the renderer/runtime.
+ */
+interface WeaverseNextServerClient extends WeaverseNextClient {
+    /** Public, client-safe resolved configs (no server secrets). */
+    configs: WeaverseNextConfigs;
+    fetchCustomPages: (options?: WeaverseNextFetchCustomPagesOptions) => Promise<WeaverseNextCustomPageEntry[]>;
+    fetchWithCache: <T = unknown>(url: string, options?: WeaverseNextFetchOptions) => Promise<T>;
+    loadPage: (input?: WeaverseNextLoadPageInput) => Promise<WeaverseNextLoaderData | null>;
+    /**
+     * Load theme settings. Pass cache options (`revalidate` / `tags`) only — the
+     * request context is the one the client was created with, so there is no
+     * per-call context override. The parameter is typed broadly purely to stay
+     * assignable to the base {@link WeaverseNextClient.loadThemeSettings}; any
+     * non-cache fields are ignored.
+     */
+    loadThemeSettings: (options?: WeaverseNextThemeSettingsOptions | WeaverseNextRequestContext) => Promise<WeaverseNextThemeSettingsResponse>;
+    /** Resolve the effective projectId (query → function → string → env). */
+    resolveProjectId: () => Promise<string>;
+}
+/** Input for {@link WeaverseNextServerClient.loadPage}. */
+interface WeaverseNextServerLoadPageInput extends WeaverseNextLoadPageInput {
+    /** Per-call cache override merged over the client-level `cache` config. */
+    cache?: WeaverseNextCacheConfig;
+    /** Route-level project override (multi-project), like Hydrogen. */
+    projectId?: string;
+}
+
+interface WeaverseNextSeoMetadata {
+    alternates?: {
+        canonical?: string;
+    };
+    description?: string;
+    keywords?: string;
+    openGraph?: {
+        description?: string;
+        images?: string[];
+        title?: string;
+        type?: string;
+    };
+    robots: {
+        follow: boolean;
+        index: boolean;
+    };
+    title?: string;
+    twitter?: {
+        card?: string;
+        description?: string;
+        images?: string[];
+        title?: string;
+    };
+}
+declare function formatWeaverseNextSeoMetadata(seo: PageSEOData | null | undefined): WeaverseNextSeoMetadata;
+declare function getWeaverseNextSeoMetadata(data: WeaverseNextLoaderData | WeaverseNextPageData | {
+    page?: WeaverseNextPageData | null;
+} | null | undefined): WeaverseNextSeoMetadata;
+
+export { type WeaverseNextRuntimeInternal as A, type WeaverseNextSeoMetadata as B, type WeaverseNextServerClient as C, type WeaverseNextServerClientConfig as D, type WeaverseNextServerLoadPageInput as E, type WeaverseNextStorefront as F, type WeaverseNextThemeSchema as G, type WeaverseNextThemeSettingsOptions as H, type WeaverseNextThemeSettingsResponse as I, type WeaverseNextThemeSettingsStore as J, type WeaverseNextTranslationChanges as K, type WeaverseNextTranslationEntry as L, type WeaverseNextTranslationItemEntry as M, type WeaverseNextTranslationMap as N, type WeaverseNextTranslationMapEntry as O, type WeaverseProduct as P, formatWeaverseNextSeoMetadata as Q, getWeaverseNextSeoMetadata as R, ThemeTextStore as T, type WeaverseArticle as W, TranslationStore as a, type WeaverseBlog as b, type WeaverseCollection as c, type WeaverseMetaObject as d, type WeaverseNextBaseConfigs as e, type WeaverseNextCacheConfig as f, type WeaverseNextClient as g, type WeaverseNextClientConfig as h, type WeaverseNextCommerceContext as i, type WeaverseNextComponent as j, type WeaverseNextComponentData as k, type WeaverseNextComponentLoaderArgs as l, type WeaverseNextComponentProps as m, type WeaverseNextConfigs as n, type WeaverseNextCustomPageEntry as o, type WeaverseNextFetchCustomPagesOptions as p, type WeaverseNextFetchOptions as q, type WeaverseNextI18n as r, type WeaverseNextLoadPageInput as s, type WeaverseNextLoaderData as t, type WeaverseNextPageAssignment as u, type WeaverseNextPageData as v, type WeaverseNextProjectId as w, type WeaverseNextRequestContext as x, type WeaverseNextRequestInfo as y, type WeaverseNextRuntimeConfig as z };

package/dist/server.d.mts

@@ -0,0 +1,99 @@
+import { x as WeaverseNextRequestContext, e as WeaverseNextBaseConfigs, C as WeaverseNextServerClient, k as WeaverseNextComponentData, D as WeaverseNextServerClientConfig } from './seo-CgO21rLg.mjs';
+export { f as WeaverseNextCacheConfig, n as WeaverseNextConfigs, o as WeaverseNextCustomPageEntry, p as WeaverseNextFetchCustomPagesOptions, q as WeaverseNextFetchOptions, w as WeaverseNextProjectId, B as WeaverseNextSeoMetadata, E as WeaverseNextServerLoadPageInput, H as WeaverseNextThemeSettingsOptions, I as WeaverseNextThemeSettingsResponse, Q as formatWeaverseNextSeoMetadata, R as getWeaverseNextSeoMetadata } from './seo-CgO21rLg.mjs';
+import '@weaverse/schema';
+import '@weaverse/react';
+import 'react';
+
+interface ResolveConfigsOptions {
+    env?: Record<string, string | undefined>;
+    weaverseApiBase?: string;
+    weaverseHost?: string;
+    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.
+ */
+declare function getWeaverseNextConfigs(context?: WeaverseNextRequestContext, options?: ResolveConfigsOptions): WeaverseNextBaseConfigs;
+
+/**
+ * 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).
+ */
+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}.
+ */
+declare function resolveRequestUrl(context?: WeaverseNextRequestContext): string;
+
+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.
+     */
+    getClient: (request: Request) => Promise<WeaverseNextServerClient> | WeaverseNextServerClient;
+}
+/** POST body accepted by the revalidate route. */
+interface WeaverseNextRevalidateRequestBody {
+    draftItem: WeaverseNextComponentData;
+}
+/**
+ * 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({})),
+ * })
+ * ```
+ */
+declare function createWeaverseNextRevalidateHandler(config: WeaverseNextRevalidateHandlerConfig): {
+    POST: (request: Request) => Promise<Response>;
+};
+
+/**
+ * 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()
+ * ```
+ */
+declare function createWeaverseNextServerClient(config: WeaverseNextServerClientConfig): WeaverseNextServerClient;
+
+export { WeaverseNextBaseConfigs, type WeaverseNextRevalidateHandlerConfig, type WeaverseNextRevalidateRequestBody, WeaverseNextServerClient, WeaverseNextServerClientConfig, createWeaverseNextRevalidateHandler, createWeaverseNextServerClient, getWeaverseNextConfigs, normalizeNextPageUrl, resolveRequestUrl };