@payloadcms/tanstack-start 4.0.0-beta.0

package/dist/utilities/devConfigReload.server.js

@@ -0,0 +1,63 @@
+import { registerDevReloadStrategy } from 'payload';
+import { PAYLOAD_CONFIG_CHANGED_EVENT } from './devConfigReloadEvent.js';
+/**
+ * Subscribes the Payload instance to the config-changed event that the
+ * `payload:dev-config-reload` Vite plugin broadcasts.
+ *
+ * Imported for its side effect by `initAdminContext.server.ts`, the adapter's only
+ * `getPayload` call site, so the strategy is registered before an instance can
+ * be built. Registration is module-scoped on both ends: this runs inside the
+ * app's server graph and so resolves the same copy of `payload` that
+ * `getPayload` is called on, and each Vite environment (`ssr`, `rsc`) registers
+ * its own listener against its own copy.
+ *
+ * Vite re-evaluates this module on a program reload, which drops the listeners
+ * the previous instance had collected. `getPayload` reconnects on its next call
+ * because the registered strategy is a new object - see `connectDevReload`.
+ *
+ * `import.meta.hot` is only defined during dev serve, so this is inert in a
+ * production build.
+ */ const hot = import.meta.hot;
+if (hot) {
+    registerDevReloadStrategy(createConfigChangedStrategy({
+        hot
+    }));
+}
+/**
+ * Builds a dev reload strategy that forwards the config-changed event to every
+ * connected instance.
+ *
+ * After a program reload, the first request to re-import this module replaces
+ * the old listener with a new one, but the cached Payload instance only connects
+ * to it on its next `getPayload` call - and a request such as a frontend page
+ * render may never make one. An event that lands in that gap has no one to
+ * notify, so it is held and replayed to the next connection instead of being
+ * dropped - which would otherwise leave the instance serving the old config
+ * indefinitely.
+ */ function createConfigChangedStrategy({ hot }) {
+    const listeners = new Set();
+    let hasPendingReload = false;
+    hot.on(PAYLOAD_CONFIG_CHANGED_EVENT, ()=>{
+        if (listeners.size === 0) {
+            hasPendingReload = true;
+            return;
+        }
+        for (const onReload of listeners){
+            onReload();
+        }
+    });
+    return {
+        connect: (onReload)=>{
+            listeners.add(onReload);
+            if (hasPendingReload) {
+                hasPendingReload = false;
+                onReload();
+            }
+            return ()=>{
+                listeners.delete(onReload);
+            };
+        }
+    };
+}
+
+//# sourceMappingURL=devConfigReload.server.js.map

package/dist/utilities/devConfigReload.server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/devConfigReload.server.ts"],"sourcesContent":["import { registerDevReloadStrategy } from 'payload'\n\nimport { PAYLOAD_CONFIG_CHANGED_EVENT } from './devConfigReloadEvent.js'\n\n/**\n * Subscribes the Payload instance to the config-changed event that the\n * `payload:dev-config-reload` Vite plugin broadcasts.\n *\n * Imported for its side effect by `initAdminContext.server.ts`, the adapter's only\n * `getPayload` call site, so the strategy is registered before an instance can\n * be built. Registration is module-scoped on both ends: this runs inside the\n * app's server graph and so resolves the same copy of `payload` that\n * `getPayload` is called on, and each Vite environment (`ssr`, `rsc`) registers\n * its own listener against its own copy.\n *\n * Vite re-evaluates this module on a program reload, which drops the listeners\n * the previous instance had collected. `getPayload` reconnects on its next call\n * because the registered strategy is a new object - see `connectDevReload`.\n *\n * `import.meta.hot` is only defined during dev serve, so this is inert in a\n * production build.\n */\nconst hot = (import.meta as unknown as { hot?: ViteHotContext }).hot\n\nif (hot) {\n  registerDevReloadStrategy(createConfigChangedStrategy({ hot }))\n}\n\n/**\n * Builds a dev reload strategy that forwards the config-changed event to every\n * connected instance.\n *\n * After a program reload, the first request to re-import this module replaces\n * the old listener with a new one, but the cached Payload instance only connects\n * to it on its next `getPayload` call - and a request such as a frontend page\n * render may never make one. An event that lands in that gap has no one to\n * notify, so it is held and replayed to the next connection instead of being\n * dropped - which would otherwise leave the instance serving the old config\n * indefinitely.\n */\nfunction createConfigChangedStrategy({ hot }: { hot: ViteHotContext }): {\n  connect: (onReload: () => void) => () => void\n} {\n  const listeners = new Set<() => void>()\n  let hasPendingReload = false\n\n  hot.on(PAYLOAD_CONFIG_CHANGED_EVENT, () => {\n    if (listeners.size === 0) {\n      hasPendingReload = true\n      return\n    }\n\n    for (const onReload of listeners) {\n      onReload()\n    }\n  })\n\n  return {\n    connect: (onReload) => {\n      listeners.add(onReload)\n\n      if (hasPendingReload) {\n        hasPendingReload = false\n        onReload()\n      }\n\n      return () => {\n        listeners.delete(onReload)\n      }\n    },\n  }\n}\n\ntype ViteHotContext = {\n  on: (event: string, cb: () => void) => void\n}\n"],"names":["registerDevReloadStrategy","PAYLOAD_CONFIG_CHANGED_EVENT","hot","createConfigChangedStrategy","listeners","Set","hasPendingReload","on","size","onReload","connect","add","delete"],"mappings":"AAAA,SAASA,yBAAyB,QAAQ,UAAS;AAEnD,SAASC,4BAA4B,QAAQ,4BAA2B;AAExE;;;;;;;;;;;;;;;;;CAiBC,GACD,MAAMC,MAAM,AAAC,YAAoDA,GAAG;AAEpE,IAAIA,KAAK;IACPF,0BAA0BG,4BAA4B;QAAED;IAAI;AAC9D;AAEA;;;;;;;;;;;CAWC,GACD,SAASC,4BAA4B,EAAED,GAAG,EAA2B;IAGnE,MAAME,YAAY,IAAIC;IACtB,IAAIC,mBAAmB;IAEvBJ,IAAIK,EAAE,CAACN,8BAA8B;QACnC,IAAIG,UAAUI,IAAI,KAAK,GAAG;YACxBF,mBAAmB;YACnB;QACF;QAEA,KAAK,MAAMG,YAAYL,UAAW;YAChCK;QACF;IACF;IAEA,OAAO;QACLC,SAAS,CAACD;YACRL,UAAUO,GAAG,CAACF;YAEd,IAAIH,kBAAkB;gBACpBA,mBAAmB;gBACnBG;YACF;YAEA,OAAO;gBACLL,UAAUQ,MAAM,CAACH;YACnB;QACF;IACF;AACF"}

