next-sanity 13.2.3 → 13.3.1

package/dist/SanityLive.js

@@ -71,9 +71,7 @@ function SanityLive(props) {
 				if (onGoAway) startTransition(() => onGoAway(event, actionContext, (interval) => startTransition(() => setRefreshOnInterval(interval))));
 				else if (!onGoAway) handleErrorEvent(new Error(`Sanity Live connection closed, automatic revalidation is disabled, the server gave this reason: ${event.reason}`, { cause: event }));
 				break;
-			default:
-				handleErrorEvent(new Error("Unknown live event type", { cause: event }));
-				break;
+			default: handleErrorEvent(new Error("Unknown live event type", { cause: event }));
 		}
 	});
 	useEffect(() => {

package/dist/SanityLive.js.map

@@ -1 +1 @@
-{"version":3,"file":"SanityLive.js","names":[],"sources":["../src/live/client-components/RefreshOnInterval.tsx","../src/live/client-components/SanityLive.tsx"],"sourcesContent":["'use client'\nimport {useRouter} from 'next/navigation'\nimport {startTransition, useEffect} from 'react'\n\nexport function RefreshOnInterval(props: {interval: number}): null {\n  const router = useRouter()\n\n  useEffect(() => {\n    const interval = setInterval(() => startTransition(() => router.refresh()), props.interval)\n    return () => clearInterval(interval)\n  }, [router, props.interval])\n\n  return null\n}\nRefreshOnInterval.displayName = 'RefreshOnInterval'\n","import {createClient, type LiveEvent} from '@sanity/client'\nimport {useRouter} from 'next/navigation'\nimport {useEffect, useMemo, useState, useEffectEvent, startTransition} from 'react'\n\nimport {cacheTagPrefix, defaultApiHost} from '#live/constants'\nimport {isCorsOriginError} from '#live/isCorsOriginError'\nimport type {\n  SanityClientConfig,\n  SanityLiveAction,\n  SanityLiveContext,\n  SanityLiveOnError,\n  SanityLiveOnGoaway,\n  SanityLiveOnReconnect,\n  SanityLiveOnRestart,\n  SanityLiveOnWelcome,\n} from '#live/types'\n\nimport {RefreshOnInterval} from './RefreshOnInterval'\n\nexport interface SanityLiveProps {\n  config: SanityClientConfig\n  includeDrafts: true | undefined\n  requestTag: string\n  waitFor: 'function' | undefined\n\n  action: SanityLiveAction\n  onError: SanityLiveOnError | undefined\n  onWelcome: SanityLiveOnWelcome | false | undefined\n  onReconnect: SanityLiveOnReconnect | false | undefined\n  onRestart: SanityLiveOnRestart | false | undefined\n  onGoAway: SanityLiveOnGoaway | false | undefined\n}\n\nfunction SanityLive(props: SanityLiveProps): React.JSX.Element | null {\n  const {\n    config,\n    includeDrafts = false,\n    requestTag,\n    waitFor,\n\n    action,\n    onError = handleError,\n    onWelcome = handleWelcome,\n    onReconnect = handleReconnect,\n    onRestart = 'refresh',\n    onGoAway = handleGoaway,\n  } = props\n  const {\n    projectId,\n    dataset,\n    apiHost = defaultApiHost,\n    apiVersion,\n    useProjectHostname = true,\n    token,\n    requestTagPrefix,\n  } = config\n  const actionContext = {includeDrafts, waitFor} satisfies SanityLiveContext\n\n  const client = useMemo(\n    () =>\n      createClient({\n        projectId,\n        dataset,\n        apiHost,\n        apiVersion,\n        useProjectHostname,\n        ignoreBrowserTokenWarning: true,\n        token,\n        useCdn: false,\n        requestTagPrefix,\n      }),\n    [apiHost, apiVersion, dataset, projectId, requestTagPrefix, token, useProjectHostname],\n  )\n\n  // The interval is set in milliseconds, false means long polling is disabled\n  const [refreshOnInterval, setRefreshOnInterval] = useState<number | false>(false)\n\n  const [error, setError] = useState<unknown>()\n  if (error !== undefined) {\n    // Throw during render to bubble up to the nearest <ErrorBoundary>, only when `onError=\"throw\"` is set\n    throw error\n  }\n  const handleErrorEvent = useEffectEvent((error: unknown) => {\n    if (onError === 'throw') {\n      setError(error)\n    } else {\n      onError(error, actionContext)\n    }\n  })\n\n  const router = useRouter()\n  const handleLiveEvent = useEffectEvent((event: LiveEvent) => {\n    switch (event.type) {\n      case 'welcome': {\n        // Disable long polling when welcome event is received, this is a no-op if long polling is already disabled\n        startTransition(() => setRefreshOnInterval(false))\n\n        if (onWelcome) {\n          startTransition(() => onWelcome(event, actionContext))\n        }\n        break\n      }\n      case 'message': {\n        startTransition(() =>\n          action === 'refresh'\n            ? router.refresh()\n            : action(event.tags.map((tag) => `${cacheTagPrefix}${tag}`)).then((result) => {\n                if (result === 'refresh') {\n                  startTransition(() => router.refresh())\n                }\n              }),\n        )\n        break\n      }\n      case 'reconnect': {\n        if (onReconnect) {\n          startTransition(() => onReconnect(event, actionContext))\n        }\n        break\n      }\n      case 'restart': {\n        // Disable long polling when restart event is received, this is a no-op if long polling is already disabled\n        startTransition(() => setRefreshOnInterval(false))\n\n        if (onRestart) {\n          startTransition(() =>\n            onRestart === 'refresh'\n              ? router.refresh()\n              : Promise.resolve(onRestart(event, actionContext)).then((result) => {\n                  if (result === 'refresh') {\n                    startTransition(() => router.refresh())\n                  }\n                }),\n          )\n        }\n        break\n      }\n      case 'goaway': {\n        if (onGoAway) {\n          startTransition(() =>\n            onGoAway(event, actionContext, (interval) =>\n              startTransition(() => setRefreshOnInterval(interval)),\n            ),\n          )\n        } else if (!onGoAway) {\n          handleErrorEvent(\n            new Error(\n              `Sanity Live connection closed, automatic revalidation is disabled, the server gave this reason: ${event.reason}`,\n              {cause: event},\n            ),\n          )\n        }\n        break\n      }\n      default:\n        handleErrorEvent(new Error('Unknown live event type', {cause: event}))\n        break\n    }\n  })\n  useEffect(() => {\n    const subscription = client.live\n      .events({includeDrafts, tag: requestTag, waitFor})\n      .subscribe({next: handleLiveEvent, error: handleErrorEvent})\n    return () => subscription.unsubscribe()\n  }, [client.live, requestTag, includeDrafts, waitFor])\n\n  if (refreshOnInterval && Number.isFinite(refreshOnInterval) && refreshOnInterval > 0) {\n    return <RefreshOnInterval interval={refreshOnInterval} />\n  }\n  return null\n}\n\nSanityLive.displayName = 'SanityLiveClientComponent'\n\nexport default SanityLive\n\nconst handleError: Exclude<SanityLiveOnError, 'throw'> = (error, _context) => {\n  if (isCorsOriginError(error)) {\n    console.warn(\n      `Sanity Live is unable to connect to the Sanity API as the current origin - ${window.origin} - is not in the list of allowed CORS origins for this Sanity Project.`,\n      error.addOriginUrl && `Add it here:`,\n      error.addOriginUrl?.toString(),\n    )\n  } else {\n    console.error(error)\n  }\n}\n\nconst handleWelcome: SanityLiveOnWelcome = (_, {includeDrafts, waitFor}) => {\n  // oxlint-disable-next-line no-console\n  console.info(\n    `<SanityLive${includeDrafts ? ' includeDrafts' : ''}> is connected and listening for live events to ${includeDrafts ? 'all content including drafts and version documents in content releases' : 'published content'}.${waitFor === 'function' ? ' Events will be delayed until after a Sanity Function has processed them.' : ''}`,\n  )\n}\n\nconst handleReconnect: SanityLiveOnReconnect = (_, {includeDrafts}) => {\n  console.error(`<SanityLive${includeDrafts ? ' includeDrafts' : ''}> is attempting to reconnect`)\n}\n\nconst handleGoaway: SanityLiveOnGoaway = (event, {includeDrafts}, setLongPollingInterval) => {\n  const interval = 30_000\n  console.warn(\n    `<SanityLive${includeDrafts ? ' includeDrafts' : ''}> connection is closed after receiving a 'goaway' event, the server gave this reason:`,\n    JSON.stringify(event.reason),\n    `Content will now be refreshed every ${interval / 1_000} seconds`,\n  )\n  setLongPollingInterval(interval)\n}\n"],"mappings":"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"}
+{"version":3,"file":"SanityLive.js","names":[],"sources":["../src/live/client-components/RefreshOnInterval.tsx","../src/live/client-components/SanityLive.tsx"],"sourcesContent":["'use client'\nimport {useRouter} from 'next/navigation'\nimport {startTransition, useEffect} from 'react'\n\nexport function RefreshOnInterval(props: {interval: number}): null {\n  const router = useRouter()\n\n  useEffect(() => {\n    const interval = setInterval(() => startTransition(() => router.refresh()), props.interval)\n    return () => clearInterval(interval)\n  }, [router, props.interval])\n\n  return null\n}\nRefreshOnInterval.displayName = 'RefreshOnInterval'\n","import {createClient, type LiveEvent} from '@sanity/client'\nimport {useRouter} from 'next/navigation'\nimport {useEffect, useMemo, useState, useEffectEvent, startTransition} from 'react'\n\nimport {cacheTagPrefix, defaultApiHost} from '#live/constants'\nimport {isCorsOriginError} from '#live/isCorsOriginError'\nimport type {\n  SanityClientConfig,\n  SanityLiveAction,\n  SanityLiveContext,\n  SanityLiveOnError,\n  SanityLiveOnGoaway,\n  SanityLiveOnReconnect,\n  SanityLiveOnRestart,\n  SanityLiveOnWelcome,\n} from '#live/types'\n\nimport {RefreshOnInterval} from './RefreshOnInterval'\n\nexport interface SanityLiveProps {\n  config: SanityClientConfig\n  includeDrafts: true | undefined\n  requestTag: string\n  waitFor: 'function' | undefined\n\n  action: SanityLiveAction\n  onError: SanityLiveOnError | undefined\n  onWelcome: SanityLiveOnWelcome | false | undefined\n  onReconnect: SanityLiveOnReconnect | false | undefined\n  onRestart: SanityLiveOnRestart | false | undefined\n  onGoAway: SanityLiveOnGoaway | false | undefined\n}\n\nfunction SanityLive(props: SanityLiveProps): React.JSX.Element | null {\n  const {\n    config,\n    includeDrafts = false,\n    requestTag,\n    waitFor,\n\n    action,\n    onError = handleError,\n    onWelcome = handleWelcome,\n    onReconnect = handleReconnect,\n    onRestart = 'refresh',\n    onGoAway = handleGoaway,\n  } = props\n  const {\n    projectId,\n    dataset,\n    apiHost = defaultApiHost,\n    apiVersion,\n    useProjectHostname = true,\n    token,\n    requestTagPrefix,\n  } = config\n  const actionContext = {includeDrafts, waitFor} satisfies SanityLiveContext\n\n  const client = useMemo(\n    () =>\n      createClient({\n        projectId,\n        dataset,\n        apiHost,\n        apiVersion,\n        useProjectHostname,\n        ignoreBrowserTokenWarning: true,\n        token,\n        useCdn: false,\n        requestTagPrefix,\n      }),\n    [apiHost, apiVersion, dataset, projectId, requestTagPrefix, token, useProjectHostname],\n  )\n\n  // The interval is set in milliseconds, false means long polling is disabled\n  const [refreshOnInterval, setRefreshOnInterval] = useState<number | false>(false)\n\n  const [error, setError] = useState<unknown>()\n  if (error !== undefined) {\n    // Throw during render to bubble up to the nearest <ErrorBoundary>, only when `onError=\"throw\"` is set\n    throw error\n  }\n  const handleErrorEvent = useEffectEvent((error: unknown) => {\n    if (onError === 'throw') {\n      setError(error)\n    } else {\n      onError(error, actionContext)\n    }\n  })\n\n  const router = useRouter()\n  const handleLiveEvent = useEffectEvent((event: LiveEvent) => {\n    switch (event.type) {\n      case 'welcome': {\n        // Disable long polling when welcome event is received, this is a no-op if long polling is already disabled\n        startTransition(() => setRefreshOnInterval(false))\n\n        if (onWelcome) {\n          startTransition(() => onWelcome(event, actionContext))\n        }\n        break\n      }\n      case 'message': {\n        startTransition(() =>\n          action === 'refresh'\n            ? router.refresh()\n            : action(event.tags.map((tag) => `${cacheTagPrefix}${tag}`)).then((result) => {\n                if (result === 'refresh') {\n                  startTransition(() => router.refresh())\n                }\n              }),\n        )\n        break\n      }\n      case 'reconnect': {\n        if (onReconnect) {\n          startTransition(() => onReconnect(event, actionContext))\n        }\n        break\n      }\n      case 'restart': {\n        // Disable long polling when restart event is received, this is a no-op if long polling is already disabled\n        startTransition(() => setRefreshOnInterval(false))\n\n        if (onRestart) {\n          startTransition(() =>\n            onRestart === 'refresh'\n              ? router.refresh()\n              : Promise.resolve(onRestart(event, actionContext)).then((result) => {\n                  if (result === 'refresh') {\n                    startTransition(() => router.refresh())\n                  }\n                }),\n          )\n        }\n        break\n      }\n      case 'goaway': {\n        if (onGoAway) {\n          startTransition(() =>\n            onGoAway(event, actionContext, (interval) =>\n              startTransition(() => setRefreshOnInterval(interval)),\n            ),\n          )\n        } else if (!onGoAway) {\n          handleErrorEvent(\n            new Error(\n              `Sanity Live connection closed, automatic revalidation is disabled, the server gave this reason: ${event.reason}`,\n              {cause: event},\n            ),\n          )\n        }\n        break\n      }\n      default:\n        handleErrorEvent(new Error('Unknown live event type', {cause: event}))\n        break\n    }\n  })\n  useEffect(() => {\n    const subscription = client.live\n      .events({includeDrafts, tag: requestTag, waitFor})\n      .subscribe({next: handleLiveEvent, error: handleErrorEvent})\n    return () => subscription.unsubscribe()\n  }, [client.live, requestTag, includeDrafts, waitFor])\n\n  if (refreshOnInterval && Number.isFinite(refreshOnInterval) && refreshOnInterval > 0) {\n    return <RefreshOnInterval interval={refreshOnInterval} />\n  }\n  return null\n}\n\nSanityLive.displayName = 'SanityLiveClientComponent'\n\nexport default SanityLive\n\nconst handleError: Exclude<SanityLiveOnError, 'throw'> = (error, _context) => {\n  if (isCorsOriginError(error)) {\n    console.warn(\n      `Sanity Live is unable to connect to the Sanity API as the current origin - ${window.origin} - is not in the list of allowed CORS origins for this Sanity Project.`,\n      error.addOriginUrl && `Add it here:`,\n      error.addOriginUrl?.toString(),\n    )\n  } else {\n    console.error(error)\n  }\n}\n\nconst handleWelcome: SanityLiveOnWelcome = (_, {includeDrafts, waitFor}) => {\n  // oxlint-disable-next-line no-console\n  console.info(\n    `<SanityLive${includeDrafts ? ' includeDrafts' : ''}> is connected and listening for live events to ${includeDrafts ? 'all content including drafts and version documents in content releases' : 'published content'}.${waitFor === 'function' ? ' Events will be delayed until after a Sanity Function has processed them.' : ''}`,\n  )\n}\n\nconst handleReconnect: SanityLiveOnReconnect = (_, {includeDrafts}) => {\n  console.error(`<SanityLive${includeDrafts ? ' includeDrafts' : ''}> is attempting to reconnect`)\n}\n\nconst handleGoaway: SanityLiveOnGoaway = (event, {includeDrafts}, setLongPollingInterval) => {\n  const interval = 30_000\n  console.warn(\n    `<SanityLive${includeDrafts ? ' includeDrafts' : ''}> connection is closed after receiving a 'goaway' event, the server gave this reason:`,\n    JSON.stringify(event.reason),\n    `Content will now be refreshed every ${interval / 1_000} seconds`,\n  )\n  setLongPollingInterval(interval)\n}\n"],"mappings":";;;;;;AAIA,SAAgB,kBAAkB,OAAiC;CACjE,MAAM,SAAS,UAAU;CAEzB,gBAAgB;EACd,MAAM,WAAW,kBAAkB,sBAAsB,OAAO,QAAQ,CAAC,GAAG,MAAM,QAAQ;EAC1F,aAAa,cAAc,QAAQ;CACrC,GAAG,CAAC,QAAQ,MAAM,QAAQ,CAAC;CAE3B,OAAO;AACT;AACA,kBAAkB,cAAc;ACmBhC,SAAS,WAAW,OAAkD;CACpE,MAAM,EACJ,QACA,gBAAgB,OAChB,YACA,SAEA,QACA,UAAU,aACV,YAAY,eACZ,cAAc,iBACd,YAAY,WACZ,WAAW,iBACT;CACJ,MAAM,EACJ,WACA,SACA,UAAU,gBACV,YACA,qBAAqB,MACrB,OACA,qBACE;CACJ,MAAM,gBAAgB;EAAC;EAAe;CAAO;CAE7C,MAAM,SAAS,cAEX,aAAa;EACX;EACA;EACA;EACA;EACA;EACA,2BAA2B;EAC3B;EACA,QAAQ;EACR;CACF,CAAC,GACH;EAAC;EAAS;EAAY;EAAS;EAAW;EAAkB;EAAO;CAAkB,CACvF;CAGA,MAAM,CAAC,mBAAmB,wBAAwB,SAAyB,KAAK;CAEhF,MAAM,CAAC,OAAO,YAAY,SAAkB;CAC5C,IAAI,UAAU,KAAA,GAEZ,MAAM;CAER,MAAM,mBAAmB,gBAAgB,UAAmB;EAC1D,IAAI,YAAY,SACd,SAAS,KAAK;OAEd,QAAQ,OAAO,aAAa;CAEhC,CAAC;CAED,MAAM,SAAS,UAAU;CACzB,MAAM,kBAAkB,gBAAgB,UAAqB;EAC3D,QAAQ,MAAM,MAAd;GACE,KAAK;IAEH,sBAAsB,qBAAqB,KAAK,CAAC;IAEjD,IAAI,WACF,sBAAsB,UAAU,OAAO,aAAa,CAAC;IAEvD;GAEF,KAAK;IACH,sBACE,WAAW,YACP,OAAO,QAAQ,IACf,OAAO,MAAM,KAAK,KAAK,QAAQ,GAAG,iBAAiB,KAAK,CAAC,CAAC,CAAC,MAAM,WAAW;KAC1E,IAAI,WAAW,WACb,sBAAsB,OAAO,QAAQ,CAAC;IAE1C,CAAC,CACP;IACA;GAEF,KAAK;IACH,IAAI,aACF,sBAAsB,YAAY,OAAO,aAAa,CAAC;IAEzD;GAEF,KAAK;IAEH,sBAAsB,qBAAqB,KAAK,CAAC;IAEjD,IAAI,WACF,sBACE,cAAc,YACV,OAAO,QAAQ,IACf,QAAQ,QAAQ,UAAU,OAAO,aAAa,CAAC,CAAC,CAAC,MAAM,WAAW;KAChE,IAAI,WAAW,WACb,sBAAsB,OAAO,QAAQ,CAAC;IAE1C,CAAC,CACP;IAEF;GAEF,KAAK;IACH,IAAI,UACF,sBACE,SAAS,OAAO,gBAAgB,aAC9B,sBAAsB,qBAAqB,QAAQ,CAAC,CACtD,CACF;SACK,IAAI,CAAC,UACV,iBACE,IAAI,MACF,mGAAmG,MAAM,UACzG,EAAC,OAAO,MAAK,CACf,CACF;IAEF;GAEF,SACE,iBAAiB,IAAI,MAAM,2BAA2B,EAAC,OAAO,MAAK,CAAC,CAAC;EAEzE;CACF,CAAC;CACD,gBAAgB;EACd,MAAM,eAAe,OAAO,KACzB,OAAO;GAAC;GAAe,KAAK;GAAY;EAAO,CAAC,CAAC,CACjD,UAAU;GAAC,MAAM;GAAiB,OAAO;EAAgB,CAAC;EAC7D,aAAa,aAAa,YAAY;CACxC,GAAG;EAAC,OAAO;EAAM;EAAY;EAAe;CAAO,CAAC;CAEpD,IAAI,qBAAqB,OAAO,SAAS,iBAAiB,KAAK,oBAAoB,GACjF,OAAO,oBAAC,mBAAD,EAAmB,UAAU,kBAAoB,CAAA;CAE1D,OAAO;AACT;AAEA,WAAW,cAAc;AAIzB,MAAM,eAAoD,OAAO,aAAa;CAC5E,IAAI,kBAAkB,KAAK,GACzB,QAAQ,KACN,8EAA8E,OAAO,OAAO,yEAC5F,MAAM,gBAAgB,gBACtB,MAAM,cAAc,SAAS,CAC/B;MAEA,QAAQ,MAAM,KAAK;AAEvB;AAEA,MAAM,iBAAsC,GAAG,EAAC,eAAe,cAAa;CAE1E,QAAQ,KACN,cAAc,gBAAgB,mBAAmB,GAAG,kDAAkD,gBAAgB,2EAA2E,oBAAoB,GAAG,YAAY,aAAa,8EAA8E,IACjU;AACF;AAEA,MAAM,mBAA0C,GAAG,EAAC,oBAAmB;CACrE,QAAQ,MAAM,cAAc,gBAAgB,mBAAmB,GAAG,6BAA6B;AACjG;AAEA,MAAM,gBAAoC,OAAO,EAAC,iBAAgB,2BAA2B;CAC3F,MAAM,WAAW;CACjB,QAAQ,KACN,cAAc,gBAAgB,mBAAmB,GAAG,wFACpD,KAAK,UAAU,MAAM,MAAM,GAC3B,uCAAuC,WAAW,IAAM,SAC1D;CACA,uBAAuB,QAAQ;AACjC"}

package/dist/index.d.ts

@@ -1,10 +1,133 @@
 import { t as isCorsOriginError } from "./isCorsOriginError.js";
 import { createClient, unstable__adapter, unstable__environment } from "@sanity/client";
-import { stegaClean } from "@sanity/client/stega";
+import { ClientReturnStega, StegaBranded, StegaBranded as StegaBranded$1, StegaCleaned, StegaCleaned as StegaCleaned$1, StegaString, stegaBrand, stegaClean } from "@sanity/client/stega";
 import { CreateDataAttribute, CreateDataAttributeProps, createDataAttribute } from "@sanity/visual-editing/create-data-attribute";
+import { InferComponents as InferComponents$1, InferStrictComponents as InferStrictComponents$1, InferValue as InferValue$1 } from "@portabletext/react";
 import groq, { defineQuery } from "groq";
 export * from "@sanity/client";
 export * from "@portabletext/react";
+/**
+ * Widens a query result type to cover both sides of stega branding:
+ * the clean TypeGen shape (`sanityFetch` with `stega: false`) and the
+ * stega-branded shape (`sanityFetch` when stega may be enabled).
+ *
+ * This is what lets the `Infer*` types accept `data` from any `sanityFetch`
+ * call without requiring a wholesale `stegaClean()`, which would strip the
+ * hidden characters Visual Editing needs to make each paragraph clickable.
+ */
+type StegaAware<T> = StegaCleaned$1<T> | StegaBranded$1<T>;
+/**
+ * Infer the Portable Text array value type from
+ * {@link https://www.sanity.io/docs/apis-and-sdks/sanity-typegen | Sanity TypeGen}
+ * generated types.
+ *
+ * Stega-aware version of `InferValue` from `@portabletext/react`: the inferred
+ * value type accepts both clean query results (`sanityFetch` with
+ * `stega: false`) and stega-branded results (`sanityFetch` when stega may be
+ * enabled). Don't clean the value with `stegaClean()` before rendering it,
+ * that strips the hidden characters `@sanity/visual-editing` uses to make each
+ * paragraph clickable. Instead, use `stegaClean` on individual strings at the
+ * point where they're compared against literals.
+ *
+ * Useful when building a re-usable wrapper component that only takes `value`
+ * as an input prop and sets up `components` internally. Pass a TypeGen-
+ * generated query result type that contains Portable Text fields - such as
+ * an individual query result like `PostQueryResult`, or the `SanityQueries`
+ * interface from `@sanity/client` - and `InferValue<T>` returns an array type
+ * containing every Portable Text item shape it can find.
+ *
+ * Always feed `InferValue<T>` query result types, not Sanity schema types.
+ * Schema types describe how content is stored, which can differ from how it
+ * is queried (e.g. references resolved with `->`).
+ *
+ * @example
+ * ```tsx
+ * // Re-usable component typed against every registered query. Relies on
+ * // `overloadClientMethods` being enabled in `sanity.cli.ts#typegen` (the default).
+ * import {
+ *   PortableText,
+ *   type InferStrictComponents,
+ *   type InferValue,
+ *   type SanityQueries,
+ * } from 'next-sanity'
+ *
+ * type PortableTextValue = InferValue<SanityQueries[keyof SanityQueries]>
+ *
+ * export function CustomPortableText(props: {value: PortableTextValue}) {
+ *   const components = {
+ *     types: {
+ *       // custom types are autocompleted and fully typed
+ *     },
+ *   } satisfies InferStrictComponents<PortableTextValue>
+ *
+ *   return <PortableText components={components} value={props.value} />
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Rendering `sanityFetch` results, with or without stega, type-checks:
+ * const {data} = await sanityFetch({query: postQuery, params})
+ * return Array.isArray(data?.content) && <CustomPortableText value={data.content} />
+ * ```
+ */
+type InferValue<T> = InferValue$1<StegaAware<T>>;
+/**
+ * Infer Portable Text components from a value type. This matches the inference
+ * behavior of the `components` prop on `<PortableText>`.
+ *
+ * Stega-aware version of `InferComponents` from `@portabletext/react`: the
+ * inferred component props cover both clean query results (`sanityFetch` with
+ * `stega: false`) and stega-branded results (`sanityFetch` when stega may be
+ * enabled), so the same `components` object can render both. Strings that may
+ * carry stega payloads stay branded inside component props: render them as-is
+ * to keep Visual Editing working, and use `stegaClean` on the individual
+ * values you compare against string literals.
+ *
+ * This is useful when working with
+ * {@link https://www.sanity.io/docs/apis-and-sdks/sanity-typegen | Sanity TypeGen},
+ * where `defineQuery()` and `sanityFetch()` can infer the shape of Portable
+ * Text fields.
+ *
+ * @example
+ * ```tsx
+ * import {PortableText, type InferComponents, defineQuery} from 'next-sanity'
+ * import {sanityFetch} from '@/sanity/lib/live'
+ *
+ * export default async function Page({slug}: {slug: string}) {
+ *   const query = defineQuery(`*[_type == "post" && slug.current == $slug][0]{title,content}`)
+ *   const {data} = await sanityFetch({query, params: {slug}})
+ *   const components = {
+ *     block: {
+ *       // custom types are autocompleted and fully typed
+ *     },
+ *   } satisfies InferComponents<typeof data.content>
+ *
+ *   return (
+ *     <>
+ *       ...
+ *       {Array.isArray(data?.content) && <PortableText components={components} value={data.content} />}
+ *     </>
+ *   )
+ * }
+ * ```
+ */
+type InferComponents<T> = InferComponents$1<StegaAware<T>>;
+/**
+ * Infer Portable Text components from a value type, requiring handlers for all
+ * custom object types and disallowing extra custom object type handlers.
+ *
+ * Stega-aware version of `InferStrictComponents` from `@portabletext/react`,
+ * see {@link InferComponents} for how stega branding is handled.
+ *
+ * This is used the same way as {@link InferComponents}, but serves a different
+ * purpose: `InferComponents` is forgiving and mirrors the inline
+ * `<PortableText components={...} />` experience, allowing custom handlers to
+ * be omitted and allowing handlers for types that do not exist in, or could not
+ * be inferred from, the value type. `InferStrictComponents` is strict: it
+ * requires inferred custom handlers and rejects unknown ones.
+ */
+type InferStrictComponents<T> = InferStrictComponents$1<StegaAware<T>>;
 /**
  * API version required for editing variants queries.
  * Uses the `X` alias while variants are in beta; will move to a dated version when stable.
@@ -12,5 +135,5 @@ export * from "@portabletext/react";
  * @public
  */
 declare const variantsApiVersion = "X";
-export { type CreateDataAttribute, type CreateDataAttributeProps, createClient, createDataAttribute, defineQuery, groq, isCorsOriginError, stegaClean, unstable__adapter, unstable__environment, variantsApiVersion };
+export { type ClientReturnStega, type CreateDataAttribute, type CreateDataAttributeProps, type InferComponents, type InferStrictComponents, type InferValue, type StegaBranded, type StegaCleaned, type StegaString, createClient, createDataAttribute, defineQuery, groq, isCorsOriginError, stegaBrand, stegaClean, unstable__adapter, unstable__environment, variantsApiVersion };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/variants/constants.ts"],"mappings":";;;;;;;;;;;;;cAMa"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/portable-text.ts","../src/variants/constants.ts"],"mappings":";;;;;;;;;;;;;;;;;KAgBK,WAAW,KAAK,eAAa,KAAK,eAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAyDxC,WAAW,KAAK,aAAuB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0ClD,gBAAgB,KAAK,kBAA4B,WAAW;;;;;;;;;;;;;;;KAgB5D,sBAAsB,KAAK,wBAAkC,WAAW;;;;;;;cC7HvE"}

