@valbuild/tanstack 0.124.0

package/client/dist/valbuild-tanstack-client.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./valbuild-tanstack-client.cjs.prod.js");
+} else {
+  module.exports = require("./valbuild-tanstack-client.cjs.dev.js");
+}

package/client/dist/valbuild-tanstack-client.cjs.prod.js

@@ -0,0 +1,288 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var routeFromVal = require('../../dist/routeFromVal-6693e037.cjs.prod.js');
+var core = require('@valbuild/core');
+var stega = require('@valbuild/react/stega');
+var React = require('react');
+var ValOverlayContext = require('../../dist/ValOverlayContext-abd6ab9a.cjs.prod.js');
+require('../../dist/createForOfIteratorHelper-0324e063.cjs.prod.js');
+require('@valbuild/shared/client');
+require('@valbuild/core/patch');
+require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+function useValStega(selector) {
+  var valOverlayContext = ValOverlayContext.useValOverlayContext();
+  var moduleIds = React__default["default"].useMemo(function () {
+    return stega.getModuleIds(selector);
+  }, [selector]);
+  var store = valOverlayContext.store;
+  var moduleMap = React__default["default"].useSyncExternalStore(store ? store.subscribe(moduleIds) : function () {
+    return function () {};
+  }, store ? store.getSnapshot(moduleIds) : function () {
+    return;
+  }, store ? store.getServerSnapshot(moduleIds) : function () {
+    return;
+  });
+  // Suspense gate. `suspend` is false during SSR and hydration (so the static
+  // committed source is rendered, matching the server HTML exactly) and is
+  // activated by ValProvider after hydration — inside a transition — when the
+  // `suspend` prop is set AND the Val Enable cookie is present (checked
+  // client-side; the server store is never populated). It never deactivates.
+  // The production path (no cookie) skips the call entirely. The
+  // `draftMode !== false` check is a release valve: with draft mode off the
+  // store never receives source updates, so waitForLoad could only ever
+  // resolve via its timeout — and would then re-suspend on every subsequent
+  // render since the resolved promise is evicted from the cache. draftMode is
+  // null until the first /draft/stat poll resolves; null -> true keeps
+  // suspending, -> false only unblocks, and false -> true happens only on an
+  // explicit draft-mode enable which already refreshes the route.
+  // React.use is allowed inside conditionals — it is not a hook.
+  /**
+   * Wait until draft mode is KNOWN, before anything else.
+   *
+   * `draftMode === null` means `/draft/stat` has not answered yet, and the
+   * `getModule` below treats it as off — so a render that slips through here
+   * while it is unknown resolves against committed source. For an ordinary field
+   * that is a flash of published content; for `useValRoute` on a route that
+   * exists only in an uncommitted patch it is `notFound()`, which no later
+   * answer can undo. That was the 404 on a page you had just created.
+   */
+  if (valOverlayContext.suspend && valOverlayContext.draftMode === null && valOverlayContext.draftModeReady) {
+    React__default["default"].use(valOverlayContext.draftModeReady);
+  }
+  /**
+   * Then wait for the draft sources — but only while more might be coming.
+   *
+   * `draftSourcesSynced` is the editor saying it has sent everything it holds,
+   * and it only holds modules with patches: an unedited module has no draft, so
+   * nothing is ever sent for it. Without that signal this could not tell "not
+   * sent yet" from "nothing to send", and waited out `waitForLoad`'s ten second
+   * timeout once per unedited module the page reads — which is what left a newly
+   * created page sitting on its loading fallback.
+   */
+  if (valOverlayContext.suspend && valOverlayContext.draftMode !== false && !valOverlayContext.draftSourcesSynced && store && !store.hasAllLoaded(moduleIds)) {
+    React__default["default"].use(store.waitForLoad(moduleIds));
+  }
+  return stega.stegaEncode(selector, {
+    disabled: !valOverlayContext.draftMode,
+    getModule: function getModule(moduleId) {
+      if (moduleMap && valOverlayContext.draftMode) {
+        return moduleMap[moduleId];
+      }
+    }
+  });
+}
+
+/**
+ * The module's source as the overlay currently sees it — i.e. WITH the editor's
+ * unpublished changes — or undefined when there is no draft view to be had
+ * (production, draft mode off, or the overlay has not pushed this module yet).
+ *
+ * This is what lets the single-entry readers show drafts. They otherwise resolve
+ * an entry through its local import thunk, which is the content that was bundled:
+ * correct in production, and stale the moment anyone edits in the Studio.
+ */
+function useDraftModuleSource(moduleFilePath) {
+  var valOverlayContext = ValOverlayContext.useValOverlayContext();
+  var store = valOverlayContext.store;
+  var moduleIds = React__default["default"].useMemo(function () {
+    return moduleFilePath ? [moduleFilePath] : [];
+  }, [moduleFilePath]);
+  var moduleMap = React__default["default"].useSyncExternalStore(store ? store.subscribe(moduleIds) : function () {
+    return function () {};
+  }, store ? store.getSnapshot(moduleIds) : function () {
+    return undefined;
+  }, store ? store.getServerSnapshot(moduleIds) : function () {
+    return undefined;
+  });
+  if (!valOverlayContext.draftMode || !moduleFilePath) {
+    return undefined;
+  }
+  return moduleMap === null || moduleMap === void 0 ? void 0 : moduleMap[moduleFilePath];
+}
+
+/**
+ * What the draft view says about one `.jsonValues()` entry.
+ *
+ * Mirrors the server-side rule in `fetchValKey`/`fetchValRoute`: a draft view
+ * that HAS an answer wins, including the answer "this entry is gone", and the
+ * bundled content is used only when there is no draft view.
+ */
+function draftJsonEntry(draftSource, key) {
+  if (draftSource === undefined || draftSource === null || routeFromVal._typeof(draftSource) !== "object" || Array.isArray(draftSource)) {
+    return {
+      status: "unavailable"
+    };
+  }
+  var entry = draftSource[key];
+  if (entry === undefined) {
+    // The module IS in the draft view and this key is not: it was deleted.
+    return {
+      status: "absent"
+    };
+  }
+  if (core.Internal.isJson(entry)) {
+    // An un-loaded marker: the Studio has not fetched this entry's content, so
+    // the draft view cannot answer. (The engine asks for entries that pending
+    // patches touch, so this resolves itself for anything actually edited.)
+    return {
+      status: "unavailable"
+    };
+  }
+  return {
+    status: "content",
+    content: entry
+  };
+}
+
+// The (loosened) content type a single `.jsonValues()` entry resolves to.
+
+// Module-level cache of in-flight/resolved entry loads, so `React.use` gets a
+// stable promise across renders (keyed by module path + entry key).
+var jsonEntryPromiseCache = new Map();
+
+/**
+ * Client counterpart to `fetchValKey`: resolves a SINGLE `.jsonValues()` entry
+ * by key, loading only that entry's backing `*.val.json` (one dynamic import).
+ * Suspends (via `React.use`) until the entry loads, so it must be rendered
+ * inside a `<Suspense>` boundary.
+ *
+ * In draft mode it renders the editor's unpublished content, taken from the
+ * overlay; in production — and whenever there is no draft view — it resolves the
+ * entry's lazy import thunk from the local module.
+ */
+function useValKeyStega(selector, key) {
+  var valOverlayContext = ValOverlayContext.useValOverlayContext();
+  var moduleFilePath = selector && core.Internal.getValPath(selector);
+  var draftSource = useDraftModuleSource(moduleFilePath || undefined);
+  var draft = draftJsonEntry(draftSource, key);
+  if (draft.status === "absent") {
+    // Deleted in the draft state. Falling back to the bundled entry here would
+    // render content the editor has just removed.
+    return undefined;
+  }
+  var content = draft.status === "content" ? draft.content : undefined;
+  if (content === undefined) {
+    content = readCommittedJsonEntry(selector, key);
+  }
+  return stega.stegaEncode(content, {
+    disabled: !valOverlayContext.draftMode,
+    root: routeFromVal.getJsonEntryStegaRoot(selector, key)
+  });
+}
+
+/**
+ * The entry's content as bundled: its lazy import thunk, resolved through
+ * `React.use` so the caller suspends until it lands.
+ *
+ * Deliberately not named `use*`: it is called conditionally, which is fine
+ * because `React.use` is not a hook, but a `use*` name would read like one.
+ */
+function readCommittedJsonEntry(selector, key) {
+  var _Internal$getValPath;
+  var source = selector && core.Internal.getSource(selector);
+  var marker = source && routeFromVal._typeof(source) === "object" ? source[key] : undefined;
+  if (!core.Internal.isJson(marker)) {
+    return undefined;
+  }
+  var thunk = core.Internal.getJsonImport(marker);
+  if (!thunk) {
+    return undefined;
+  }
+  var cacheKey = "".concat((_Internal$getValPath = core.Internal.getValPath(selector)) !== null && _Internal$getValPath !== void 0 ? _Internal$getValPath : "", " ").concat(key);
+  var promise = jsonEntryPromiseCache.get(cacheKey);
+  if (!promise) {
+    promise = thunk().then(function (mod) {
+      return mod["default"];
+    });
+    jsonEntryPromiseCache.set(cacheKey, promise);
+  }
+  return React__default["default"].use(promise);
+}
+function resolveParams(params) {
+  if (!params) {
+    return null;
+  }
+  if ("then" in params) {
+    // Defensive guard: peerDependencies declare React >=19, but if a consumer
+    // somehow ends up on React 18 with a promise params arg, surface a
+    // diagnosable error instead of a cryptic `TypeError: React.use is not a
+    // function`. Callers treat null as the error sentinel.
+    if (!("use" in React__default["default"])) {
+      console.error("Val: useValRoute received a Promise params argument but React.use is unavailable. Upgrade to React 19+ or pre-resolve the promise before passing it.");
+      return null;
+    }
+    return React__default["default"].use(params);
+  }
+  return params;
+}
+function useValRouteStega(selector, params) {
+  var valOverlayContext = ValOverlayContext.useValOverlayContext();
+  // Both called unconditionally to keep hook order stable. For a `.jsonValues()`
+  // router `val` is unused (we resolve a single entry below instead); for any
+  // other router `draftSource` is.
+  var val = useValStega(selector);
+  var draftSource = useDraftModuleSource(selector && core.Internal.getValPath(selector) || undefined);
+  var resolvedParams = resolveParams(params);
+  // Careful: null means there was an error - undefined means no params
+  if (resolvedParams === null) {
+    return null;
+  }
+  var path = selector && core.Internal.getValPath(selector);
+  var schema = selector && core.Internal.getSchema(selector);
+  // `.jsonValues()` router: map params → the entry key and load ONLY that
+  // entry's backing `*.val.json` (one dynamic import), like `useValKey`.
+  if (routeFromVal.isJsonValuesRecordSchema(schema)) {
+    var source = selector && core.Internal.getSource(selector);
+    var url = routeFromVal.getValRouteUrlFromVal(resolvedParams || {}, "useValRoute", path, schema, source);
+    if (!url) {
+      return null;
+    }
+    var draft = draftJsonEntry(draftSource, url);
+    if (draft.status === "absent") {
+      // The draft state says this route is gone — see useValKeyStega.
+      return null;
+    }
+    var content = draft.status === "content" ? draft.content : undefined;
+    if (content === undefined) {
+      content = readCommittedJsonEntry(selector, url);
+    }
+    if (content === undefined) {
+      return null;
+    }
+    return stega.stegaEncode(content, {
+      disabled: !valOverlayContext.draftMode,
+      root: routeFromVal.getJsonEntryStegaRoot(selector, url)
+    });
+  }
+  var route = routeFromVal.initValRouteFromVal(resolvedParams || {}, "useValRoute", path, schema, val);
+  return route;
+}
+function useValRouteUrl(selector, params) {
+  var val = useValStega(selector);
+  var resolvedParams = params === undefined ? undefined : resolveParams(params);
+  // Careful: null means there was an error - undefined means no params
+  if (resolvedParams === null) {
+    return null;
+  }
+  var route = routeFromVal.getValRouteUrlFromVal(resolvedParams || {}, "useValRouteUrl", selector && core.Internal.getValPath(selector), selector && core.Internal.getSchema(selector), val);
+  return route;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function initValClient(config) {
+  return {
+    useValStega: useValStega,
+    useValKeyStega: useValKeyStega,
+    useValRouteStega: useValRouteStega,
+    useValRouteUrl: useValRouteUrl
+  };
+}
+
+exports.initValClient = initValClient;

package/client/dist/valbuild-tanstack-client.esm.js

@@ -0,0 +1,280 @@
+import { g as getJsonEntryStegaRoot, _ as _typeof, i as isJsonValuesRecordSchema, a as getValRouteUrlFromVal, b as initValRouteFromVal } from '../../dist/routeFromVal-728295a0.esm.js';
+import { Internal } from '@valbuild/core';
+import { getModuleIds, stegaEncode } from '@valbuild/react/stega';
+import React from 'react';
+import { u as useValOverlayContext } from '../../dist/ValOverlayContext-87cb022d.esm.js';
+import '../../dist/createForOfIteratorHelper-485c2ce1.esm.js';
+import '@valbuild/shared/client';
+import '@valbuild/core/patch';
+import 'react/jsx-runtime';
+
+function useValStega(selector) {
+  var valOverlayContext = useValOverlayContext();
+  var moduleIds = React.useMemo(function () {
+    return getModuleIds(selector);
+  }, [selector]);
+  var store = valOverlayContext.store;
+  var moduleMap = React.useSyncExternalStore(store ? store.subscribe(moduleIds) : function () {
+    return function () {};
+  }, store ? store.getSnapshot(moduleIds) : function () {
+    return;
+  }, store ? store.getServerSnapshot(moduleIds) : function () {
+    return;
+  });
+  // Suspense gate. `suspend` is false during SSR and hydration (so the static
+  // committed source is rendered, matching the server HTML exactly) and is
+  // activated by ValProvider after hydration — inside a transition — when the
+  // `suspend` prop is set AND the Val Enable cookie is present (checked
+  // client-side; the server store is never populated). It never deactivates.
+  // The production path (no cookie) skips the call entirely. The
+  // `draftMode !== false` check is a release valve: with draft mode off the
+  // store never receives source updates, so waitForLoad could only ever
+  // resolve via its timeout — and would then re-suspend on every subsequent
+  // render since the resolved promise is evicted from the cache. draftMode is
+  // null until the first /draft/stat poll resolves; null -> true keeps
+  // suspending, -> false only unblocks, and false -> true happens only on an
+  // explicit draft-mode enable which already refreshes the route.
+  // React.use is allowed inside conditionals — it is not a hook.
+  /**
+   * Wait until draft mode is KNOWN, before anything else.
+   *
+   * `draftMode === null` means `/draft/stat` has not answered yet, and the
+   * `getModule` below treats it as off — so a render that slips through here
+   * while it is unknown resolves against committed source. For an ordinary field
+   * that is a flash of published content; for `useValRoute` on a route that
+   * exists only in an uncommitted patch it is `notFound()`, which no later
+   * answer can undo. That was the 404 on a page you had just created.
+   */
+  if (valOverlayContext.suspend && valOverlayContext.draftMode === null && valOverlayContext.draftModeReady) {
+    React.use(valOverlayContext.draftModeReady);
+  }
+  /**
+   * Then wait for the draft sources — but only while more might be coming.
+   *
+   * `draftSourcesSynced` is the editor saying it has sent everything it holds,
+   * and it only holds modules with patches: an unedited module has no draft, so
+   * nothing is ever sent for it. Without that signal this could not tell "not
+   * sent yet" from "nothing to send", and waited out `waitForLoad`'s ten second
+   * timeout once per unedited module the page reads — which is what left a newly
+   * created page sitting on its loading fallback.
+   */
+  if (valOverlayContext.suspend && valOverlayContext.draftMode !== false && !valOverlayContext.draftSourcesSynced && store && !store.hasAllLoaded(moduleIds)) {
+    React.use(store.waitForLoad(moduleIds));
+  }
+  return stegaEncode(selector, {
+    disabled: !valOverlayContext.draftMode,
+    getModule: function getModule(moduleId) {
+      if (moduleMap && valOverlayContext.draftMode) {
+        return moduleMap[moduleId];
+      }
+    }
+  });
+}
+
+/**
+ * The module's source as the overlay currently sees it — i.e. WITH the editor's
+ * unpublished changes — or undefined when there is no draft view to be had
+ * (production, draft mode off, or the overlay has not pushed this module yet).
+ *
+ * This is what lets the single-entry readers show drafts. They otherwise resolve
+ * an entry through its local import thunk, which is the content that was bundled:
+ * correct in production, and stale the moment anyone edits in the Studio.
+ */
+function useDraftModuleSource(moduleFilePath) {
+  var valOverlayContext = useValOverlayContext();
+  var store = valOverlayContext.store;
+  var moduleIds = React.useMemo(function () {
+    return moduleFilePath ? [moduleFilePath] : [];
+  }, [moduleFilePath]);
+  var moduleMap = React.useSyncExternalStore(store ? store.subscribe(moduleIds) : function () {
+    return function () {};
+  }, store ? store.getSnapshot(moduleIds) : function () {
+    return undefined;
+  }, store ? store.getServerSnapshot(moduleIds) : function () {
+    return undefined;
+  });
+  if (!valOverlayContext.draftMode || !moduleFilePath) {
+    return undefined;
+  }
+  return moduleMap === null || moduleMap === void 0 ? void 0 : moduleMap[moduleFilePath];
+}
+
+/**
+ * What the draft view says about one `.jsonValues()` entry.
+ *
+ * Mirrors the server-side rule in `fetchValKey`/`fetchValRoute`: a draft view
+ * that HAS an answer wins, including the answer "this entry is gone", and the
+ * bundled content is used only when there is no draft view.
+ */
+function draftJsonEntry(draftSource, key) {
+  if (draftSource === undefined || draftSource === null || _typeof(draftSource) !== "object" || Array.isArray(draftSource)) {
+    return {
+      status: "unavailable"
+    };
+  }
+  var entry = draftSource[key];
+  if (entry === undefined) {
+    // The module IS in the draft view and this key is not: it was deleted.
+    return {
+      status: "absent"
+    };
+  }
+  if (Internal.isJson(entry)) {
+    // An un-loaded marker: the Studio has not fetched this entry's content, so
+    // the draft view cannot answer. (The engine asks for entries that pending
+    // patches touch, so this resolves itself for anything actually edited.)
+    return {
+      status: "unavailable"
+    };
+  }
+  return {
+    status: "content",
+    content: entry
+  };
+}
+
+// The (loosened) content type a single `.jsonValues()` entry resolves to.
+
+// Module-level cache of in-flight/resolved entry loads, so `React.use` gets a
+// stable promise across renders (keyed by module path + entry key).
+var jsonEntryPromiseCache = new Map();
+
+/**
+ * Client counterpart to `fetchValKey`: resolves a SINGLE `.jsonValues()` entry
+ * by key, loading only that entry's backing `*.val.json` (one dynamic import).
+ * Suspends (via `React.use`) until the entry loads, so it must be rendered
+ * inside a `<Suspense>` boundary.
+ *
+ * In draft mode it renders the editor's unpublished content, taken from the
+ * overlay; in production — and whenever there is no draft view — it resolves the
+ * entry's lazy import thunk from the local module.
+ */
+function useValKeyStega(selector, key) {
+  var valOverlayContext = useValOverlayContext();
+  var moduleFilePath = selector && Internal.getValPath(selector);
+  var draftSource = useDraftModuleSource(moduleFilePath || undefined);
+  var draft = draftJsonEntry(draftSource, key);
+  if (draft.status === "absent") {
+    // Deleted in the draft state. Falling back to the bundled entry here would
+    // render content the editor has just removed.
+    return undefined;
+  }
+  var content = draft.status === "content" ? draft.content : undefined;
+  if (content === undefined) {
+    content = readCommittedJsonEntry(selector, key);
+  }
+  return stegaEncode(content, {
+    disabled: !valOverlayContext.draftMode,
+    root: getJsonEntryStegaRoot(selector, key)
+  });
+}
+
+/**
+ * The entry's content as bundled: its lazy import thunk, resolved through
+ * `React.use` so the caller suspends until it lands.
+ *
+ * Deliberately not named `use*`: it is called conditionally, which is fine
+ * because `React.use` is not a hook, but a `use*` name would read like one.
+ */
+function readCommittedJsonEntry(selector, key) {
+  var _Internal$getValPath;
+  var source = selector && Internal.getSource(selector);
+  var marker = source && _typeof(source) === "object" ? source[key] : undefined;
+  if (!Internal.isJson(marker)) {
+    return undefined;
+  }
+  var thunk = Internal.getJsonImport(marker);
+  if (!thunk) {
+    return undefined;
+  }
+  var cacheKey = "".concat((_Internal$getValPath = Internal.getValPath(selector)) !== null && _Internal$getValPath !== void 0 ? _Internal$getValPath : "", " ").concat(key);
+  var promise = jsonEntryPromiseCache.get(cacheKey);
+  if (!promise) {
+    promise = thunk().then(function (mod) {
+      return mod["default"];
+    });
+    jsonEntryPromiseCache.set(cacheKey, promise);
+  }
+  return React.use(promise);
+}
+function resolveParams(params) {
+  if (!params) {
+    return null;
+  }
+  if ("then" in params) {
+    // Defensive guard: peerDependencies declare React >=19, but if a consumer
+    // somehow ends up on React 18 with a promise params arg, surface a
+    // diagnosable error instead of a cryptic `TypeError: React.use is not a
+    // function`. Callers treat null as the error sentinel.
+    if (!("use" in React)) {
+      console.error("Val: useValRoute received a Promise params argument but React.use is unavailable. Upgrade to React 19+ or pre-resolve the promise before passing it.");
+      return null;
+    }
+    return React.use(params);
+  }
+  return params;
+}
+function useValRouteStega(selector, params) {
+  var valOverlayContext = useValOverlayContext();
+  // Both called unconditionally to keep hook order stable. For a `.jsonValues()`
+  // router `val` is unused (we resolve a single entry below instead); for any
+  // other router `draftSource` is.
+  var val = useValStega(selector);
+  var draftSource = useDraftModuleSource(selector && Internal.getValPath(selector) || undefined);
+  var resolvedParams = resolveParams(params);
+  // Careful: null means there was an error - undefined means no params
+  if (resolvedParams === null) {
+    return null;
+  }
+  var path = selector && Internal.getValPath(selector);
+  var schema = selector && Internal.getSchema(selector);
+  // `.jsonValues()` router: map params → the entry key and load ONLY that
+  // entry's backing `*.val.json` (one dynamic import), like `useValKey`.
+  if (isJsonValuesRecordSchema(schema)) {
+    var source = selector && Internal.getSource(selector);
+    var url = getValRouteUrlFromVal(resolvedParams || {}, "useValRoute", path, schema, source);
+    if (!url) {
+      return null;
+    }
+    var draft = draftJsonEntry(draftSource, url);
+    if (draft.status === "absent") {
+      // The draft state says this route is gone — see useValKeyStega.
+      return null;
+    }
+    var content = draft.status === "content" ? draft.content : undefined;
+    if (content === undefined) {
+      content = readCommittedJsonEntry(selector, url);
+    }
+    if (content === undefined) {
+      return null;
+    }
+    return stegaEncode(content, {
+      disabled: !valOverlayContext.draftMode,
+      root: getJsonEntryStegaRoot(selector, url)
+    });
+  }
+  var route = initValRouteFromVal(resolvedParams || {}, "useValRoute", path, schema, val);
+  return route;
+}
+function useValRouteUrl(selector, params) {
+  var val = useValStega(selector);
+  var resolvedParams = params === undefined ? undefined : resolveParams(params);
+  // Careful: null means there was an error - undefined means no params
+  if (resolvedParams === null) {
+    return null;
+  }
+  var route = getValRouteUrlFromVal(resolvedParams || {}, "useValRouteUrl", selector && Internal.getValPath(selector), selector && Internal.getSchema(selector), val);
+  return route;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function initValClient(config) {
+  return {
+    useValStega: useValStega,
+    useValKeyStega: useValKeyStega,
+    useValRouteStega: useValRouteStega,
+    useValRouteUrl: useValRouteUrl
+  };
+}
+
+export { initValClient };

package/client/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/valbuild-tanstack-client.cjs.js",
+  "module": "dist/valbuild-tanstack-client.esm.js"
+}