package/dist/utilities/devConfigReloadEvent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Custom Vite HMR event the `payload:dev-config-reload` plugin broadcasts when
+ * the Payload config (or anything it imports) changes on disk.
+ *
+ * Kept in its own module so the Vite plugin can name the event without pulling
+ * in the server runtime — and therefore the whole CMS — when `vite.config.ts` loads.
+ */
+export declare const PAYLOAD_CONFIG_CHANGED_EVENT = "payload:config-changed";
+//# sourceMappingURL=devConfigReloadEvent.d.ts.map

package/dist/utilities/devConfigReloadEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devConfigReloadEvent.d.ts","sourceRoot":"","sources":["../../src/utilities/devConfigReloadEvent.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,2BAA2B,CAAA"}

package/dist/utilities/devConfigReloadEvent.js

@@ -0,0 +1,9 @@
+/**
+ * Custom Vite HMR event the `payload:dev-config-reload` plugin broadcasts when
+ * the Payload config (or anything it imports) changes on disk.
+ *
+ * Kept in its own module so the Vite plugin can name the event without pulling
+ * in the server runtime — and therefore the whole CMS — when `vite.config.ts` loads.
+ */ export const PAYLOAD_CONFIG_CHANGED_EVENT = 'payload:config-changed';
+
+//# sourceMappingURL=devConfigReloadEvent.js.map

package/dist/utilities/devConfigReloadEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/devConfigReloadEvent.ts"],"sourcesContent":["/**\n * Custom Vite HMR event the `payload:dev-config-reload` plugin broadcasts when\n * the Payload config (or anything it imports) changes on disk.\n *\n * Kept in its own module so the Vite plugin can name the event without pulling\n * in the server runtime — and therefore the whole CMS — when `vite.config.ts` loads.\n */\nexport const PAYLOAD_CONFIG_CHANGED_EVENT = 'payload:config-changed'\n"],"names":["PAYLOAD_CONFIG_CHANGED_EVENT"],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,MAAMA,+BAA+B,yBAAwB"}

package/dist/utilities/getRequestI18n.server.d.ts

@@ -0,0 +1,12 @@
+import type { I18nClient } from '@payloadcms/translations';
+import type { SanitizedConfig } from 'payload';
+/**
+ * Resolves the client `I18n` for the current TanStack Start request without a
+ * full `initAdminContext` (no `getPayload`/auth/access). Mirrors the Next.js adapter's
+ * `getNextRequestI18n` and feeds the shared `generatePageMetadata`, which only
+ * needs `config` + `i18n` to translate admin-page titles.
+ */
+export declare function getRequestI18n({ config }: {
+    config: SanitizedConfig;
+}): Promise<I18nClient>;
+//# sourceMappingURL=getRequestI18n.server.d.ts.map

package/dist/utilities/getRequestI18n.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRequestI18n.server.d.ts","sourceRoot":"","sources":["../../src/utilities/getRequestI18n.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAM9C;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,eAAe,CAAA;CAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAYjG"}

package/dist/utilities/getRequestI18n.server.js

@@ -0,0 +1,25 @@
+import { initI18n } from '@payloadcms/translations';
+import { getRequest } from '@tanstack/react-start/server';
+import { getRequestLanguage, parseCookies } from 'payload';
+/**
+ * Resolves the client `I18n` for the current TanStack Start request without a
+ * full `initAdminContext` (no `getPayload`/auth/access). Mirrors the Next.js adapter's
+ * `getNextRequestI18n` and feeds the shared `generatePageMetadata`, which only
+ * needs `config` + `i18n` to translate admin-page titles.
+ */ export async function getRequestI18n({ config }) {
+    const webRequest = getRequest();
+    const headers = new Headers(webRequest.headers);
+    const cookies = parseCookies(headers);
+    const languageCode = getRequestLanguage({
+        config,
+        cookies,
+        headers
+    });
+    return initI18n({
+        config: config.i18n,
+        context: 'client',
+        language: languageCode
+    });
+}
+
+//# sourceMappingURL=getRequestI18n.server.js.map

package/dist/utilities/getRequestI18n.server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/getRequestI18n.server.ts"],"sourcesContent":["import type { I18nClient } from '@payloadcms/translations'\nimport type { SanitizedConfig } from 'payload'\n\nimport { initI18n } from '@payloadcms/translations'\nimport { getRequest } from '@tanstack/react-start/server'\nimport { getRequestLanguage, parseCookies } from 'payload'\n\n/**\n * Resolves the client `I18n` for the current TanStack Start request without a\n * full `initAdminContext` (no `getPayload`/auth/access). Mirrors the Next.js adapter's\n * `getNextRequestI18n` and feeds the shared `generatePageMetadata`, which only\n * needs `config` + `i18n` to translate admin-page titles.\n */\nexport async function getRequestI18n({ config }: { config: SanitizedConfig }): Promise<I18nClient> {\n  const webRequest = getRequest()\n  const headers = new Headers(webRequest.headers)\n  const cookies = parseCookies(headers)\n\n  const languageCode = getRequestLanguage({ config, cookies, headers })\n\n  return initI18n({\n    config: config.i18n,\n    context: 'client',\n    language: languageCode,\n  })\n}\n"],"names":["initI18n","getRequest","getRequestLanguage","parseCookies","getRequestI18n","config","webRequest","headers","Headers","cookies","languageCode","i18n","context","language"],"mappings":"AAGA,SAASA,QAAQ,QAAQ,2BAA0B;AACnD,SAASC,UAAU,QAAQ,+BAA8B;AACzD,SAASC,kBAAkB,EAAEC,YAAY,QAAQ,UAAS;AAE1D;;;;;CAKC,GACD,OAAO,eAAeC,eAAe,EAAEC,MAAM,EAA+B;IAC1E,MAAMC,aAAaL;IACnB,MAAMM,UAAU,IAAIC,QAAQF,WAAWC,OAAO;IAC9C,MAAME,UAAUN,aAAaI;IAE7B,MAAMG,eAAeR,mBAAmB;QAAEG;QAAQI;QAASF;IAAQ;IAEnE,OAAOP,SAAS;QACdK,QAAQA,OAAOM,IAAI;QACnBC,SAAS;QACTC,UAAUH;IACZ;AACF"}

package/dist/utilities/initAdminContext.server.d.ts