package/dist/index.js

@@ -1,6 +1,6 @@
 import { t as isCorsOriginError } from "./isCorsOriginError.js";
 import { createClient, unstable__adapter, unstable__environment } from "@sanity/client";
-import { stegaClean } from "@sanity/client/stega";
+import { stegaBrand, stegaClean } from "@sanity/client/stega";
 import { createDataAttribute } from "@sanity/visual-editing/create-data-attribute";
 import groq, { defineQuery } from "groq";
 export * from "@portabletext/react";
@@ -11,6 +11,6 @@ export * from "@portabletext/react";
 * @public
 */
 const variantsApiVersion = "X";
-export { createClient, createDataAttribute, defineQuery, groq, isCorsOriginError, stegaClean, unstable__adapter, unstable__environment, variantsApiVersion };
+export { createClient, createDataAttribute, defineQuery, groq, isCorsOriginError, stegaBrand, stegaClean, unstable__adapter, unstable__environment, variantsApiVersion };
 
 //# sourceMappingURL=index.js.map

package/dist/live/conditions/default/index.d.ts

@@ -11,6 +11,11 @@ import { n as resolveVariantFromCookies$1, r as resolvePerspectiveFromCookies$1,
  * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`
  * outside `'use cache'` boundaries, then pass them into cached components.
  *
+ * `sanityFetch` brands `data` with stega string types when `stega` is `true`,
+ * a non-literal `boolean`, or omitted (react-server may auto-enable stega).
+ * Pass the literal `stega: false` for clean TypeGen types. Use `stegaClean`
+ * before comparing branded strings to literals.
+ *
  * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)
  * @see [Sanity Live](https://www.sanity.io/live)
  *
@@ -44,6 +49,7 @@ import { n as resolveVariantFromCookies$1, r as resolvePerspectiveFromCookies$1,
  * export interface DynamicFetchOptions {
  *   perspective: LivePerspective
  *   variant?: string
+ *   // `boolean` brands `sanityFetch` `data`; use literal `false` for clean types
  *   stega: boolean
  * }
  *

package/dist/live/conditions/default/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/live/conditions/default/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoKgB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFlB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoFrB,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsEtC,kCAAkC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/live/conditions/default/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0KgB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFlB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoFrB,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsEtC,kCAAkC"}

package/dist/live/conditions/default/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../../src/live/conditions/default/index.ts"],"sourcesContent":["import type {resolvePerspectiveFromCookies as _resolvePerspectiveFromCookies} from '#live/resolvePerspectiveFromCookies'\nimport type {resolveVariantFromCookies as _resolveVariantFromCookies} from '#live/resolveVariantFromCookies'\nimport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\n/**\n * Set up Sanity Live for Cache Components. `defineLive` returns `sanityFetch`\n * and `<SanityLive />`, which connect your Sanity client to the Live Content API\n * so cached pages can update in response to fine-grained content changes.\n *\n * With `strict: true`, `perspective` and `stega` become required\n * `sanityFetch` options, and `includeDrafts` becomes required on\n * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`\n * outside `'use cache'` boundaries, then pass them into cached components.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * // sanity/live.ts\n * import {cookies, draftMode} from 'next/headers'\n * import {createClient} from 'next-sanity'\n * import {\n *   defineLive,\n *   resolvePerspectiveFromCookies,\n *   resolveVariantFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n *   strict: true,\n * })\n *\n * export interface DynamicFetchOptions {\n *   perspective: LivePerspective\n *   variant?: string\n *   stega: boolean\n * }\n *\n * // Resolve dynamic values outside 'use cache' boundaries.\n * export async function getDynamicFetchOptions(): Promise<DynamicFetchOptions> {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (!isDraftMode) {\n *     return {perspective: 'published', stega: false}\n *   }\n *\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   const variant = await resolveVariantFromCookies({cookies: jar})\n *   return {perspective: perspective ?? 'drafts', variant, stega: true}\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {draftMode} from 'next/headers'\n *\n * import {SanityLive} from '@/sanity/live'\n *\n * export default async function RootLayout({children}: {children: React.ReactNode}) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive includeDrafts={isDraftMode} />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {draftMode} from 'next/headers'\n * import {Suspense} from 'react'\n * import {defineQuery} from 'next-sanity'\n *\n * import {\n *   getDynamicFetchOptions,\n *   sanityFetch,\n *   type DynamicFetchOptions,\n * } from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (isDraftMode) {\n *     return (\n *       <Suspense fallback={<div>Loading...</div>}>\n *         <DynamicPage params={props.params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await props.params\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage(props: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await props.params\n *   const {perspective, variant, stega} = await getDynamicFetchOptions()\n *\n *   return <CachedPage slug={slug} perspective={perspective} variant={variant} stega={stega} />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   variant,\n *   stega,\n * }: {slug: string} & DynamicFetchOptions) {\n *   'use cache'\n *\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *     perspective,\n *     variant,\n *     stega,\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict: true}): {\n  sanityFetch: StrictDefinedFetchType\n  SanityLive: React.ComponentType<StrictDefinedLiveProps>\n}\n/**\n * Set up Sanity Live. `defineLive` returns `sanityFetch` and `<SanityLive />`,\n * which connect your Sanity client to the Live Content API so pages can serve\n * cached content and update in response to fine-grained content changes.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * import {createClient} from 'next-sanity'\n * import {defineLive} from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n * })\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {SanityLive} from '@/sanity/live'\n *\n * export default function RootLayout({children}: {children: React.ReactNode}) {\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {defineQuery} from 'next-sanity'\n * import {sanityFetch} from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {slug} = await props.params\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict?: false}): {\n  sanityFetch: DefinedFetchType\n  SanityLive: React.ComponentType<DefinedLiveProps>\n}\nexport function defineLive(_config: DefineLiveOptions): never {\n  throw new Error(`defineLive can't be imported by a client component`)\n}\n\nexport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  LivePerspective,\n  SanityLiveAction,\n  SanityLiveContext,\n  SanityLiveOnError,\n  SanityLiveOnGoaway,\n  SanityLiveOnReconnect,\n  SanityLiveOnRestart,\n  SanityLiveOnWelcome,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\nexport {isCorsOriginError} from '#live/isCorsOriginError'\nexport {parseTags} from '#live/parseTags'\n\n/**\n * This helper is intended for use with Next.js Cache Components (`cacheComponents: true`),\n * where `cookies()` and `draftMode()` cannot be called inside `'use cache'` boundaries.\n * Resolve the perspective once outside the cache boundary and pass it in as a prop / cache key.\n *\n * @example\n * ```tsx\n * import {cookies, draftMode} from 'next/headers'\n * import {defineQuery} from 'next-sanity'\n * import {resolvePerspectiveFromCookies, type LivePerspective} from 'next-sanity/live'\n * import {sanityFetch, sanityFetchStaticParams} from '#sanity/live'\n *\n * export async function generateStaticParams() {\n *   const query = defineQuery(`*[_type == \"page\" && defined(slug.current)]{\"slug\": slug.current}`)\n *   return await sanityFetchStaticParams({query})\n * }\n *\n * export default async function Page({params}: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   if (isDraftMode) {\n *     return (\n *       <Suspense>\n *         <DynamicPage params={params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await params\n *\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage({params}: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await params\n *   const perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})\n *\n *   return <CachedPage slug={slug} perspective={perspective} stega />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   stega,\n * }: Awaited<PageProps<'/[slug]'>['params']> & {\n *   perspective: LivePerspective\n *   stega: boolean\n * }) {\n *   'use cache'\n *\n *   const query = defineQuery(`*[_type == \"page\" && slug.current == $slug][0]`)\n *   const {data} = await sanityFetch({query, params: {slug}, perspective, stega})\n *\n *   return <article>...</article>\n * }\n * ```\n *\n * @public\n */\nexport const resolvePerspectiveFromCookies: typeof _resolvePerspectiveFromCookies = () => {\n  throw new Error(`resolvePerspectiveFromCookies can't be imported by a client component`)\n}\n\n/**\n * This helper is intended for use with Next.js Cache Components (`cacheComponents: true`),\n * where `cookies()` and `draftMode()` cannot be called inside `'use cache'` boundaries.\n * Resolve the variant once outside the cache boundary and pass it in as a prop / cache key.\n *\n * Unlike `resolvePerspectiveFromCookies` there is no fallback value: when no\n * variant cookie is set (or its value is invalid) it resolves to `undefined`,\n * meaning \"no variant selected\" and queries return base content.\n *\n * @example\n * ```tsx\n * import {cookies, draftMode} from 'next/headers'\n * import {defineQuery} from 'next-sanity'\n * import {\n *   resolvePerspectiveFromCookies,\n *   resolveVariantFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n * import {sanityFetch} from '#sanity/live'\n *\n * export default async function Page({params}: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   if (isDraftMode) {\n *     return (\n *       <Suspense>\n *         <DynamicPage params={params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await params\n *\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage({params}: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await params\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   const variant = await resolveVariantFromCookies({cookies: jar})\n *\n *   return <CachedPage slug={slug} perspective={perspective} variant={variant} stega />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   variant,\n *   stega,\n * }: Awaited<PageProps<'/[slug]'>['params']> & {\n *   perspective: LivePerspective\n *   variant: string | undefined\n *   stega: boolean\n * }) {\n *   'use cache'\n *\n *   const query = defineQuery(`*[_type == \"page\" && slug.current == $slug][0]`)\n *   const {data} = await sanityFetch({query, params: {slug}, perspective, variant, stega})\n *\n *   return <article>...</article>\n * }\n * ```\n *\n * @public\n */\nexport const resolveVariantFromCookies: typeof _resolveVariantFromCookies = () => {\n  throw new Error(`resolveVariantFromCookies can't be imported by a client component`)\n}\n"],"mappings":";;AA6PA,SAAgB,WAAW,SAAmC;CAC5D,MAAM,IAAI,MAAM,oDAAoD;AACtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,MAAa,sCAA6E;CACxF,MAAM,IAAI,MAAM,uEAAuE;AACzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,MAAa,kCAAqE;CAChF,MAAM,IAAI,MAAM,mEAAmE;AACrF"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/live/conditions/default/index.ts"],"sourcesContent":["import type {resolvePerspectiveFromCookies as _resolvePerspectiveFromCookies} from '#live/resolvePerspectiveFromCookies'\nimport type {resolveVariantFromCookies as _resolveVariantFromCookies} from '#live/resolveVariantFromCookies'\nimport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\n/**\n * Set up Sanity Live for Cache Components. `defineLive` returns `sanityFetch`\n * and `<SanityLive />`, which connect your Sanity client to the Live Content API\n * so cached pages can update in response to fine-grained content changes.\n *\n * With `strict: true`, `perspective` and `stega` become required\n * `sanityFetch` options, and `includeDrafts` becomes required on\n * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`\n * outside `'use cache'` boundaries, then pass them into cached components.\n *\n * `sanityFetch` brands `data` with stega string types when `stega` is `true`,\n * a non-literal `boolean`, or omitted (react-server may auto-enable stega).\n * Pass the literal `stega: false` for clean TypeGen types. Use `stegaClean`\n * before comparing branded strings to literals.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * // sanity/live.ts\n * import {cookies, draftMode} from 'next/headers'\n * import {createClient} from 'next-sanity'\n * import {\n *   defineLive,\n *   resolvePerspectiveFromCookies,\n *   resolveVariantFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n *   strict: true,\n * })\n *\n * export interface DynamicFetchOptions {\n *   perspective: LivePerspective\n *   variant?: string\n *   // `boolean` brands `sanityFetch` `data`; use literal `false` for clean types\n *   stega: boolean\n * }\n *\n * // Resolve dynamic values outside 'use cache' boundaries.\n * export async function getDynamicFetchOptions(): Promise<DynamicFetchOptions> {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (!isDraftMode) {\n *     return {perspective: 'published', stega: false}\n *   }\n *\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   const variant = await resolveVariantFromCookies({cookies: jar})\n *   return {perspective: perspective ?? 'drafts', variant, stega: true}\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {draftMode} from 'next/headers'\n *\n * import {SanityLive} from '@/sanity/live'\n *\n * export default async function RootLayout({children}: {children: React.ReactNode}) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive includeDrafts={isDraftMode} />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {draftMode} from 'next/headers'\n * import {Suspense} from 'react'\n * import {defineQuery} from 'next-sanity'\n *\n * import {\n *   getDynamicFetchOptions,\n *   sanityFetch,\n *   type DynamicFetchOptions,\n * } from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (isDraftMode) {\n *     return (\n *       <Suspense fallback={<div>Loading...</div>}>\n *         <DynamicPage params={props.params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await props.params\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage(props: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await props.params\n *   const {perspective, variant, stega} = await getDynamicFetchOptions()\n *\n *   return <CachedPage slug={slug} perspective={perspective} variant={variant} stega={stega} />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   variant,\n *   stega,\n * }: {slug: string} & DynamicFetchOptions) {\n *   'use cache'\n *\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *     perspective,\n *     variant,\n *     stega,\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict: true}): {\n  sanityFetch: StrictDefinedFetchType\n  SanityLive: React.ComponentType<StrictDefinedLiveProps>\n}\n/**\n * Set up Sanity Live. `defineLive` returns `sanityFetch` and `<SanityLive />`,\n * which connect your Sanity client to the Live Content API so pages can serve\n * cached content and update in response to fine-grained content changes.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * import {createClient} from 'next-sanity'\n * import {defineLive} from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n * })\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {SanityLive} from '@/sanity/live'\n *\n * export default function RootLayout({children}: {children: React.ReactNode}) {\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {defineQuery} from 'next-sanity'\n * import {sanityFetch} from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {slug} = await props.params\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict?: false}): {\n  sanityFetch: DefinedFetchType\n  SanityLive: React.ComponentType<DefinedLiveProps>\n}\nexport function defineLive(_config: DefineLiveOptions): never {\n  throw new Error(`defineLive can't be imported by a client component`)\n}\n\nexport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  LivePerspective,\n  SanityLiveAction,\n  SanityLiveContext,\n  SanityLiveOnError,\n  SanityLiveOnGoaway,\n  SanityLiveOnReconnect,\n  SanityLiveOnRestart,\n  SanityLiveOnWelcome,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\nexport {isCorsOriginError} from '#live/isCorsOriginError'\nexport {parseTags} from '#live/parseTags'\n\n/**\n * This helper is intended for use with Next.js Cache Components (`cacheComponents: true`),\n * where `cookies()` and `draftMode()` cannot be called inside `'use cache'` boundaries.\n * Resolve the perspective once outside the cache boundary and pass it in as a prop / cache key.\n *\n * @example\n * ```tsx\n * import {cookies, draftMode} from 'next/headers'\n * import {defineQuery} from 'next-sanity'\n * import {resolvePerspectiveFromCookies, type LivePerspective} from 'next-sanity/live'\n * import {sanityFetch, sanityFetchStaticParams} from '#sanity/live'\n *\n * export async function generateStaticParams() {\n *   const query = defineQuery(`*[_type == \"page\" && defined(slug.current)]{\"slug\": slug.current}`)\n *   return await sanityFetchStaticParams({query})\n * }\n *\n * export default async function Page({params}: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   if (isDraftMode) {\n *     return (\n *       <Suspense>\n *         <DynamicPage params={params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await params\n *\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage({params}: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await params\n *   const perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})\n *\n *   return <CachedPage slug={slug} perspective={perspective} stega />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   stega,\n * }: Awaited<PageProps<'/[slug]'>['params']> & {\n *   perspective: LivePerspective\n *   stega: boolean\n * }) {\n *   'use cache'\n *\n *   const query = defineQuery(`*[_type == \"page\" && slug.current == $slug][0]`)\n *   const {data} = await sanityFetch({query, params: {slug}, perspective, stega})\n *\n *   return <article>...</article>\n * }\n * ```\n *\n * @public\n */\nexport const resolvePerspectiveFromCookies: typeof _resolvePerspectiveFromCookies = () => {\n  throw new Error(`resolvePerspectiveFromCookies can't be imported by a client component`)\n}\n\n/**\n * This helper is intended for use with Next.js Cache Components (`cacheComponents: true`),\n * where `cookies()` and `draftMode()` cannot be called inside `'use cache'` boundaries.\n * Resolve the variant once outside the cache boundary and pass it in as a prop / cache key.\n *\n * Unlike `resolvePerspectiveFromCookies` there is no fallback value: when no\n * variant cookie is set (or its value is invalid) it resolves to `undefined`,\n * meaning \"no variant selected\" and queries return base content.\n *\n * @example\n * ```tsx\n * import {cookies, draftMode} from 'next/headers'\n * import {defineQuery} from 'next-sanity'\n * import {\n *   resolvePerspectiveFromCookies,\n *   resolveVariantFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n * import {sanityFetch} from '#sanity/live'\n *\n * export default async function Page({params}: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   if (isDraftMode) {\n *     return (\n *       <Suspense>\n *         <DynamicPage params={params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await params\n *\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage({params}: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await params\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   const variant = await resolveVariantFromCookies({cookies: jar})\n *\n *   return <CachedPage slug={slug} perspective={perspective} variant={variant} stega />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   variant,\n *   stega,\n * }: Awaited<PageProps<'/[slug]'>['params']> & {\n *   perspective: LivePerspective\n *   variant: string | undefined\n *   stega: boolean\n * }) {\n *   'use cache'\n *\n *   const query = defineQuery(`*[_type == \"page\" && slug.current == $slug][0]`)\n *   const {data} = await sanityFetch({query, params: {slug}, perspective, variant, stega})\n *\n *   return <article>...</article>\n * }\n * ```\n *\n * @public\n */\nexport const resolveVariantFromCookies: typeof _resolveVariantFromCookies = () => {\n  throw new Error(`resolveVariantFromCookies can't be imported by a client component`)\n}\n"],"mappings":";;AAmQA,SAAgB,WAAW,SAAmC;CAC5D,MAAM,IAAI,MAAM,oDAAoD;AACtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,MAAa,sCAA6E;CACxF,MAAM,IAAI,MAAM,uEAAuE;AACzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,MAAa,kCAAqE;CAChF,MAAM,IAAI,MAAM,mEAAmE;AACrF"}

package/dist/live/conditions/next-js/index.d.ts

@@ -11,6 +11,11 @@ import { n as resolveVariantFromCookies, r as resolvePerspectiveFromCookies, t a
  * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`
  * outside `'use cache'` boundaries, then pass them into cached components.
  *
+ * `sanityFetch` brands `data` with stega string types when `stega` is `true`,
+ * a non-literal `boolean`, or omitted (react-server may auto-enable stega).
+ * Pass the literal `stega: false` for clean TypeGen types. Use `stegaClean`
+ * before comparing branded strings to literals.
+ *
  * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)
  * @see [Sanity Live](https://www.sanity.io/live)
  *
@@ -44,6 +49,7 @@ import { n as resolveVariantFromCookies, r as resolvePerspectiveFromCookies, t a
  * export interface DynamicFetchOptions {
  *   perspective: LivePerspective
  *   variant?: string
+ *   // `boolean` brands `sanityFetch` `data`; use literal `false` for clean types
  *   stega: boolean
  * }
  *

package/dist/live/conditions/next-js/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/live/conditions/next-js/defineLive.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2KgB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFlB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/live/conditions/next-js/defineLive.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiLgB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFlB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc"}

package/dist/live/conditions/next-js/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["sanityCacheLife","SanityLive","SanityLiveClientComponent"],"sources":["../../../../src/live/conditions/next-js/defineLive.tsx"],"sourcesContent":["import {sanity as sanityCacheLife} from 'next-sanity/live/cache-life'\nimport {SanityLive as SanityLiveClientComponent} from 'next-sanity/live/client-components'\nimport {revalidateSyncTagsAction} from 'next-sanity/live/server-actions'\nimport {cacheLife, cacheTag} from 'next/cache'\nimport {PHASE_PRODUCTION_BUILD} from 'next/constants'\n\nimport {cacheTagPrefix, defaultApiHost} from '#live/constants'\nimport {preconnect} from '#live/preconnect'\nimport {validateStrictFetchOptions, validateStrictSanityLiveProps} from '#live/strictValidation'\nimport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\n/**\n * Set up Sanity Live for Cache Components. `defineLive` returns `sanityFetch`\n * and `<SanityLive />`, which connect your Sanity client to the Live Content API\n * so cached pages can update in response to fine-grained content changes.\n *\n * With `strict: true`, `perspective` and `stega` become required\n * `sanityFetch` options, and `includeDrafts` becomes required on\n * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`\n * outside `'use cache'` boundaries, then pass them into cached components.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * // sanity/live.ts\n * import {cookies, draftMode} from 'next/headers'\n * import {createClient} from 'next-sanity'\n * import {\n *   defineLive,\n *   resolvePerspectiveFromCookies,\n *   resolveVariantFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n *   strict: true,\n * })\n *\n * export interface DynamicFetchOptions {\n *   perspective: LivePerspective\n *   variant?: string\n *   stega: boolean\n * }\n *\n * // Resolve dynamic values outside 'use cache' boundaries.\n * export async function getDynamicFetchOptions(): Promise<DynamicFetchOptions> {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (!isDraftMode) {\n *     return {perspective: 'published', stega: false}\n *   }\n *\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   const variant = await resolveVariantFromCookies({cookies: jar})\n *   return {perspective: perspective ?? 'drafts', variant, stega: true}\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {draftMode} from 'next/headers'\n *\n * import {SanityLive} from '@/sanity/live'\n *\n * export default async function RootLayout({children}: {children: React.ReactNode}) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive includeDrafts={isDraftMode} />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {draftMode} from 'next/headers'\n * import {Suspense} from 'react'\n * import {defineQuery} from 'next-sanity'\n *\n * import {\n *   getDynamicFetchOptions,\n *   sanityFetch,\n *   type DynamicFetchOptions,\n * } from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (isDraftMode) {\n *     return (\n *       <Suspense fallback={<div>Loading...</div>}>\n *         <DynamicPage params={props.params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await props.params\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage(props: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await props.params\n *   const {perspective, variant, stega} = await getDynamicFetchOptions()\n *\n *   return <CachedPage slug={slug} perspective={perspective} variant={variant} stega={stega} />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   variant,\n *   stega,\n * }: {slug: string} & DynamicFetchOptions) {\n *   'use cache'\n *\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *     perspective,\n *     variant,\n *     stega,\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict: true}): {\n  sanityFetch: StrictDefinedFetchType\n  SanityLive: React.ComponentType<StrictDefinedLiveProps>\n}\n/**\n * Set up Sanity Live. `defineLive` returns `sanityFetch` and `<SanityLive />`,\n * which connect your Sanity client to the Live Content API so pages can serve\n * cached content and update in response to fine-grained content changes.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * import {createClient} from 'next-sanity'\n * import {defineLive} from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n * })\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {SanityLive} from '@/sanity/live'\n *\n * export default function RootLayout({children}: {children: React.ReactNode}) {\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {defineQuery} from 'next-sanity'\n * import {sanityFetch} from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {slug} = await props.params\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict?: false}): {\n  sanityFetch: DefinedFetchType\n  SanityLive: React.ComponentType<DefinedLiveProps>\n}\nexport function defineLive(config: DefineLiveOptions) {\n  const {client: _client, serverToken, browserToken, strict = false} = config\n\n  if (!_client) {\n    throw new Error('`client` is required for `defineLive` to function')\n  }\n\n  if (process.env.NODE_ENV === 'development' && !serverToken && serverToken !== false) {\n    console.warn(\n      'No `serverToken` provided to `defineLive`. This means that only published content will be fetched and respond to live events. You can silence this warning by setting `serverToken: false`.',\n    )\n  }\n\n  if (process.env.NODE_ENV === 'development' && !browserToken && browserToken !== false) {\n    console.warn(\n      'No `browserToken` provided to `defineLive`. This means that live previewing drafts will only work when using the Presentation Tool in your Sanity Studio. To support live previewing drafts stand-alone, provide a `browserToken`. It is shared with the browser so it should only have Viewer rights or lower. You can silence this warning by setting `browserToken: false`.',\n    )\n  }\n\n  const client = _client.withConfig({\n    allowReconfigure: false,\n    useCdn: true,\n    perspective: 'published',\n    stega: false,\n  })\n\n  const sanityFetch: DefinedFetchType = async function sanityFetch({\n    query,\n    params = {},\n    perspective,\n    variant,\n    stega,\n    tags: customCacheTags = [],\n    requestTag = 'next-loader.fetch.cache-components',\n  }) {\n    if (strict) {\n      validateStrictFetchOptions({perspective, stega})\n    }\n\n    const useCdn = perspective ? perspective === 'published' : undefined\n    const isBuildPhase = process.env['NEXT_PHASE'] === PHASE_PRODUCTION_BUILD\n    const cacheMode = useCdn !== false && !isBuildPhase ? 'noStale' : undefined\n    const token =\n      ((perspective && perspective !== 'published') || stega) && serverToken\n        ? serverToken\n        : undefined\n\n    const {result, resultSourceMap, syncTags} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective,\n      variant,\n      stega,\n      returnQuery: false,\n      useCdn,\n      cacheMode,\n      tag: requestTag,\n      token,\n    })\n    const tags = [...customCacheTags, ...(syncTags || []).map((tag) => `${cacheTagPrefix}${tag}`)]\n    /**\n     * The tags used here, are expired later on in the `action` Server Action given to `<SanityLive />` with the `revalidateTag` function from `next/cache`,\n     * or by a route handler that userland sets up.\n     */\n    cacheTag(...tags)\n    /**\n     * Sanity Live handles on-demand revalidation, so the default 15min time-based revalidation is too short,\n     * userland can still set a shorter revalidate time by calling `cacheLife` themselves.\n     */\n    cacheLife(sanityCacheLife)\n\n    return {data: result, sourceMap: resultSourceMap || null, tags}\n  }\n\n  const SanityLive: React.ComponentType<DefinedLiveProps> = function SanityLive(props) {\n    if (strict) {\n      validateStrictSanityLiveProps(props)\n    }\n    const {\n      includeDrafts: _includeDrafts = false,\n      requestTag = 'next-loader.live.cache-components',\n      waitFor,\n\n      action,\n      onError,\n      onWelcome,\n      onReconnect,\n      onRestart,\n      onGoAway,\n    } = props\n    const {projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix} =\n      client.config()\n\n    const includeDrafts = typeof browserToken === 'string' && !!browserToken && _includeDrafts\n    const shouldWaitFor = waitFor === 'function' && !includeDrafts ? waitFor : undefined\n\n    // Preconnect to the Live Event API origin early, as the Sanity API is almost always on a different origin than the app\n    preconnect(client)\n\n    return (\n      <SanityLiveClientComponent\n        config={{\n          projectId,\n          dataset,\n          apiHost: apiHost === defaultApiHost ? undefined : apiHost,\n          apiVersion,\n          useProjectHostname: useProjectHostname ? undefined : useProjectHostname,\n          requestTagPrefix,\n          token: includeDrafts ? browserToken : undefined,\n        }}\n        includeDrafts={includeDrafts ? true : undefined}\n        requestTag={requestTag}\n        waitFor={shouldWaitFor}\n        action={\n          action ??\n          (shouldWaitFor === 'function' || includeDrafts ? 'refresh' : revalidateSyncTagsAction)\n        }\n        onError={onError}\n        onWelcome={onWelcome}\n        onReconnect={onReconnect}\n        onRestart={onRestart}\n        onGoAway={onGoAway}\n      />\n    )\n  }\n  SanityLive.displayName = 'SanityLiveServerComponent'\n\n  return {sanityFetch, SanityLive}\n}\n"],"mappings":";;;;;;;;;;AAoQA,SAAgB,WAAW,QAA2B;CACpD,MAAM,EAAC,QAAQ,SAAS,aAAa,cAAc,SAAS,UAAS;CAErE,IAAI,CAAC,SACH,MAAM,IAAI,MAAM,mDAAmD;CAGrE,IAAI,QAAQ,IAAI,aAAa,iBAAiB,CAAC,eAAe,gBAAgB,OAC5E,QAAQ,KACN,6LACF;CAGF,IAAI,QAAQ,IAAI,aAAa,iBAAiB,CAAC,gBAAgB,iBAAiB,OAC9E,QAAQ,KACN,gXACF;CAGF,MAAM,SAAS,QAAQ,WAAW;EAChC,kBAAkB;EAClB,QAAQ;EACR,aAAa;EACb,OAAO;CACT,CAAC;CAED,MAAM,cAAgC,eAAe,YAAY,EAC/D,OACA,SAAS,CAAC,GACV,aACA,SACA,OACA,MAAM,kBAAkB,CAAC,GACzB,aAAa,wCACZ;EACD,IAAI,QACF,2BAA2B;GAAC;GAAa;EAAK,CAAC;EAGjD,MAAM,SAAS,cAAc,gBAAgB,cAAc,KAAA;EAC3D,MAAM,eAAe,QAAQ,IAAI,kBAAkB;EACnD,MAAM,YAAY,WAAW,SAAS,CAAC,eAAe,YAAY,KAAA;EAClE,MAAM,SACF,eAAe,gBAAgB,eAAgB,UAAU,cACvD,cACA,KAAA;EAEN,MAAM,EAAC,QAAQ,iBAAiB,aAAY,MAAM,OAAO,MAAM,OAAO,MAAM,QAAQ;GAClF,gBAAgB;GAChB;GACA;GACA;GACA,aAAa;GACb;GACA;GACA,KAAK;GACL;EACF,CAAC;EACD,MAAM,OAAO,CAAC,GAAG,iBAAiB,IAAI,YAAY,CAAC,EAAA,CAAG,KAAK,QAAQ,GAAG,iBAAiB,KAAK,CAAC;;;;;EAK7F,SAAS,GAAG,IAAI;;;;;EAKhB,UAAUA,MAAe;EAEzB,OAAO;GAAC,MAAM;GAAQ,WAAW,mBAAmB;GAAM;EAAI;CAChE;CAEA,MAAMC,eAAoD,SAASA,aAAW,OAAO;EACnF,IAAI,QACF,8BAA8B,KAAK;EAErC,MAAM,EACJ,eAAe,iBAAiB,OAChC,aAAa,qCACb,SAEA,QACA,SACA,WACA,aACA,WACA,aACE;EACJ,MAAM,EAAC,WAAW,SAAS,SAAS,YAAY,oBAAoB,qBAClE,OAAO,OAAO;EAEhB,MAAM,gBAAgB,OAAO,iBAAiB,YAAY,CAAC,CAAC,gBAAgB;EAC5E,MAAM,gBAAgB,YAAY,cAAc,CAAC,gBAAgB,UAAU,KAAA;EAG3E,WAAW,MAAM;EAEjB,OACE,oBAACC,YAAD;GACE,QAAQ;IACN;IACA;IACA,SAAS,YAAA,0BAA6B,KAAA,IAAY;IAClD;IACA,oBAAoB,qBAAqB,KAAA,IAAY;IACrD;IACA,OAAO,gBAAgB,eAAe,KAAA;GACxC;GACA,eAAe,gBAAgB,OAAO,KAAA;GAC1B;GACZ,SAAS;GACT,QACE,WACC,kBAAkB,cAAc,gBAAgB,YAAY;GAEtD;GACE;GACE;GACF;GACD;EACX,CAAA;CAEL;CACA,aAAW,cAAc;CAEzB,OAAO;EAAC;EAAa,YAAA;CAAU;AACjC"}
+{"version":3,"file":"index.js","names":["sanityCacheLife","SanityLive","SanityLiveClientComponent"],"sources":["../../../../src/live/conditions/next-js/defineLive.tsx"],"sourcesContent":["import {sanity as sanityCacheLife} from 'next-sanity/live/cache-life'\nimport {SanityLive as SanityLiveClientComponent} from 'next-sanity/live/client-components'\nimport {revalidateSyncTagsAction} from 'next-sanity/live/server-actions'\nimport {cacheLife, cacheTag} from 'next/cache'\nimport {PHASE_PRODUCTION_BUILD} from 'next/constants'\n\nimport {cacheTagPrefix, defaultApiHost} from '#live/constants'\nimport {preconnect} from '#live/preconnect'\nimport {validateStrictFetchOptions, validateStrictSanityLiveProps} from '#live/strictValidation'\nimport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\n/**\n * Set up Sanity Live for Cache Components. `defineLive` returns `sanityFetch`\n * and `<SanityLive />`, which connect your Sanity client to the Live Content API\n * so cached pages can update in response to fine-grained content changes.\n *\n * With `strict: true`, `perspective` and `stega` become required\n * `sanityFetch` options, and `includeDrafts` becomes required on\n * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`\n * outside `'use cache'` boundaries, then pass them into cached components.\n *\n * `sanityFetch` brands `data` with stega string types when `stega` is `true`,\n * a non-literal `boolean`, or omitted (react-server may auto-enable stega).\n * Pass the literal `stega: false` for clean TypeGen types. Use `stegaClean`\n * before comparing branded strings to literals.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * // sanity/live.ts\n * import {cookies, draftMode} from 'next/headers'\n * import {createClient} from 'next-sanity'\n * import {\n *   defineLive,\n *   resolvePerspectiveFromCookies,\n *   resolveVariantFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n *   strict: true,\n * })\n *\n * export interface DynamicFetchOptions {\n *   perspective: LivePerspective\n *   variant?: string\n *   // `boolean` brands `sanityFetch` `data`; use literal `false` for clean types\n *   stega: boolean\n * }\n *\n * // Resolve dynamic values outside 'use cache' boundaries.\n * export async function getDynamicFetchOptions(): Promise<DynamicFetchOptions> {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (!isDraftMode) {\n *     return {perspective: 'published', stega: false}\n *   }\n *\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   const variant = await resolveVariantFromCookies({cookies: jar})\n *   return {perspective: perspective ?? 'drafts', variant, stega: true}\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {draftMode} from 'next/headers'\n *\n * import {SanityLive} from '@/sanity/live'\n *\n * export default async function RootLayout({children}: {children: React.ReactNode}) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive includeDrafts={isDraftMode} />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {draftMode} from 'next/headers'\n * import {Suspense} from 'react'\n * import {defineQuery} from 'next-sanity'\n *\n * import {\n *   getDynamicFetchOptions,\n *   sanityFetch,\n *   type DynamicFetchOptions,\n * } from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (isDraftMode) {\n *     return (\n *       <Suspense fallback={<div>Loading...</div>}>\n *         <DynamicPage params={props.params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await props.params\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage(props: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await props.params\n *   const {perspective, variant, stega} = await getDynamicFetchOptions()\n *\n *   return <CachedPage slug={slug} perspective={perspective} variant={variant} stega={stega} />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   variant,\n *   stega,\n * }: {slug: string} & DynamicFetchOptions) {\n *   'use cache'\n *\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *     perspective,\n *     variant,\n *     stega,\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict: true}): {\n  sanityFetch: StrictDefinedFetchType\n  SanityLive: React.ComponentType<StrictDefinedLiveProps>\n}\n/**\n * Set up Sanity Live. `defineLive` returns `sanityFetch` and `<SanityLive />`,\n * which connect your Sanity client to the Live Content API so pages can serve\n * cached content and update in response to fine-grained content changes.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * import {createClient} from 'next-sanity'\n * import {defineLive} from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n * })\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {SanityLive} from '@/sanity/live'\n *\n * export default function RootLayout({children}: {children: React.ReactNode}) {\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {defineQuery} from 'next-sanity'\n * import {sanityFetch} from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {slug} = await props.params\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict?: false}): {\n  sanityFetch: DefinedFetchType\n  SanityLive: React.ComponentType<DefinedLiveProps>\n}\nexport function defineLive(config: DefineLiveOptions) {\n  const {client: _client, serverToken, browserToken, strict = false} = config\n\n  if (!_client) {\n    throw new Error('`client` is required for `defineLive` to function')\n  }\n\n  if (process.env.NODE_ENV === 'development' && !serverToken && serverToken !== false) {\n    console.warn(\n      'No `serverToken` provided to `defineLive`. This means that only published content will be fetched and respond to live events. You can silence this warning by setting `serverToken: false`.',\n    )\n  }\n\n  if (process.env.NODE_ENV === 'development' && !browserToken && browserToken !== false) {\n    console.warn(\n      'No `browserToken` provided to `defineLive`. This means that live previewing drafts will only work when using the Presentation Tool in your Sanity Studio. To support live previewing drafts stand-alone, provide a `browserToken`. It is shared with the browser so it should only have Viewer rights or lower. You can silence this warning by setting `browserToken: false`.',\n    )\n  }\n\n  const client = _client.withConfig({\n    allowReconfigure: false,\n    useCdn: true,\n    perspective: 'published',\n    stega: false,\n  })\n\n  const sanityFetch: DefinedFetchType = async function sanityFetch({\n    query,\n    params = {},\n    perspective,\n    variant,\n    stega,\n    tags: customCacheTags = [],\n    requestTag = 'next-loader.fetch.cache-components',\n  }) {\n    if (strict) {\n      validateStrictFetchOptions({perspective, stega})\n    }\n\n    const useCdn = perspective ? perspective === 'published' : undefined\n    const isBuildPhase = process.env['NEXT_PHASE'] === PHASE_PRODUCTION_BUILD\n    const cacheMode = useCdn !== false && !isBuildPhase ? 'noStale' : undefined\n    const token =\n      ((perspective && perspective !== 'published') || stega) && serverToken\n        ? serverToken\n        : undefined\n\n    const {result, resultSourceMap, syncTags} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective,\n      variant,\n      stega,\n      returnQuery: false,\n      useCdn,\n      cacheMode,\n      tag: requestTag,\n      token,\n    })\n    const tags = [...customCacheTags, ...(syncTags || []).map((tag) => `${cacheTagPrefix}${tag}`)]\n    /**\n     * The tags used here, are expired later on in the `action` Server Action given to `<SanityLive />` with the `revalidateTag` function from `next/cache`,\n     * or by a route handler that userland sets up.\n     */\n    cacheTag(...tags)\n    /**\n     * Sanity Live handles on-demand revalidation, so the default 15min time-based revalidation is too short,\n     * userland can still set a shorter revalidate time by calling `cacheLife` themselves.\n     */\n    cacheLife(sanityCacheLife)\n\n    return {data: result, sourceMap: resultSourceMap || null, tags}\n  }\n\n  const SanityLive: React.ComponentType<DefinedLiveProps> = function SanityLive(props) {\n    if (strict) {\n      validateStrictSanityLiveProps(props)\n    }\n    const {\n      includeDrafts: _includeDrafts = false,\n      requestTag = 'next-loader.live.cache-components',\n      waitFor,\n\n      action,\n      onError,\n      onWelcome,\n      onReconnect,\n      onRestart,\n      onGoAway,\n    } = props\n    const {projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix} =\n      client.config()\n\n    const includeDrafts = typeof browserToken === 'string' && !!browserToken && _includeDrafts\n    const shouldWaitFor = waitFor === 'function' && !includeDrafts ? waitFor : undefined\n\n    // Preconnect to the Live Event API origin early, as the Sanity API is almost always on a different origin than the app\n    preconnect(client)\n\n    return (\n      <SanityLiveClientComponent\n        config={{\n          projectId,\n          dataset,\n          apiHost: apiHost === defaultApiHost ? undefined : apiHost,\n          apiVersion,\n          useProjectHostname: useProjectHostname ? undefined : useProjectHostname,\n          requestTagPrefix,\n          token: includeDrafts ? browserToken : undefined,\n        }}\n        includeDrafts={includeDrafts ? true : undefined}\n        requestTag={requestTag}\n        waitFor={shouldWaitFor}\n        action={\n          action ??\n          (shouldWaitFor === 'function' || includeDrafts ? 'refresh' : revalidateSyncTagsAction)\n        }\n        onError={onError}\n        onWelcome={onWelcome}\n        onReconnect={onReconnect}\n        onRestart={onRestart}\n        onGoAway={onGoAway}\n      />\n    )\n  }\n  SanityLive.displayName = 'SanityLiveServerComponent'\n\n  return {sanityFetch, SanityLive}\n}\n"],"mappings":";;;;;;;;;;AA0QA,SAAgB,WAAW,QAA2B;CACpD,MAAM,EAAC,QAAQ,SAAS,aAAa,cAAc,SAAS,UAAS;CAErE,IAAI,CAAC,SACH,MAAM,IAAI,MAAM,mDAAmD;CAGrE,IAAI,QAAQ,IAAI,aAAa,iBAAiB,CAAC,eAAe,gBAAgB,OAC5E,QAAQ,KACN,6LACF;CAGF,IAAI,QAAQ,IAAI,aAAa,iBAAiB,CAAC,gBAAgB,iBAAiB,OAC9E,QAAQ,KACN,gXACF;CAGF,MAAM,SAAS,QAAQ,WAAW;EAChC,kBAAkB;EAClB,QAAQ;EACR,aAAa;EACb,OAAO;CACT,CAAC;CAED,MAAM,cAAgC,eAAe,YAAY,EAC/D,OACA,SAAS,CAAC,GACV,aACA,SACA,OACA,MAAM,kBAAkB,CAAC,GACzB,aAAa,wCACZ;EACD,IAAI,QACF,2BAA2B;GAAC;GAAa;EAAK,CAAC;EAGjD,MAAM,SAAS,cAAc,gBAAgB,cAAc,KAAA;EAC3D,MAAM,eAAe,QAAQ,IAAI,kBAAkB;EACnD,MAAM,YAAY,WAAW,SAAS,CAAC,eAAe,YAAY,KAAA;EAClE,MAAM,SACF,eAAe,gBAAgB,eAAgB,UAAU,cACvD,cACA,KAAA;EAEN,MAAM,EAAC,QAAQ,iBAAiB,aAAY,MAAM,OAAO,MAAM,OAAO,MAAM,QAAQ;GAClF,gBAAgB;GAChB;GACA;GACA;GACA,aAAa;GACb;GACA;GACA,KAAK;GACL;EACF,CAAC;EACD,MAAM,OAAO,CAAC,GAAG,iBAAiB,IAAI,YAAY,CAAC,EAAA,CAAG,KAAK,QAAQ,GAAG,iBAAiB,KAAK,CAAC;;;;;EAK7F,SAAS,GAAG,IAAI;;;;;EAKhB,UAAUA,MAAe;EAEzB,OAAO;GAAC,MAAM;GAAQ,WAAW,mBAAmB;GAAM;EAAI;CAChE;CAEA,MAAMC,eAAoD,SAASA,aAAW,OAAO;EACnF,IAAI,QACF,8BAA8B,KAAK;EAErC,MAAM,EACJ,eAAe,iBAAiB,OAChC,aAAa,qCACb,SAEA,QACA,SACA,WACA,aACA,WACA,aACE;EACJ,MAAM,EAAC,WAAW,SAAS,SAAS,YAAY,oBAAoB,qBAClE,OAAO,OAAO;EAEhB,MAAM,gBAAgB,OAAO,iBAAiB,YAAY,CAAC,CAAC,gBAAgB;EAC5E,MAAM,gBAAgB,YAAY,cAAc,CAAC,gBAAgB,UAAU,KAAA;EAG3E,WAAW,MAAM;EAEjB,OACE,oBAACC,YAAD;GACE,QAAQ;IACN;IACA;IACA,SAAS,YAAA,0BAA6B,KAAA,IAAY;IAClD;IACA,oBAAoB,qBAAqB,KAAA,IAAY;IACrD;IACA,OAAO,gBAAgB,eAAe,KAAA;GACxC;GACA,eAAe,gBAAgB,OAAO,KAAA;GAC1B;GACZ,SAAS;GACT,QACE,WACC,kBAAkB,cAAc,gBAAgB,YAAY;GAEtD;GACE;GACE;GACF;GACD;EACX,CAAA;CAEL;CACA,aAAW,cAAc;CAEzB,OAAO;EAAC;EAAa,YAAA;CAAU;AACjC"}

package/dist/live/conditions/react-server/index.d.ts

@@ -11,6 +11,11 @@ import { n as resolveVariantFromCookies, r as resolvePerspectiveFromCookies, t a
  * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`
  * outside `'use cache'` boundaries, then pass them into cached components.
  *
+ * `sanityFetch` brands `data` with stega string types when `stega` is `true`,
+ * a non-literal `boolean`, or omitted (react-server may auto-enable stega).
+ * Pass the literal `stega: false` for clean TypeGen types. Use `stegaClean`
+ * before comparing branded strings to literals.
+ *
  * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)
  * @see [Sanity Live](https://www.sanity.io/live)
  *
@@ -44,6 +49,7 @@ import { n as resolveVariantFromCookies, r as resolvePerspectiveFromCookies, t a
  * export interface DynamicFetchOptions {
  *   perspective: LivePerspective
  *   variant?: string
+ *   // `boolean` brands `sanityFetch` `data`; use literal `false` for clean types
  *   stega: boolean
  * }
  *

package/dist/live/conditions/react-server/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/live/conditions/react-server/defineLive.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6KgB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFlB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/live/conditions/react-server/defineLive.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmLgB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFlB,WAAW,QAAQ;EAAqB;;EACtD,aAAa;EACb,YAAY,MAAM,cAAc"}

package/dist/live/conditions/react-server/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["SanityLive","SanityLiveClientComponent"],"sources":["../../../../src/live/conditions/react-server/defineLive.tsx"],"sourcesContent":["import {SanityLive as SanityLiveClientComponent} from 'next-sanity/live/client-components'\nimport {revalidateSyncTagsAction} from 'next-sanity/live/server-actions'\nimport {PHASE_PRODUCTION_BUILD} from 'next/constants'\nimport {cookies, draftMode} from 'next/headers'\n\nimport {cacheTagPrefix, defaultApiHost} from '#live/constants'\nimport {preconnect} from '#live/preconnect'\nimport {resolvePerspectiveFromCookies} from '#live/resolvePerspectiveFromCookies'\nimport {resolveVariantFromCookies} from '#live/resolveVariantFromCookies'\nimport {validateStrictFetchOptions, validateStrictSanityLiveProps} from '#live/strictValidation'\nimport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  LivePerspective,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\n/**\n * Set up Sanity Live for Cache Components. `defineLive` returns `sanityFetch`\n * and `<SanityLive />`, which connect your Sanity client to the Live Content API\n * so cached pages can update in response to fine-grained content changes.\n *\n * With `strict: true`, `perspective` and `stega` become required\n * `sanityFetch` options, and `includeDrafts` becomes required on\n * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`\n * outside `'use cache'` boundaries, then pass them into cached components.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * // sanity/live.ts\n * import {cookies, draftMode} from 'next/headers'\n * import {createClient} from 'next-sanity'\n * import {\n *   defineLive,\n *   resolvePerspectiveFromCookies,\n *   resolveVariantFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n *   strict: true,\n * })\n *\n * export interface DynamicFetchOptions {\n *   perspective: LivePerspective\n *   variant?: string\n *   stega: boolean\n * }\n *\n * // Resolve dynamic values outside 'use cache' boundaries.\n * export async function getDynamicFetchOptions(): Promise<DynamicFetchOptions> {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (!isDraftMode) {\n *     return {perspective: 'published', stega: false}\n *   }\n *\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   const variant = await resolveVariantFromCookies({cookies: jar})\n *   return {perspective: perspective ?? 'drafts', variant, stega: true}\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {draftMode} from 'next/headers'\n *\n * import {SanityLive} from '@/sanity/live'\n *\n * export default async function RootLayout({children}: {children: React.ReactNode}) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive includeDrafts={isDraftMode} />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {draftMode} from 'next/headers'\n * import {Suspense} from 'react'\n * import {defineQuery} from 'next-sanity'\n *\n * import {\n *   getDynamicFetchOptions,\n *   sanityFetch,\n *   type DynamicFetchOptions,\n * } from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (isDraftMode) {\n *     return (\n *       <Suspense fallback={<div>Loading...</div>}>\n *         <DynamicPage params={props.params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await props.params\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage(props: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await props.params\n *   const {perspective, variant, stega} = await getDynamicFetchOptions()\n *\n *   return <CachedPage slug={slug} perspective={perspective} variant={variant} stega={stega} />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   variant,\n *   stega,\n * }: {slug: string} & DynamicFetchOptions) {\n *   'use cache'\n *\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *     perspective,\n *     variant,\n *     stega,\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict: true}): {\n  sanityFetch: StrictDefinedFetchType\n  SanityLive: React.ComponentType<StrictDefinedLiveProps>\n}\n/**\n * Set up Sanity Live. `defineLive` returns `sanityFetch` and `<SanityLive />`,\n * which connect your Sanity client to the Live Content API so pages can serve\n * cached content and update in response to fine-grained content changes.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * import {createClient} from 'next-sanity'\n * import {defineLive} from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n * })\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {SanityLive} from '@/sanity/live'\n *\n * export default function RootLayout({children}: {children: React.ReactNode}) {\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {defineQuery} from 'next-sanity'\n * import {sanityFetch} from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {slug} = await props.params\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict?: false}): {\n  sanityFetch: DefinedFetchType\n  SanityLive: React.ComponentType<DefinedLiveProps>\n}\nexport function defineLive(config: DefineLiveOptions) {\n  const {client: _client, serverToken, browserToken, strict = false} = config\n\n  if (!_client) {\n    throw new Error('`client` is required for `defineLive` to function')\n  }\n\n  if (process.env.NODE_ENV === 'development' && !serverToken && serverToken !== false) {\n    console.warn(\n      'No `serverToken` provided to `defineLive`. This means that only published content will be fetched and respond to live events. You can silence this warning by setting `serverToken: false`.',\n    )\n  }\n\n  if (process.env.NODE_ENV === 'development' && !browserToken && browserToken !== false) {\n    console.warn(\n      'No `browserToken` provided to `defineLive`. This means that live previewing drafts will only work when using the Presentation Tool in your Sanity Studio. To support live previewing drafts stand-alone, provide a `browserToken`. It is shared with the browser so it should only have Viewer rights or lower. You can silence this warning by setting `browserToken: false`.',\n    )\n  }\n\n  const client = _client.withConfig({\n    allowReconfigure: false,\n    useCdn: true,\n    perspective: 'published',\n    stega: false,\n  })\n  const studioUrlDefined = typeof client.config().stega.studioUrl !== 'undefined'\n\n  const sanityFetch: DefinedFetchType = async function sanityFetch({\n    query,\n    params = {},\n    perspective: _perspective,\n    variant: _variant,\n    stega: _stega,\n    tags = [],\n    requestTag = 'next-loader.fetch',\n  }) {\n    if (strict) {\n      validateStrictFetchOptions({perspective: _perspective, stega: _stega})\n    }\n    const stega = strict\n      ? _stega\n      : (_stega ?? (serverToken && studioUrlDefined ? (await draftMode()).isEnabled : false))\n    const perspective = strict\n      ? _perspective\n      : (_perspective ?? (serverToken ? await resolveCookiePerspective() : undefined))\n    // The variant cookie is only auto-resolved when the perspective is too:\n    // an explicit `perspective` opts out of cookie resolution entirely, which\n    // keeps fetches with explicit options free of dynamic API calls.\n    const variant = strict\n      ? _variant\n      : (_variant ??\n        (serverToken && typeof _perspective === 'undefined'\n          ? await resolveCookieVariant()\n          : undefined))\n    const useCdn = perspective ? perspective === 'published' : undefined\n    const isBuildPhase = process.env['NEXT_PHASE'] === PHASE_PRODUCTION_BUILD\n    const cacheMode = useCdn !== false && !isBuildPhase ? 'noStale' : undefined\n    const token =\n      ((perspective && perspective !== 'published') || stega) && serverToken\n        ? serverToken\n        : undefined\n\n    // 1. Fetch the tags first, with an uncached request, but that does not count towards the Sanity API quota\n    const {syncTags} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective,\n      variant,\n      stega: false,\n      resultSourceMap: false,\n      returnQuery: false,\n      useCdn,\n      cacheMode,\n      tag: [requestTag, 'fetch-sync-tags'].filter(Boolean).join('.'),\n      token,\n    })\n\n    const cacheTags = [...tags, ...(syncTags?.map((tag) => `${cacheTagPrefix}${tag}`) || [])]\n\n    // 2. Then fetch the data, using the fetch cache with specified tags\n    const {result, resultSourceMap} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective,\n      variant,\n      stega,\n      next: {revalidate: false, tags: cacheTags},\n      useCdn,\n      cacheMode,\n      tag: requestTag,\n      token,\n    })\n    return {data: result, sourceMap: resultSourceMap || null, tags: cacheTags}\n  }\n\n  const SanityLive: React.ComponentType<DefinedLiveProps> = async function SanityLive(props) {\n    if (strict) {\n      validateStrictSanityLiveProps(props)\n    }\n    const {\n      includeDrafts: _includeDrafts,\n      requestTag = 'next-loader.live',\n      waitFor,\n\n      action,\n      onError,\n      onWelcome,\n      onReconnect,\n      onRestart,\n      onGoAway,\n    } = props\n    const {projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix} =\n      client.config()\n\n    const includeDrafts =\n      typeof browserToken === 'string' &&\n      !!browserToken &&\n      (_includeDrafts ?? (await draftMode()).isEnabled)\n    const shouldWaitFor = waitFor === 'function' && !includeDrafts ? waitFor : undefined\n\n    // Preconnect to the Live Event API origin early, as the Sanity API is almost always on a different origin than the app\n    preconnect(client)\n\n    return (\n      <SanityLiveClientComponent\n        config={{\n          projectId,\n          dataset,\n          apiHost: apiHost === defaultApiHost ? undefined : apiHost,\n          apiVersion,\n          useProjectHostname: useProjectHostname ? undefined : useProjectHostname,\n          requestTagPrefix,\n          token: includeDrafts ? browserToken : undefined,\n        }}\n        includeDrafts={includeDrafts ? true : undefined}\n        requestTag={requestTag}\n        waitFor={shouldWaitFor}\n        action={\n          action ??\n          (shouldWaitFor === 'function' || includeDrafts ? 'refresh' : revalidateSyncTagsAction)\n        }\n        onError={onError}\n        onWelcome={onWelcome}\n        onReconnect={onReconnect}\n        onRestart={onRestart}\n        onGoAway={onGoAway}\n      />\n    )\n  }\n  SanityLive.displayName = 'SanityLiveServerComponent'\n\n  return {sanityFetch, SanityLive}\n}\n\nasync function resolveCookiePerspective(): Promise<LivePerspective | undefined> {\n  return (await draftMode()).isEnabled\n    ? await resolvePerspectiveFromCookies({cookies: await cookies()})\n    : undefined\n}\n\nasync function resolveCookieVariant(): Promise<string | undefined> {\n  return (await draftMode()).isEnabled\n    ? await resolveVariantFromCookies({cookies: await cookies()})\n    : undefined\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["SanityLive","SanityLiveClientComponent"],"sources":["../../../../src/live/conditions/react-server/defineLive.tsx"],"sourcesContent":["import {SanityLive as SanityLiveClientComponent} from 'next-sanity/live/client-components'\nimport {revalidateSyncTagsAction} from 'next-sanity/live/server-actions'\nimport {PHASE_PRODUCTION_BUILD} from 'next/constants'\nimport {cookies, draftMode} from 'next/headers'\n\nimport {cacheTagPrefix, defaultApiHost} from '#live/constants'\nimport {preconnect} from '#live/preconnect'\nimport {resolvePerspectiveFromCookies} from '#live/resolvePerspectiveFromCookies'\nimport {resolveVariantFromCookies} from '#live/resolveVariantFromCookies'\nimport {validateStrictFetchOptions, validateStrictSanityLiveProps} from '#live/strictValidation'\nimport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  LivePerspective,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\n/**\n * Set up Sanity Live for Cache Components. `defineLive` returns `sanityFetch`\n * and `<SanityLive />`, which connect your Sanity client to the Live Content API\n * so cached pages can update in response to fine-grained content changes.\n *\n * With `strict: true`, `perspective` and `stega` become required\n * `sanityFetch` options, and `includeDrafts` becomes required on\n * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`\n * outside `'use cache'` boundaries, then pass them into cached components.\n *\n * `sanityFetch` brands `data` with stega string types when `stega` is `true`,\n * a non-literal `boolean`, or omitted (react-server may auto-enable stega).\n * Pass the literal `stega: false` for clean TypeGen types. Use `stegaClean`\n * before comparing branded strings to literals.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * // sanity/live.ts\n * import {cookies, draftMode} from 'next/headers'\n * import {createClient} from 'next-sanity'\n * import {\n *   defineLive,\n *   resolvePerspectiveFromCookies,\n *   resolveVariantFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n *   strict: true,\n * })\n *\n * export interface DynamicFetchOptions {\n *   perspective: LivePerspective\n *   variant?: string\n *   // `boolean` brands `sanityFetch` `data`; use literal `false` for clean types\n *   stega: boolean\n * }\n *\n * // Resolve dynamic values outside 'use cache' boundaries.\n * export async function getDynamicFetchOptions(): Promise<DynamicFetchOptions> {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (!isDraftMode) {\n *     return {perspective: 'published', stega: false}\n *   }\n *\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   const variant = await resolveVariantFromCookies({cookies: jar})\n *   return {perspective: perspective ?? 'drafts', variant, stega: true}\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {draftMode} from 'next/headers'\n *\n * import {SanityLive} from '@/sanity/live'\n *\n * export default async function RootLayout({children}: {children: React.ReactNode}) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive includeDrafts={isDraftMode} />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {draftMode} from 'next/headers'\n * import {Suspense} from 'react'\n * import {defineQuery} from 'next-sanity'\n *\n * import {\n *   getDynamicFetchOptions,\n *   sanityFetch,\n *   type DynamicFetchOptions,\n * } from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (isDraftMode) {\n *     return (\n *       <Suspense fallback={<div>Loading...</div>}>\n *         <DynamicPage params={props.params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await props.params\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage(props: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await props.params\n *   const {perspective, variant, stega} = await getDynamicFetchOptions()\n *\n *   return <CachedPage slug={slug} perspective={perspective} variant={variant} stega={stega} />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   variant,\n *   stega,\n * }: {slug: string} & DynamicFetchOptions) {\n *   'use cache'\n *\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *     perspective,\n *     variant,\n *     stega,\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict: true}): {\n  sanityFetch: StrictDefinedFetchType\n  SanityLive: React.ComponentType<StrictDefinedLiveProps>\n}\n/**\n * Set up Sanity Live. `defineLive` returns `sanityFetch` and `<SanityLive />`,\n * which connect your Sanity client to the Live Content API so pages can serve\n * cached content and update in response to fine-grained content changes.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * import {createClient} from 'next-sanity'\n * import {defineLive} from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n * })\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {SanityLive} from '@/sanity/live'\n *\n * export default function RootLayout({children}: {children: React.ReactNode}) {\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {defineQuery} from 'next-sanity'\n * import {sanityFetch} from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {slug} = await props.params\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict?: false}): {\n  sanityFetch: DefinedFetchType\n  SanityLive: React.ComponentType<DefinedLiveProps>\n}\nexport function defineLive(config: DefineLiveOptions) {\n  const {client: _client, serverToken, browserToken, strict = false} = config\n\n  if (!_client) {\n    throw new Error('`client` is required for `defineLive` to function')\n  }\n\n  if (process.env.NODE_ENV === 'development' && !serverToken && serverToken !== false) {\n    console.warn(\n      'No `serverToken` provided to `defineLive`. This means that only published content will be fetched and respond to live events. You can silence this warning by setting `serverToken: false`.',\n    )\n  }\n\n  if (process.env.NODE_ENV === 'development' && !browserToken && browserToken !== false) {\n    console.warn(\n      'No `browserToken` provided to `defineLive`. This means that live previewing drafts will only work when using the Presentation Tool in your Sanity Studio. To support live previewing drafts stand-alone, provide a `browserToken`. It is shared with the browser so it should only have Viewer rights or lower. You can silence this warning by setting `browserToken: false`.',\n    )\n  }\n\n  const client = _client.withConfig({\n    allowReconfigure: false,\n    useCdn: true,\n    perspective: 'published',\n    stega: false,\n  })\n  const studioUrlDefined = typeof client.config().stega.studioUrl !== 'undefined'\n\n  const sanityFetch: DefinedFetchType = async function sanityFetch({\n    query,\n    params = {},\n    perspective: _perspective,\n    variant: _variant,\n    stega: _stega,\n    tags = [],\n    requestTag = 'next-loader.fetch',\n  }) {\n    if (strict) {\n      validateStrictFetchOptions({perspective: _perspective, stega: _stega})\n    }\n    const stega = strict\n      ? _stega\n      : (_stega ?? (serverToken && studioUrlDefined ? (await draftMode()).isEnabled : false))\n    const perspective = strict\n      ? _perspective\n      : (_perspective ?? (serverToken ? await resolveCookiePerspective() : undefined))\n    // The variant cookie is only auto-resolved when the perspective is too:\n    // an explicit `perspective` opts out of cookie resolution entirely, which\n    // keeps fetches with explicit options free of dynamic API calls.\n    const variant = strict\n      ? _variant\n      : (_variant ??\n        (serverToken && typeof _perspective === 'undefined'\n          ? await resolveCookieVariant()\n          : undefined))\n    const useCdn = perspective ? perspective === 'published' : undefined\n    const isBuildPhase = process.env['NEXT_PHASE'] === PHASE_PRODUCTION_BUILD\n    const cacheMode = useCdn !== false && !isBuildPhase ? 'noStale' : undefined\n    const token =\n      ((perspective && perspective !== 'published') || stega) && serverToken\n        ? serverToken\n        : undefined\n\n    // 1. Fetch the tags first, with an uncached request, but that does not count towards the Sanity API quota\n    const {syncTags} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective,\n      variant,\n      stega: false,\n      resultSourceMap: false,\n      returnQuery: false,\n      useCdn,\n      cacheMode,\n      tag: [requestTag, 'fetch-sync-tags'].filter(Boolean).join('.'),\n      token,\n    })\n\n    const cacheTags = [...tags, ...(syncTags?.map((tag) => `${cacheTagPrefix}${tag}`) || [])]\n\n    // 2. Then fetch the data, using the fetch cache with specified tags\n    const {result, resultSourceMap} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective,\n      variant,\n      stega,\n      next: {revalidate: false, tags: cacheTags},\n      useCdn,\n      cacheMode,\n      tag: requestTag,\n      token,\n    })\n    return {data: result, sourceMap: resultSourceMap || null, tags: cacheTags}\n  }\n\n  const SanityLive: React.ComponentType<DefinedLiveProps> = async function SanityLive(props) {\n    if (strict) {\n      validateStrictSanityLiveProps(props)\n    }\n    const {\n      includeDrafts: _includeDrafts,\n      requestTag = 'next-loader.live',\n      waitFor,\n\n      action,\n      onError,\n      onWelcome,\n      onReconnect,\n      onRestart,\n      onGoAway,\n    } = props\n    const {projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix} =\n      client.config()\n\n    const includeDrafts =\n      typeof browserToken === 'string' &&\n      !!browserToken &&\n      (_includeDrafts ?? (await draftMode()).isEnabled)\n    const shouldWaitFor = waitFor === 'function' && !includeDrafts ? waitFor : undefined\n\n    // Preconnect to the Live Event API origin early, as the Sanity API is almost always on a different origin than the app\n    preconnect(client)\n\n    return (\n      <SanityLiveClientComponent\n        config={{\n          projectId,\n          dataset,\n          apiHost: apiHost === defaultApiHost ? undefined : apiHost,\n          apiVersion,\n          useProjectHostname: useProjectHostname ? undefined : useProjectHostname,\n          requestTagPrefix,\n          token: includeDrafts ? browserToken : undefined,\n        }}\n        includeDrafts={includeDrafts ? true : undefined}\n        requestTag={requestTag}\n        waitFor={shouldWaitFor}\n        action={\n          action ??\n          (shouldWaitFor === 'function' || includeDrafts ? 'refresh' : revalidateSyncTagsAction)\n        }\n        onError={onError}\n        onWelcome={onWelcome}\n        onReconnect={onReconnect}\n        onRestart={onRestart}\n        onGoAway={onGoAway}\n      />\n    )\n  }\n  SanityLive.displayName = 'SanityLiveServerComponent'\n\n  return {sanityFetch, SanityLive}\n}\n\nasync function resolveCookiePerspective(): Promise<LivePerspective | undefined> {\n  return (await draftMode()).isEnabled\n    ? await resolvePerspectiveFromCookies({cookies: await cookies()})\n    : undefined\n}\n\nasync function resolveCookieVariant(): Promise<string | undefined> {\n  return (await draftMode()).isEnabled\n    ? await resolveVariantFromCookies({cookies: await cookies()})\n    : undefined\n}\n"],"mappings":"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"}

package/dist/types.d.ts

@@ -1,17 +1,27 @@
+import { StegaBranded } from "@sanity/client/stega";
 import { ClientPerspective, ClientReturn, ContentSourceMap, InitializedClientConfig, LiveEvent, QueryParams, SanityClient } from "next-sanity";
+/**
+ * Like `ClientReturnStega` from `@sanity/client/stega`, but composed from the
+ * main-entry {@link ClientReturn} so `SanityQueries` TypeGen augmentations on
+ * `@sanity/client` apply. The stega subpath ships a bundled `ClientReturn` that
+ * does not see those augmentations.
+ */
+type FetchClientReturnStega<QueryString extends string> = StegaBranded<ClientReturn<QueryString, unknown>>;
 /**
  * Perspectives supported by Sanity Live.
  * Using the legacy `'raw'` perspective is not supported and leads to undefined behavior.
  */
 type LivePerspective = Exclude<ClientPerspective, "raw">;
+type DefinedFetchResult<Data> = Promise<{
+  data: Data;
+  sourceMap: ContentSourceMap | null;
+  tags: string[];
+}>;
 /**
- * Fetches data through the configured Sanity client and returns the result
- * together with the source map and cache tags that Sanity Live uses for
- * targeted revalidation.
- *
- * Returned by `defineLive({strict: false})` and `defineLive({strict: undefined})`.
+ * Options accepted by `sanityFetch()` returned by `defineLive({strict: false})`
+ * and `defineLive({strict: undefined})`.
  */
-type DefinedFetchType = <const QueryString extends string>(options: {
+interface DefinedFetchOptions<QueryString extends string> {
   /**
    * GROQ query to execute.
    */
@@ -57,6 +67,12 @@ type DefinedFetchType = <const QueryString extends string>(options: {
    * Enables stega encoding of the data. This is typically only used in draft
    * mode with `perspective: 'drafts'` and `@sanity/visual-editing`.
    *
+   * Unless this option is the literal `false`, the returned `data` is
+   * stega-branded (`StegaBranded<ClientReturn<...>>`): strings that may carry
+   * stega payloads are typed as `StegaString` and must be cleaned with
+   * `stegaClean` before they can be compared against string literals. Pass the
+   * literal `stega: false` to keep clean TypeGen / {@link ClientReturn} types.
+   *
    * @remarks
    * Requires `serverToken` to be configured in `defineLive()`
    *
@@ -95,11 +111,54 @@ type DefinedFetchType = <const QueryString extends string>(options: {
    * otherwise it's `'next-loader.fetch'`
    */
   requestTag?: string;
-}) => Promise<{
-  data: ClientReturn<QueryString, unknown>;
-  sourceMap: ContentSourceMap | null;
-  tags: string[];
-}>;
+}
+/**
+ * Like {@link DefinedFetchOptions} but with `stega` fixed to `true`, selecting
+ * the overload that brands the returned `data` with stega string types.
+ * All other options inherit their documentation from {@link DefinedFetchOptions}.
+ */
+interface DefinedFetchStegaEnabledOptions<QueryString extends string> extends DefinedFetchOptions<QueryString> {
+  /**
+   * Enables stega encoding of the data. This is typically only used in draft
+   * mode with `perspective: 'drafts'` and `@sanity/visual-editing`.
+   *
+   * With the literal `true`, the returned `data` is stega-branded
+   * (`StegaBranded<ClientReturn<...>>`): use `stegaClean` before comparing
+   * strings against literals.
+   *
+   * @remarks
+   * Requires `serverToken` to be configured in `defineLive()`
+   */
+  stega: true;
+}
+/**
+ * Like {@link DefinedFetchOptions} but with `stega` fixed to `false`, selecting
+ * the overload that keeps the returned `data` free of stega branding.
+ * All other options inherit their documentation from {@link DefinedFetchOptions}.
+ */
+interface DefinedFetchStegaDisabledOptions<QueryString extends string> extends DefinedFetchOptions<QueryString> {
+  /**
+   * Disables stega encoding for this fetch. The returned `data` keeps clean
+   * TypeGen / {@link ClientReturn} types, no `stegaClean` needed.
+   */
+  stega: false;
+}
+/**
+ * Fetches data through the configured Sanity client and returns the result
+ * together with the source map and cache tags that Sanity Live uses for
+ * targeted revalidation.
+ *
+ * Returned by `defineLive({strict: false})` and `defineLive({strict: undefined})`.
+ *
+ * Overloads brand `data` with stega string types when stega may be enabled
+ * (`stega: true`, a non-literal `boolean`, or omitted). Literal `stega: false`
+ * keeps clean TypeGen / {@link ClientReturn} types.
+ */
+type DefinedFetchType = {
+  <const QueryString extends string>(options: DefinedFetchStegaEnabledOptions<QueryString>): DefinedFetchResult<FetchClientReturnStega<QueryString>>;
+  <const QueryString extends string>(options: DefinedFetchStegaDisabledOptions<QueryString>): DefinedFetchResult<ClientReturn<QueryString, unknown>>;
+  <const QueryString extends string>(options: DefinedFetchOptions<QueryString>): DefinedFetchResult<FetchClientReturnStega<QueryString>>;
+};
 /**
  * Render this in your root layout.tsx to make your page refresh, or revalidate, on new content live, automatically.
  * @public
@@ -210,12 +269,20 @@ interface StrictDefinedLiveProps extends Omit<DefinedLiveProps, "includeDrafts">
   includeDrafts: boolean;
 }
 /**
- * Like {@link DefinedFetchType} but with `perspective` and `stega` required.
- * Returned by `defineLive({strict: true})`.
+ * Options accepted by `sanityFetch()` returned by `defineLive({strict: true})`.
+ * Like {@link DefinedFetchOptions} but with `perspective` and `stega` required,
+ * and no cookie or `draftMode()` auto-resolution of defaults.
  */
-type StrictDefinedFetchType = <const QueryString extends string>(options: {
-  query: QueryString;
-  params?: QueryParams | Promise<QueryParams>;
+interface StrictDefinedFetchOptions<QueryString extends string> extends DefinedFetchOptions<QueryString> {
+  /**
+   * Content perspective used for the fetch.
+   *
+   * Required when `strict: true` is set on `defineLive()`: there is no cookie
+   * auto-resolution; only the explicit option is used.
+   *
+   * @remarks
+   * Non-`'published'` perspectives require `serverToken` to be configured in `defineLive()`
+   */
   perspective: LivePerspective;
   /**
    * Editing variant used for the fetch, as the bare variant id (e.g. `Ab12cd34`).
@@ -225,14 +292,64 @@ type StrictDefinedFetchType = <const QueryString extends string>(options: {
    * only the explicit option is used.
    */
   variant?: string;
+  /**
+   * Enables stega encoding of the data. This is typically only used in draft
+   * mode with `perspective: 'drafts'` and `@sanity/visual-editing`.
+   *
+   * Required when `strict: true` is set on `defineLive()`. Unless this option
+   * is the literal `false`, the returned `data` is stega-branded
+   * (`StegaBranded<ClientReturn<...>>`) — conservative: treat strings as
+   * possibly stega-encoded until cleaned with `stegaClean`.
+   *
+   * @remarks
+   * Requires `serverToken` to be configured in `defineLive()`
+   */
   stega: boolean;
-  tags?: string[];
-  requestTag?: string;
-}) => Promise<{
-  data: ClientReturn<QueryString, unknown>;
-  sourceMap: ContentSourceMap | null;
-  tags: string[];
-}>;
+}
+/**
+ * Like {@link StrictDefinedFetchOptions} but with `stega` fixed to `true`,
+ * selecting the overload that brands the returned `data` with stega string types.
+ * All other options inherit their documentation from {@link StrictDefinedFetchOptions}.
+ */
+interface StrictDefinedFetchStegaEnabledOptions<QueryString extends string> extends StrictDefinedFetchOptions<QueryString> {
+  /**
+   * Enables stega encoding of the data. This is typically only used in draft
+   * mode with `perspective: 'drafts'` and `@sanity/visual-editing`.
+   *
+   * With the literal `true`, the returned `data` is stega-branded
+   * (`StegaBranded<ClientReturn<...>>`): use `stegaClean` before comparing
+   * strings against literals.
+   *
+   * @remarks
+   * Requires `serverToken` to be configured in `defineLive()`
+   */
+  stega: true;
+}
+/**
+ * Like {@link StrictDefinedFetchOptions} but with `stega` fixed to `false`,
+ * selecting the overload that keeps the returned `data` free of stega branding.
+ * All other options inherit their documentation from {@link StrictDefinedFetchOptions}.
+ */
+interface StrictDefinedFetchStegaDisabledOptions<QueryString extends string> extends StrictDefinedFetchOptions<QueryString> {
+  /**
+   * Disables stega encoding for this fetch. The returned `data` keeps clean
+   * TypeGen / {@link ClientReturn} types, no `stegaClean` needed.
+   */
+  stega: false;
+}
+/**
+ * Like {@link DefinedFetchType} but with `perspective` and `stega` required.
+ * Returned by `defineLive({strict: true})`.
+ *
+ * Overloads brand `data` with stega string types when stega may be enabled
+ * (`stega: true` or a non-literal `boolean`). Literal `stega: false` keeps
+ * clean TypeGen / {@link ClientReturn} types.
+ */
+type StrictDefinedFetchType = {
+  <const QueryString extends string>(options: StrictDefinedFetchStegaEnabledOptions<QueryString>): DefinedFetchResult<FetchClientReturnStega<QueryString>>;
+  <const QueryString extends string>(options: StrictDefinedFetchStegaDisabledOptions<QueryString>): DefinedFetchResult<ClientReturn<QueryString, unknown>>;
+  <const QueryString extends string>(options: StrictDefinedFetchOptions<QueryString>): DefinedFetchResult<FetchClientReturnStega<QueryString>>;
+};
 interface SanityClientConfig extends Pick<InitializedClientConfig, "projectId" | "dataset" | "apiVersion" | "token" | "requestTagPrefix"> {
   apiHost: string | undefined;
   useProjectHostname: boolean | undefined;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../src/live/shared/types.ts"],"mappings":";;;;;KAcY,kBAAkB,QAAQ;;;;;;;;KAS1B,0BAA0B,4BAA4B;;;;EAIhE,OAAO;;;;EAIP,SAAS,cAAc,QAAQ;;;;;;;;;;;;;;;;EAgB/B,cAAc;;;;;;;;;;;;;;;;;EAiBd;;;;;;;;;;;;;;;;;;EAkBA;;;;;;;;;;;;;;EAcA;;;;;;;;;;EAUA;MACI;EACJ,MAAM,aAAa;EACnB,WAAW;EACX;;;;;;UAOe;;;;;;;;;;;;;;;;EAgBf;;;;;;;;;;EAUA;;;;;EAKA;;;;;;;EAOA,SAAS;;;;;;EAMT,UAAU;;;;;EAKV,YAAY;;;;;EAKZ,cAAc;;;;;EAKd,YAAY;;;;;EAKZ,WAAW;;UAGI;;;;EAIf,QAAQ;;;;;;;EAOR;;;;;;;;EAQA;;;;;;;;;;;EAWA;;;;;;UAOe,+BAA+B,KAAK;EACnD;;;;;;KAOU,gCAAgC,4BAA4B;EACtE,OAAO;EACP,SAAS,cAAc,QAAQ;EAC/B,aAAa;;;;;;;;EAQb;EACA;EACA;EACA;MACI;EACJ,MAAM,aAAa;EACnB,WAAW;EACX;;UAGe,2BAA2B,KAC1C;EAGA;EACA;;;;;UAMe;;;;;EAKf;;;;EAIA;;;;;;;;;;;;;;;;KAiBU,qBAAqB,wBAAwB;;;;;;;;;KAS7C,sBAAsB,gBAAgB,SAAS;;;;;;;;KAQ/C,uBACV,OAAO,QAAQ;EAAY;IAC3B,SAAS,6BACC;;;;;;KAMA,yBACV,OAAO,QAAQ;EAAY;IAC3B,SAAS,6BACC;;;;;;;KAQA,wBAEN,OAAO,QAAQ;EAAY;IAC3B,SAAS,6BACC;;;;;;;;;KAUJ,sBACV,OAAO,QAAQ;EAAY;IAC3B,SAAS,mBACT,qBAAqB,qCACX"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/live/shared/types.ts"],"mappings":";;;;;;;;KAiBK,uBAAuB,8BAA8B,aACxD,aAAa;;;;;KAOH,kBAAkB,QAAQ;KAEjC,mBAAmB,QAAQ;EAC9B,MAAM;EACN,WAAW;EACX;;;;;;UAOQ,oBAAoB;;;;EAI5B,OAAO;;;;EAIP,SAAS,cAAc,QAAQ;;;;;;;;;;;;;;;;EAgB/B,cAAc;;;;;;;;;;;;;;;;;EAiBd;;;;;;;;;;;;;;;;;;;;;;;;EAwBA;;;;;;;;;;;;;;EAcA;;;;;;;;;;EAUA;;;;;;;UAQQ,gCACR,oCACQ,oBAAoB;;;;;;;;;;;;EAY5B;;;;;;;UAQQ,iCACR,oCACQ,oBAAoB;;;;;EAK5B;;;;;;;;;;;;;KAcU;SACH,4BACL,SAAS,gCAAgC,eACxC,mBAAmB,uBAAuB;SACtC,4BACL,SAAS,iCAAiC,eACzC,mBAAmB,aAAa;SAC5B,4BACL,SAAS,oBAAoB,eAC5B,mBAAmB,uBAAuB;;;;;;UAO9B;;;;;;;;;;;;;;;;EAgBf;;;;;;;;;;EAUA;;;;;EAKA;;;;;;;EAOA,SAAS;;;;;;EAMT,UAAU;;;;;EAKV,YAAY;;;;;EAKZ,cAAc;;;;;EAKd,YAAY;;;;;EAKZ,WAAW;;UAGI;;;;EAIf,QAAQ;;;;;;;EAOR;;;;;;;;EAQA;;;;;;;;;;;EAWA;;;;;;UAOe,+BAA+B,KAAK;EACnD;;;;;;;UAQQ,0BACR,oCACQ,oBAAoB;;;;;;;;;;EAU5B,aAAa;;;;;;;;EAQb;;;;;;;;;;;;;EAaA;;;;;;;UAQQ,sCACR,oCACQ,0BAA0B;;;;;;;;;;;;EAYlC;;;;;;;UAQQ,uCACR,oCACQ,0BAA0B;;;;;EAKlC;;;;;;;;;;KAWU;SACH,4BACL,SAAS,sCAAsC,eAC9C,mBAAmB,uBAAuB;SACtC,4BACL,SAAS,uCAAuC,eAC/C,mBAAmB,aAAa;SAC5B,4BACL,SAAS,0BAA0B,eAClC,mBAAmB,uBAAuB;;UAG9B,2BAA2B,KAC1C;EAGA;EACA;;;;;UAMe;;;;;EAKf;;;;EAIA;;;;;;;;;;;;;;;;KAiBU,qBAAqB,wBAAwB;;;;;;;;;KAS7C,sBAAsB,gBAAgB,SAAS;;;;;;;;KAQ/C,uBACV,OAAO,QAAQ;EAAY;IAC3B,SAAS,6BACC;;;;;;KAMA,yBACV,OAAO,QAAQ;EAAY;IAC3B,SAAS,6BACC;;;;;;;KAQA,wBAEN,OAAO,QAAQ;EAAY;IAC3B,SAAS,6BACC;;;;;;;;;KAUJ,sBACV,OAAO,QAAQ;EAAY;IAC3B,SAAS,mBACT,qBAAqB,qCACX"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-sanity",
-  "version": "13.2.3",
+  "version": "13.3.1",
   "description": "Sanity.io toolkit for Next.js",
   "keywords": [
     "live",
@@ -59,39 +59,39 @@
   },
   "dependencies": {
     "@portabletext/react": "^7.0.1",
-    "@sanity/client": "^7.25.0",
+    "@sanity/client": "^7.26.1",
     "@sanity/generate-help-url": "^4.0.0",
     "@sanity/preview-url-secret": "^4.1.2",
     "@sanity/visual-editing": "^5.7.3",
     "@sanity/webhook": "^4.0.4",
-    "groq": "^6.7.0",
+    "groq": "^6.8.0",
     "history": "^5.3.0"
   },
   "devDependencies": {
     "@sanity/tsconfig": "^2.2.1",
     "@types/node": "^24.13.3",
-    "@types/react": "^19.2.17",
-    "@types/react-dom": "^19.2.3",
+    "@types/react": "^19.2.18",
+    "@types/react-dom": "^19.2.4",
     "@vercel/stega": "^1.1.0",
-    "@vitejs/plugin-react": "^6.0.4",
+    "@vitejs/plugin-react": "^6.0.5",
     "@vitest/browser-playwright": "^4.1.10",
     "@vitest/coverage-v8": "^4.1.10",
-    "js-yaml": "^5.2.2",
+    "js-yaml": "^5.2.3",
     "msw": "^2.15.0",
-    "next": "16.3.0-canary.99",
+    "next": "16.3.1-canary.0",
     "publint": "^0.3.22",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "styled-components": "^6.4.4",
     "tsdown": "^0.22.14",
     "typescript": "7.0.2",
-    "vite": "^8.1.5",
+    "vite": "^8.2.0",
     "vitest": "^4.1.10",
     "vitest-browser-react": "^2.2.0",
     "vitest-package-exports": "^1.2.0"
   },
   "peerDependencies": {
-    "@sanity/client": "^7.25.0",
+    "@sanity/client": "^7.26.1",
     "next": "^16.0.0-0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3",