@@ -0,0 +1,9 @@
+import type { ServerAdapter } from 'payload';
+import type { InitAdminContextArgs } from 'payload/internal';
+import './devConfigReload.server.js';
+type TanStackInitAdminContextArgs = {
+    serverAdapter?: ServerAdapter;
+} & Omit<InitAdminContextArgs, 'cache' | 'requestURL' | 'serverAdapter'>;
+export declare const initAdminContext: ({ serverAdapter, ...args }: TanStackInitAdminContextArgs) => Promise<import("payload").AdminContext>;
+export {};
+//# sourceMappingURL=initAdminContext.server.d.ts.map

package/dist/utilities/initAdminContext.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initAdminContext.server.d.ts","sourceRoot":"","sources":["../../src/utilities/initAdminContext.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAO5D,OAAO,6BAA6B,CAAA;AAGpC,KAAK,4BAA4B,GAAG;IAClC,aAAa,CAAC,EAAE,aAAa,CAAA;CAC9B,GAAG,IAAI,CAAC,oBAAoB,EAAE,OAAO,GAAG,YAAY,GAAG,eAAe,CAAC,CAAA;AAExE,eAAO,MAAM,gBAAgB,+BAG1B,4BAA4B,4CAK3B,CAAA"}

package/dist/utilities/initAdminContext.server.js

@@ -0,0 +1,13 @@
+import { getRequest } from '@tanstack/react-start/server';
+import { initAdminContext as initPayloadAdminContext } from 'payload/internal';
+// Registers the dev reload strategy before `initPayloadAdminContext` can build an instance.
+// Side-effect only, and a no-op outside of dev serve.
+import './devConfigReload.server.js';
+import { tanstackServerAdapter } from '../adapters/server.js';
+export const initAdminContext = ({ serverAdapter = tanstackServerAdapter, ...args })=>initPayloadAdminContext({
+        ...args,
+        requestURL: getRequest().url,
+        serverAdapter
+    });
+
+//# sourceMappingURL=initAdminContext.server.js.map

package/dist/utilities/initAdminContext.server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/initAdminContext.server.ts"],"sourcesContent":["import type { ServerAdapter } from 'payload'\nimport type { InitAdminContextArgs } from 'payload/internal'\n\nimport { getRequest } from '@tanstack/react-start/server'\nimport { initAdminContext as initPayloadAdminContext } from 'payload/internal'\n\n// Registers the dev reload strategy before `initPayloadAdminContext` can build an instance.\n// Side-effect only, and a no-op outside of dev serve.\nimport './devConfigReload.server.js'\nimport { tanstackServerAdapter } from '../adapters/server.js'\n\ntype TanStackInitAdminContextArgs = {\n  serverAdapter?: ServerAdapter\n} & Omit<InitAdminContextArgs, 'cache' | 'requestURL' | 'serverAdapter'>\n\nexport const initAdminContext = ({\n  serverAdapter = tanstackServerAdapter,\n  ...args\n}: TanStackInitAdminContextArgs) =>\n  initPayloadAdminContext({\n    ...args,\n    requestURL: getRequest().url,\n    serverAdapter,\n  })\n"],"names":["getRequest","initAdminContext","initPayloadAdminContext","tanstackServerAdapter","serverAdapter","args","requestURL","url"],"mappings":"AAGA,SAASA,UAAU,QAAQ,+BAA8B;AACzD,SAASC,oBAAoBC,uBAAuB,QAAQ,mBAAkB;AAE9E,4FAA4F;AAC5F,sDAAsD;AACtD,OAAO,8BAA6B;AACpC,SAASC,qBAAqB,QAAQ,wBAAuB;AAM7D,OAAO,MAAMF,mBAAmB,CAAC,EAC/BG,gBAAgBD,qBAAqB,EACrC,GAAGE,MAC0B,GAC7BH,wBAAwB;QACtB,GAAGG,IAAI;QACPC,YAAYN,aAAaO,GAAG;QAC5BH;IACF,GAAE"}

package/dist/utilities/routerSearch.d.ts

@@ -0,0 +1,40 @@
+import * as qs from 'qs-esm';
+/**
+ * `parseSearch` for TanStack Router's `createRouter`, required for Payload's
+ * admin UI. Pair with {@link payloadStringifySearch}.
+ *
+ * Payload serializes query state (notably the list-view `where` filter) with
+ * `qs` bracket notation — e.g. `?where[or][0][and][0][x][equals]=y`. TanStack
+ * Router's default serializer treats each bracketed string as a flat key and
+ * JSON-encodes values, so it never round-trips Payload's nested query: every
+ * navigation re-encodes the already-encoded value, exponentially nesting it
+ * (`[true,"[true,\"[true…"]`) until the filter is unusable. Parsing and
+ * stringifying with `qs` (same options as `payload`/`@payloadcms/ui`) keeps
+ * the URL idempotent and the nested `where` intact across navigations.
+ *
+ * This is a router-global serializer: it applies to every route, not just
+ * `/admin`. On your own routes, search values arrive as strings (qs does no
+ * JSON type-coercion), so coerce in `validateSearch` (e.g. `Number(...)`) where
+ * you need numbers or booleans.
+ *
+ * @example
+ * ```ts
+ * import { createRouter } from '@tanstack/react-router'
+ * import { payloadParseSearch, payloadStringifySearch } from '@payloadcms/tanstack-start/shared'
+ *
+ * export function getRouter() {
+ *   return createRouter({
+ *     parseSearch: payloadParseSearch,
+ *     routeTree,
+ *     stringifySearch: payloadStringifySearch,
+ *   })
+ * }
+ * ```
+ */
+export declare const payloadParseSearch: (searchStr: string) => qs.ParsedQs;
+/**
+ * `stringifySearch` for TanStack Router's `createRouter`, required for Payload's
+ * admin UI. Pair with {@link payloadParseSearch}; see it for the full rationale.
+ */
+export declare const payloadStringifySearch: (search: Record<string, unknown>) => string;
+//# sourceMappingURL=routerSearch.d.ts.map

package/dist/utilities/routerSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routerSearch.d.ts","sourceRoot":"","sources":["../../src/utilities/routerSearch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,QAAQ,CAAA;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,kBAAkB,cAAe,MAAM,gBACS,CAAA;AAE7D;;;GAGG;AACH,eAAO,MAAM,sBAAsB,WAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WAGrE,CAAA"}

package/dist/utilities/routerSearch.js

@@ -0,0 +1,45 @@
+import * as qs from 'qs-esm';
+/**
+ * `parseSearch` for TanStack Router's `createRouter`, required for Payload's
+ * admin UI. Pair with {@link payloadStringifySearch}.
+ *
+ * Payload serializes query state (notably the list-view `where` filter) with
+ * `qs` bracket notation — e.g. `?where[or][0][and][0][x][equals]=y`. TanStack
+ * Router's default serializer treats each bracketed string as a flat key and
+ * JSON-encodes values, so it never round-trips Payload's nested query: every
+ * navigation re-encodes the already-encoded value, exponentially nesting it
+ * (`[true,"[true,\"[true…"]`) until the filter is unusable. Parsing and
+ * stringifying with `qs` (same options as `payload`/`@payloadcms/ui`) keeps
+ * the URL idempotent and the nested `where` intact across navigations.
+ *
+ * This is a router-global serializer: it applies to every route, not just
+ * `/admin`. On your own routes, search values arrive as strings (qs does no
+ * JSON type-coercion), so coerce in `validateSearch` (e.g. `Number(...)`) where
+ * you need numbers or booleans.
+ *
+ * @example
+ * ```ts
+ * import { createRouter } from '@tanstack/react-router'
+ * import { payloadParseSearch, payloadStringifySearch } from '@payloadcms/tanstack-start/shared'
+ *
+ * export function getRouter() {
+ *   return createRouter({
+ *     parseSearch: payloadParseSearch,
+ *     routeTree,
+ *     stringifySearch: payloadStringifySearch,
+ *   })
+ * }
+ * ```
+ */ export const payloadParseSearch = (searchStr)=>qs.parse(searchStr, {
+        depth: 10,
+        ignoreQueryPrefix: true
+    });
+/**
+ * `stringifySearch` for TanStack Router's `createRouter`, required for Payload's
+ * admin UI. Pair with {@link payloadParseSearch}; see it for the full rationale.
+ */ export const payloadStringifySearch = (search)=>{
+    const searchStr = qs.stringify(search);
+    return searchStr ? `?${searchStr}` : '';
+};
+
+//# sourceMappingURL=routerSearch.js.map

package/dist/utilities/routerSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/routerSearch.ts"],"sourcesContent":["import * as qs from 'qs-esm'\n\n/**\n * `parseSearch` for TanStack Router's `createRouter`, required for Payload's\n * admin UI. Pair with {@link payloadStringifySearch}.\n *\n * Payload serializes query state (notably the list-view `where` filter) with\n * `qs` bracket notation — e.g. `?where[or][0][and][0][x][equals]=y`. TanStack\n * Router's default serializer treats each bracketed string as a flat key and\n * JSON-encodes values, so it never round-trips Payload's nested query: every\n * navigation re-encodes the already-encoded value, exponentially nesting it\n * (`[true,\"[true,\\\"[true…\"]`) until the filter is unusable. Parsing and\n * stringifying with `qs` (same options as `payload`/`@payloadcms/ui`) keeps\n * the URL idempotent and the nested `where` intact across navigations.\n *\n * This is a router-global serializer: it applies to every route, not just\n * `/admin`. On your own routes, search values arrive as strings (qs does no\n * JSON type-coercion), so coerce in `validateSearch` (e.g. `Number(...)`) where\n * you need numbers or booleans.\n *\n * @example\n * ```ts\n * import { createRouter } from '@tanstack/react-router'\n * import { payloadParseSearch, payloadStringifySearch } from '@payloadcms/tanstack-start/shared'\n *\n * export function getRouter() {\n *   return createRouter({\n *     parseSearch: payloadParseSearch,\n *     routeTree,\n *     stringifySearch: payloadStringifySearch,\n *   })\n * }\n * ```\n */\nexport const payloadParseSearch = (searchStr: string) =>\n  qs.parse(searchStr, { depth: 10, ignoreQueryPrefix: true })\n\n/**\n * `stringifySearch` for TanStack Router's `createRouter`, required for Payload's\n * admin UI. Pair with {@link payloadParseSearch}; see it for the full rationale.\n */\nexport const payloadStringifySearch = (search: Record<string, unknown>) => {\n  const searchStr = qs.stringify(search)\n  return searchStr ? `?${searchStr}` : ''\n}\n"],"names":["qs","payloadParseSearch","searchStr","parse","depth","ignoreQueryPrefix","payloadStringifySearch","search","stringify"],"mappings":"AAAA,YAAYA,QAAQ,SAAQ;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BC,GACD,OAAO,MAAMC,qBAAqB,CAACC,YACjCF,GAAGG,KAAK,CAACD,WAAW;QAAEE,OAAO;QAAIC,mBAAmB;IAAK,GAAE;AAE7D;;;CAGC,GACD,OAAO,MAAMC,yBAAyB,CAACC;IACrC,MAAML,YAAYF,GAAGQ,SAAS,CAACD;IAC/B,OAAOL,YAAY,CAAC,CAAC,EAAEA,WAAW,GAAG;AACvC,EAAC"}

package/dist/utilities/serializeForRsc.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Recursively walk a server-function return value and prepare it for transit
+ * to the client as an RSC payload.
+ *
+ * Mirrors `toSerializable`'s walk (Maps, Sets, Dates, typed arrays, circular
+ * refs) with two key differences:
+ *
+ * 1. React elements are NOT stripped. They are passed through
+ *    `renderServerComponent` from `@tanstack/react-start/rsc` to produce a
+ *    "renderable RSC handle". TanStack Start's `$RSC` serialization adapter
+ *    streams the underlying Flight payload to the client, where it is
+ *    decoded back into a renderable React node. This matches the way
+ *    Next.js's RSC payload format ships React elements over server actions
+ *    and lets server-rendered custom field components (e.g. those returned
+ *    by `buildFormState` / `RenderServerComponent`) survive a `form-state`
+ *    round trip.
+ *
+ * 2. Functions, Symbols, and RegExps are still stripped — TanStack's seroval
+ *    transport cannot handle them, and Payload doesn't intentionally include
+ *    them in server-function return values.
+ *
+ * Use this in `createServerFn` handlers that return Payload form/view state
+ * containing React elements (e.g. `state[path].customComponents.Field`).
+ */
+export declare function serializeForRsc<T>(value: T): Promise<T>;
+//# sourceMappingURL=serializeForRsc.d.ts.map

package/dist/utilities/serializeForRsc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeForRsc.d.ts","sourceRoot":"","sources":["../../src/utilities/serializeForRsc.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAE7D"}

package/dist/utilities/serializeForRsc.js

@@ -0,0 +1,127 @@
+import { renderServerComponent } from '@tanstack/react-start/rsc';
+import { setOwnProperty } from 'payload/shared';
+import { createElement, Fragment } from 'react';
+/**
+ * Recursively walk a server-function return value and prepare it for transit
+ * to the client as an RSC payload.
+ *
+ * Mirrors `toSerializable`'s walk (Maps, Sets, Dates, typed arrays, circular
+ * refs) with two key differences:
+ *
+ * 1. React elements are NOT stripped. They are passed through
+ *    `renderServerComponent` from `@tanstack/react-start/rsc` to produce a
+ *    "renderable RSC handle". TanStack Start's `$RSC` serialization adapter
+ *    streams the underlying Flight payload to the client, where it is
+ *    decoded back into a renderable React node. This matches the way
+ *    Next.js's RSC payload format ships React elements over server actions
+ *    and lets server-rendered custom field components (e.g. those returned
+ *    by `buildFormState` / `RenderServerComponent`) survive a `form-state`
+ *    round trip.
+ *
+ * 2. Functions, Symbols, and RegExps are still stripped — TanStack's seroval
+ *    transport cannot handle them, and Payload doesn't intentionally include
+ *    them in server-function return values.
+ *
+ * Use this in `createServerFn` handlers that return Payload form/view state
+ * containing React elements (e.g. `state[path].customComponents.Field`).
+ */ export async function serializeForRsc(value) {
+    return await walk(value, new WeakMap(), new WeakSet());
+}
+async function walk(value, cache, ancestors) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    const t = typeof value;
+    if (t === 'function' || t === 'symbol') {
+        return undefined;
+    }
+    if (t !== 'object') {
+        return value;
+    }
+    const obj = value;
+    if (typeof obj.$$typeof === 'symbol') {
+        return await renderServerComponent(value);
+    }
+    if (ancestors.has(obj)) {
+        return undefined;
+    }
+    if (cache.has(obj)) {
+        return cache.get(obj);
+    }
+    if (obj instanceof Date) {
+        return obj;
+    }
+    if (obj instanceof RegExp) {
+        return undefined;
+    }
+    ancestors.add(obj);
+    if (obj instanceof Map) {
+        const cleaned = new Map();
+        cache.set(obj, cleaned);
+        for (const [k, v] of obj){
+            const cv = await walk(v, cache, ancestors);
+            if (cv !== undefined) {
+                cleaned.set(k, cv);
+            }
+        }
+        ancestors.delete(obj);
+        return cleaned;
+    }
+    if (obj instanceof Set) {
+        const cleaned = new Set();
+        cache.set(obj, cleaned);
+        for (const v of obj){
+            const cv = await walk(v, cache, ancestors);
+            if (cv !== undefined) {
+                cleaned.add(cv);
+            }
+        }
+        ancestors.delete(obj);
+        return cleaned;
+    }
+    if (Array.isArray(obj)) {
+        // An array consisting entirely of React elements (e.g. a field's
+        // `beforeInput` / `afterInput` component list, produced by
+        // `RenderServerComponent`) must be rendered as a SINGLE RSC handle.
+        // Converting each element individually below turns every item into its own
+        // `renderServerComponent` handle, which drops the element's React `key` —
+        // the client then renders `{[handle, handle]}` as unkeyed array children
+        // and React warns "Each child in a list should have a unique key prop".
+        // Payload always renders these component arrays wholesale (`{BeforeInput}`),
+        // so collapsing them into one Fragment-rendered handle is render-equivalent
+        // and keeps the per-element keys intact inside the single Flight payload.
+        const items = obj.filter((item)=>item !== null && item !== undefined);
+        const isReactElementArray = items.length > 0 && items.every((item)=>typeof item === 'object' && typeof item.$$typeof === 'symbol');
+        if (isReactElementArray) {
+            ancestors.delete(obj);
+            return await renderServerComponent(createElement(Fragment, null, ...obj));
+        }
+        const arr = [];
+        cache.set(obj, arr);
+        for (const item of obj){
+            arr.push(await walk(item, cache, ancestors));
+        }
+        ancestors.delete(obj);
+        return arr;
+    }
+    if (ArrayBuffer.isView(obj)) {
+        ancestors.delete(obj);
+        return obj;
+    }
+    const result = {};
+    cache.set(obj, result);
+    for (const key of Object.keys(obj)){
+        const v = await walk(obj[key], cache, ancestors);
+        if (v !== undefined) {
+            setOwnProperty({
+                key,
+                target: result,
+                value: v
+            });
+        }
+    }
+    ancestors.delete(obj);
+    return result;
+}
+
+//# sourceMappingURL=serializeForRsc.js.map

package/dist/utilities/serializeForRsc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/serializeForRsc.ts"],"sourcesContent":["import type React from 'react'\n\nimport { renderServerComponent } from '@tanstack/react-start/rsc'\nimport { setOwnProperty } from 'payload/shared'\nimport { createElement, Fragment } from 'react'\n\n/**\n * Recursively walk a server-function return value and prepare it for transit\n * to the client as an RSC payload.\n *\n * Mirrors `toSerializable`'s walk (Maps, Sets, Dates, typed arrays, circular\n * refs) with two key differences:\n *\n * 1. React elements are NOT stripped. They are passed through\n *    `renderServerComponent` from `@tanstack/react-start/rsc` to produce a\n *    \"renderable RSC handle\". TanStack Start's `$RSC` serialization adapter\n *    streams the underlying Flight payload to the client, where it is\n *    decoded back into a renderable React node. This matches the way\n *    Next.js's RSC payload format ships React elements over server actions\n *    and lets server-rendered custom field components (e.g. those returned\n *    by `buildFormState` / `RenderServerComponent`) survive a `form-state`\n *    round trip.\n *\n * 2. Functions, Symbols, and RegExps are still stripped — TanStack's seroval\n *    transport cannot handle them, and Payload doesn't intentionally include\n *    them in server-function return values.\n *\n * Use this in `createServerFn` handlers that return Payload form/view state\n * containing React elements (e.g. `state[path].customComponents.Field`).\n */\nexport async function serializeForRsc<T>(value: T): Promise<T> {\n  return (await walk(value, new WeakMap<object, unknown>(), new WeakSet<object>())) as T\n}\n\nasync function walk(\n  value: unknown,\n  cache: WeakMap<object, unknown>,\n  ancestors: WeakSet<object>,\n): Promise<unknown> {\n  if (value === null || value === undefined) {\n    return value\n  }\n\n  const t = typeof value\n  if (t === 'function' || t === 'symbol') {\n    return undefined\n  }\n  if (t !== 'object') {\n    return value\n  }\n\n  const obj = value as Record<string, unknown>\n\n  if (typeof obj.$$typeof === 'symbol') {\n    return await renderServerComponent(value as React.ReactElement)\n  }\n\n  if (ancestors.has(obj)) {\n    return undefined\n  }\n\n  if (cache.has(obj)) {\n    return cache.get(obj)\n  }\n\n  if (obj instanceof Date) {\n    return obj\n  }\n\n  if (obj instanceof RegExp) {\n    return undefined\n  }\n\n  ancestors.add(obj)\n\n  if (obj instanceof Map) {\n    const cleaned = new Map()\n    cache.set(obj, cleaned)\n    for (const [k, v] of obj) {\n      const cv = await walk(v, cache, ancestors)\n      if (cv !== undefined) {\n        cleaned.set(k, cv)\n      }\n    }\n    ancestors.delete(obj)\n    return cleaned\n  }\n\n  if (obj instanceof Set) {\n    const cleaned = new Set()\n    cache.set(obj, cleaned)\n    for (const v of obj) {\n      const cv = await walk(v, cache, ancestors)\n      if (cv !== undefined) {\n        cleaned.add(cv)\n      }\n    }\n    ancestors.delete(obj)\n    return cleaned\n  }\n\n  if (Array.isArray(obj)) {\n    // An array consisting entirely of React elements (e.g. a field's\n    // `beforeInput` / `afterInput` component list, produced by\n    // `RenderServerComponent`) must be rendered as a SINGLE RSC handle.\n    // Converting each element individually below turns every item into its own\n    // `renderServerComponent` handle, which drops the element's React `key` —\n    // the client then renders `{[handle, handle]}` as unkeyed array children\n    // and React warns \"Each child in a list should have a unique key prop\".\n    // Payload always renders these component arrays wholesale (`{BeforeInput}`),\n    // so collapsing them into one Fragment-rendered handle is render-equivalent\n    // and keeps the per-element keys intact inside the single Flight payload.\n    const items = obj.filter((item) => item !== null && item !== undefined)\n    const isReactElementArray =\n      items.length > 0 &&\n      items.every(\n        (item) =>\n          typeof item === 'object' && typeof (item as { $$typeof?: unknown }).$$typeof === 'symbol',\n      )\n    if (isReactElementArray) {\n      ancestors.delete(obj)\n      return await renderServerComponent(\n        createElement(Fragment, null, ...(obj as React.ReactNode[])),\n      )\n    }\n\n    const arr: unknown[] = []\n    cache.set(obj, arr)\n    for (const item of obj) {\n      arr.push(await walk(item, cache, ancestors))\n    }\n    ancestors.delete(obj)\n    return arr\n  }\n\n  if (ArrayBuffer.isView(obj)) {\n    ancestors.delete(obj)\n    return obj\n  }\n\n  const result: Record<string, unknown> = {}\n  cache.set(obj, result)\n  for (const key of Object.keys(obj)) {\n    const v = await walk(obj[key], cache, ancestors)\n    if (v !== undefined) {\n      setOwnProperty({ key, target: result, value: v })\n    }\n  }\n  ancestors.delete(obj)\n  return result\n}\n"],"names":["renderServerComponent","setOwnProperty","createElement","Fragment","serializeForRsc","value","walk","WeakMap","WeakSet","cache","ancestors","undefined","t","obj","$$typeof","has","get","Date","RegExp","add","Map","cleaned","set","k","v","cv","delete","Set","Array","isArray","items","filter","item","isReactElementArray","length","every","arr","push","ArrayBuffer","isView","result","key","Object","keys","target"],"mappings":"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"}

package/dist/utilities/serverFunctionClient.d.ts

@@ -0,0 +1,29 @@
+import type { ServerFunctionClient, ServerFunctionClientArgs } from 'payload';
+/**
+ * Builds the client-side `ServerFunctionClient` wired into
+ * `RootProvider.serverFunction`, given the app's `createServerFn`-based
+ * dispatcher (`runServerFn`).
+ *
+ * Strips functions / symbols / RegExps / React elements from the args before
+ * dispatching: the previous `fetch + JSON.stringify` pipeline silently dropped
+ * those, but TanStack Start's seroval-based wire format errors instead. We
+ * mirror the relaxed behaviour so existing callers (e.g. `getFormState` in
+ * `ServerFunctionsProvider`) that may pass the live form state — which can
+ * carry stray functions — keep working without each call site sanitising.
+ *
+ * Delegates to `runServerFn`, so the response (including any RSC handles for
+ * server-rendered custom components) is decoded by TanStack Start back into
+ * renderable React nodes on the client.
+ */
+export declare function createServerFunctionClient({ runServerFn, }: {
+    runServerFn: (input: {
+        data: ServerFunctionClientArgs;
+    }) => Promise<unknown>;
+}): ServerFunctionClient;
+/**
+ * Recursively removes values TanStack Start's seroval wire format cannot
+ * serialize (functions, symbols, RegExps, React elements, cyclic refs) and
+ * normalizes `Date` subclasses to plain `Date`.
+ */
+export declare function stripUnserializable(value: unknown, cache?: WeakMap<object, unknown>, ancestors?: WeakSet<object>): unknown;
+//# sourceMappingURL=serverFunctionClient.d.ts.map

package/dist/utilities/serverFunctionClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverFunctionClient.d.ts","sourceRoot":"","sources":["../../src/utilities/serverFunctionClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAI7E;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CAAC,EACzC,WAAW,GACZ,EAAE;IACD,WAAW,EAAE,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,wBAAwB,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CAC7E,GAAG,oBAAoB,CAKvB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,KAAK,GAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAiB,EAC/C,SAAS,GAAE,OAAO,CAAC,MAAM,CAAiB,GACzC,OAAO,CA4FT"}

package/dist/utilities/serverFunctionClient.js

@@ -0,0 +1,114 @@
+import { setOwnProperty } from 'payload/shared';
+/**
+ * Builds the client-side `ServerFunctionClient` wired into
+ * `RootProvider.serverFunction`, given the app's `createServerFn`-based
+ * dispatcher (`runServerFn`).
+ *
+ * Strips functions / symbols / RegExps / React elements from the args before
+ * dispatching: the previous `fetch + JSON.stringify` pipeline silently dropped
+ * those, but TanStack Start's seroval-based wire format errors instead. We
+ * mirror the relaxed behaviour so existing callers (e.g. `getFormState` in
+ * `ServerFunctionsProvider`) that may pass the live form state — which can
+ * carry stray functions — keep working without each call site sanitising.
+ *
+ * Delegates to `runServerFn`, so the response (including any RSC handles for
+ * server-rendered custom components) is decoded by TanStack Start back into
+ * renderable React nodes on the client.
+ */ export function createServerFunctionClient({ runServerFn }) {
+    return async (args)=>{
+        const safeArgs = stripUnserializable(args);
+        return await runServerFn({
+            data: safeArgs
+        });
+    };
+}
+/**
+ * Recursively removes values TanStack Start's seroval wire format cannot
+ * serialize (functions, symbols, RegExps, React elements, cyclic refs) and
+ * normalizes `Date` subclasses to plain `Date`.
+ */ export function stripUnserializable(value, cache = new WeakMap(), ancestors = new WeakSet()) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    const t = typeof value;
+    if (t === 'function' || t === 'symbol') {
+        return undefined;
+    }
+    if (t !== 'object') {
+        return value;
+    }
+    const obj = value;
+    if (typeof obj.$$typeof === 'symbol') {
+        return undefined;
+    }
+    if (ancestors.has(obj)) {
+        return undefined;
+    }
+    if (cache.has(obj)) {
+        return cache.get(obj);
+    }
+    if (obj instanceof Date) {
+        // Normalize to a plain `Date`. Subclasses (e.g. `@date-fns/tz`'s `TZDate`,
+        // used by the schedule-publish drawer) are `instanceof Date` but have a
+        // different `constructor`, which TanStack Start's seroval serializer
+        // rejects with "The value [object Date] ... cannot be parsed/serialized".
+        return new Date(obj.getTime());
+    }
+    if (obj instanceof RegExp) {
+        return undefined;
+    }
+    ancestors.add(obj);
+    if (obj instanceof Map) {
+        const cleaned = new Map();
+        cache.set(obj, cleaned);
+        for (const [k, v] of obj){
+            const cv = stripUnserializable(v, cache, ancestors);
+            if (cv !== undefined) {
+                cleaned.set(k, cv);
+            }
+        }
+        ancestors.delete(obj);
+        return cleaned;
+    }
+    if (obj instanceof Set) {
+        const cleaned = new Set();
+        cache.set(obj, cleaned);
+        for (const v of obj){
+            const cv = stripUnserializable(v, cache, ancestors);
+            if (cv !== undefined) {
+                cleaned.add(cv);
+            }
+        }
+        ancestors.delete(obj);
+        return cleaned;
+    }
+    if (Array.isArray(obj)) {
+        const arr = [];
+        cache.set(obj, arr);
+        for (const item of obj){
+            arr.push(stripUnserializable(item, cache, ancestors));
+        }
+        ancestors.delete(obj);
+        return arr;
+    }
+    if (ArrayBuffer.isView(obj)) {
+        ancestors.delete(obj);
+        return obj;
+    }
+    const result = {};
+    cache.set(obj, result);
+    for (const key of Object.keys(obj)){
+        const v = stripUnserializable(obj[key], cache, ancestors);
+        if (v !== undefined) {
+            setOwnProperty({
+                key,
+                target: result,
+                value: v
+            });
+        }
+    }
+    ancestors.delete(obj);
+    return result;
+}
+
+//# sourceMappingURL=serverFunctionClient.js.map

package/dist/utilities/serverFunctionClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/serverFunctionClient.ts"],"sourcesContent":["import type { ServerFunctionClient, ServerFunctionClientArgs } from 'payload'\n\nimport { setOwnProperty } from 'payload/shared'\n\n/**\n * Builds the client-side `ServerFunctionClient` wired into\n * `RootProvider.serverFunction`, given the app's `createServerFn`-based\n * dispatcher (`runServerFn`).\n *\n * Strips functions / symbols / RegExps / React elements from the args before\n * dispatching: the previous `fetch + JSON.stringify` pipeline silently dropped\n * those, but TanStack Start's seroval-based wire format errors instead. We\n * mirror the relaxed behaviour so existing callers (e.g. `getFormState` in\n * `ServerFunctionsProvider`) that may pass the live form state — which can\n * carry stray functions — keep working without each call site sanitising.\n *\n * Delegates to `runServerFn`, so the response (including any RSC handles for\n * server-rendered custom components) is decoded by TanStack Start back into\n * renderable React nodes on the client.\n */\nexport function createServerFunctionClient({\n  runServerFn,\n}: {\n  runServerFn: (input: { data: ServerFunctionClientArgs }) => Promise<unknown>\n}): ServerFunctionClient {\n  return (async (args: ServerFunctionClientArgs) => {\n    const safeArgs = stripUnserializable(args) as ServerFunctionClientArgs\n    return await runServerFn({ data: safeArgs })\n  }) as ServerFunctionClient\n}\n\n/**\n * Recursively removes values TanStack Start's seroval wire format cannot\n * serialize (functions, symbols, RegExps, React elements, cyclic refs) and\n * normalizes `Date` subclasses to plain `Date`.\n */\nexport function stripUnserializable(\n  value: unknown,\n  cache: WeakMap<object, unknown> = new WeakMap(),\n  ancestors: WeakSet<object> = new WeakSet(),\n): unknown {\n  if (value === null || value === undefined) {\n    return value\n  }\n\n  const t = typeof value\n  if (t === 'function' || t === 'symbol') {\n    return undefined\n  }\n  if (t !== 'object') {\n    return value\n  }\n\n  const obj = value as Record<string, unknown>\n\n  if (typeof obj.$$typeof === 'symbol') {\n    return undefined\n  }\n\n  if (ancestors.has(obj)) {\n    return undefined\n  }\n\n  if (cache.has(obj)) {\n    return cache.get(obj)\n  }\n\n  if (obj instanceof Date) {\n    // Normalize to a plain `Date`. Subclasses (e.g. `@date-fns/tz`'s `TZDate`,\n    // used by the schedule-publish drawer) are `instanceof Date` but have a\n    // different `constructor`, which TanStack Start's seroval serializer\n    // rejects with \"The value [object Date] ... cannot be parsed/serialized\".\n    return new Date(obj.getTime())\n  }\n\n  if (obj instanceof RegExp) {\n    return undefined\n  }\n\n  ancestors.add(obj)\n\n  if (obj instanceof Map) {\n    const cleaned = new Map()\n    cache.set(obj, cleaned)\n    for (const [k, v] of obj) {\n      const cv = stripUnserializable(v, cache, ancestors)\n      if (cv !== undefined) {\n        cleaned.set(k, cv)\n      }\n    }\n    ancestors.delete(obj)\n    return cleaned\n  }\n\n  if (obj instanceof Set) {\n    const cleaned = new Set()\n    cache.set(obj, cleaned)\n    for (const v of obj) {\n      const cv = stripUnserializable(v, cache, ancestors)\n      if (cv !== undefined) {\n        cleaned.add(cv)\n      }\n    }\n    ancestors.delete(obj)\n    return cleaned\n  }\n\n  if (Array.isArray(obj)) {\n    const arr: unknown[] = []\n    cache.set(obj, arr)\n    for (const item of obj) {\n      arr.push(stripUnserializable(item, cache, ancestors))\n    }\n    ancestors.delete(obj)\n    return arr\n  }\n\n  if (ArrayBuffer.isView(obj)) {\n    ancestors.delete(obj)\n    return obj\n  }\n\n  const result: Record<string, unknown> = {}\n  cache.set(obj, result)\n  for (const key of Object.keys(obj)) {\n    const v = stripUnserializable(obj[key], cache, ancestors)\n    if (v !== undefined) {\n      setOwnProperty({ key, target: result, value: v })\n    }\n  }\n  ancestors.delete(obj)\n  return result\n}\n"],"names":["setOwnProperty","createServerFunctionClient","runServerFn","args","safeArgs","stripUnserializable","data","value","cache","WeakMap","ancestors","WeakSet","undefined","t","obj","$$typeof","has","get","Date","getTime","RegExp","add","Map","cleaned","set","k","v","cv","delete","Set","Array","isArray","arr","item","push","ArrayBuffer","isView","result","key","Object","keys","target"],"mappings":"AAEA,SAASA,cAAc,QAAQ,iBAAgB;AAE/C;;;;;;;;;;;;;;;CAeC,GACD,OAAO,SAASC,2BAA2B,EACzCC,WAAW,EAGZ;IACC,OAAQ,OAAOC;QACb,MAAMC,WAAWC,oBAAoBF;QACrC,OAAO,MAAMD,YAAY;YAAEI,MAAMF;QAAS;IAC5C;AACF;AAEA;;;;CAIC,GACD,OAAO,SAASC,oBACdE,KAAc,EACdC,QAAkC,IAAIC,SAAS,EAC/CC,YAA6B,IAAIC,SAAS;IAE1C,IAAIJ,UAAU,QAAQA,UAAUK,WAAW;QACzC,OAAOL;IACT;IAEA,MAAMM,IAAI,OAAON;IACjB,IAAIM,MAAM,cAAcA,MAAM,UAAU;QACtC,OAAOD;IACT;IACA,IAAIC,MAAM,UAAU;QAClB,OAAON;IACT;IAEA,MAAMO,MAAMP;IAEZ,IAAI,OAAOO,IAAIC,QAAQ,KAAK,UAAU;QACpC,OAAOH;IACT;IAEA,IAAIF,UAAUM,GAAG,CAACF,MAAM;QACtB,OAAOF;IACT;IAEA,IAAIJ,MAAMQ,GAAG,CAACF,MAAM;QAClB,OAAON,MAAMS,GAAG,CAACH;IACnB;IAEA,IAAIA,eAAeI,MAAM;QACvB,2EAA2E;QAC3E,wEAAwE;QACxE,qEAAqE;QACrE,0EAA0E;QAC1E,OAAO,IAAIA,KAAKJ,IAAIK,OAAO;IAC7B;IAEA,IAAIL,eAAeM,QAAQ;QACzB,OAAOR;IACT;IAEAF,UAAUW,GAAG,CAACP;IAEd,IAAIA,eAAeQ,KAAK;QACtB,MAAMC,UAAU,IAAID;QACpBd,MAAMgB,GAAG,CAACV,KAAKS;QACf,KAAK,MAAM,CAACE,GAAGC,EAAE,IAAIZ,IAAK;YACxB,MAAMa,KAAKtB,oBAAoBqB,GAAGlB,OAAOE;YACzC,IAAIiB,OAAOf,WAAW;gBACpBW,QAAQC,GAAG,CAACC,GAAGE;YACjB;QACF;QACAjB,UAAUkB,MAAM,CAACd;QACjB,OAAOS;IACT;IAEA,IAAIT,eAAee,KAAK;QACtB,MAAMN,UAAU,IAAIM;QACpBrB,MAAMgB,GAAG,CAACV,KAAKS;QACf,KAAK,MAAMG,KAAKZ,IAAK;YACnB,MAAMa,KAAKtB,oBAAoBqB,GAAGlB,OAAOE;YACzC,IAAIiB,OAAOf,WAAW;gBACpBW,QAAQF,GAAG,CAACM;YACd;QACF;QACAjB,UAAUkB,MAAM,CAACd;QACjB,OAAOS;IACT;IAEA,IAAIO,MAAMC,OAAO,CAACjB,MAAM;QACtB,MAAMkB,MAAiB,EAAE;QACzBxB,MAAMgB,GAAG,CAACV,KAAKkB;QACf,KAAK,MAAMC,QAAQnB,IAAK;YACtBkB,IAAIE,IAAI,CAAC7B,oBAAoB4B,MAAMzB,OAAOE;QAC5C;QACAA,UAAUkB,MAAM,CAACd;QACjB,OAAOkB;IACT;IAEA,IAAIG,YAAYC,MAAM,CAACtB,MAAM;QAC3BJ,UAAUkB,MAAM,CAACd;QACjB,OAAOA;IACT;IAEA,MAAMuB,SAAkC,CAAC;IACzC7B,MAAMgB,GAAG,CAACV,KAAKuB;IACf,KAAK,MAAMC,OAAOC,OAAOC,IAAI,CAAC1B,KAAM;QAClC,MAAMY,IAAIrB,oBAAoBS,GAAG,CAACwB,IAAI,EAAE9B,OAAOE;QAC/C,IAAIgB,MAAMd,WAAW;YACnBZ,eAAe;gBAAEsC;gBAAKG,QAAQJ;gBAAQ9B,OAAOmB;YAAE;QACjD;IACF;IACAhB,UAAUkB,MAAM,CAACd;IACjB,OAAOuB;AACT"}

package/dist/utilities/toSerializable.d.ts

@@ -0,0 +1,11 @@
+import type { Serializable, SerializableExtensions } from '@tanstack/react-router';
+/** A record sanitized for TanStack's server-function transport. */
+export type SerializableRecord = Record<string, unknown> & SerializableExtensions['TsrSerializable'];
+/**
+ * Removes values unsupported by TanStack's serializer. Trusted serializable
+ * additions are merged afterward so opaque handles such as RSC payloads are
+ * preserved while the source record is sanitized.
+ */
+export declare function toSerializable<T>(value: T): T;
+export declare function toSerializable(value: Record<string, unknown>, additions: Record<string, Serializable>): SerializableRecord;
+//# sourceMappingURL=toSerializable.d.ts.map