@valbuild/tanstack 0.124.0

package/dist/createForOfIteratorHelper-e75681d7.cjs.dev.js

@@ -0,0 +1,157 @@
+'use strict';
+
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = !0,
+    u = !1;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = !0, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+
+exports._createForOfIteratorHelper = _createForOfIteratorHelper;
+exports._defineProperty = _defineProperty;
+exports._objectSpread2 = _objectSpread2;
+exports._slicedToArray = _slicedToArray;
+exports._toPropertyKey = _toPropertyKey;

package/dist/declarations/src/ValApp.d.ts

@@ -0,0 +1,6 @@
+import { ValConfig } from "@valbuild/core";
+import { type ReactNode } from "react";
+export declare const ValApp: ({ config, children, }: {
+    config: ValConfig;
+    children?: ReactNode;
+}) => import("react").JSX.Element;

package/dist/declarations/src/ValImage.d.ts

@@ -0,0 +1,24 @@
+import { Image } from "@valbuild/react/stega";
+/**
+ * An `<img>` for a Val image, with the edit tags kept where the Studio can see
+ * them.
+ *
+ * The Next package wraps `next/image`. TanStack Start has no image component,
+ * so this is a plain `<img>` — which means it also carries what `next/image`
+ * would have supplied on its own: the intrinsic `width`/`height` from the
+ * source (so the browser can reserve the space) and `hotspot` as
+ * `object-position`.
+ *
+ * What it exists for is the tags. `src.url` is stega-encoded, so it cannot be
+ * put in an `src` attribute as-is: the invisible characters would be sent to
+ * the server. `raw()` strips them and the paths they carried are re-attached as
+ * `data-val-path` / `data-val-attr-*`, which is what makes the image
+ * click-to-edit.
+ */
+export type ValImageProps = Omit<React.ComponentProps<"img">, "src" | "alt" | "srcSet"> & {
+    alt?: string;
+    src: Image;
+    /** Ignore the image's hotspot instead of applying it as object-position. */
+    disableHotspot?: boolean;
+};
+export declare function ValImage(props: ValImageProps): import("react").JSX.Element;

package/dist/declarations/src/ValModulesClient.d.ts

@@ -0,0 +1,34 @@
+import type { ValModules } from "@valbuild/core";
+declare global {
+    interface Window {
+        __VAL_MODULES__?: ValModules;
+    }
+}
+/**
+ * Registers the user's `val.modules` registry on `window.__VAL_MODULES__` so
+ * the Val editor SPA (both the `/val` app and the on-page overlay) can read it.
+ *
+ * Must be called from a component that statically imports `val.modules`: the
+ * module `def` entries are function closures, so the registry cannot be
+ * serialized through a loader and has to be pulled into the client bundle and
+ * registered via the window global instead.
+ *
+ * Re-runs when the `modules` reference changes (e.g. on HMR) and dispatches
+ * `val-modules-updated` so the SPA picks up the new registry.
+ */
+export declare function useRegisterValModules(modules: ValModules): void;
+/**
+ * Registers the user's `val.modules` registry for the Val editor SPA.
+ *
+ * Render this inside both `<ValProvider>` (the root route) and `<ValApp>` (the
+ * `/val` route), passing your `val.modules` default export:
+ *
+ * @example
+ * import { ValModulesClient } from "@valbuild/tanstack";
+ * import valModules from "../val.modules";
+ *
+ * <ValModulesClient modules={valModules} />
+ */
+export declare function ValModulesClient({ modules }: {
+    modules: ValModules;
+}): null;

package/dist/declarations/src/ValProvider.d.ts

@@ -0,0 +1,6 @@
+export declare const ValProvider: (props: {
+    children: React.ReactNode | React.ReactNode[];
+    config: import("@valbuild/core").ValConfig;
+    disableRefresh?: boolean;
+    suspend?: boolean;
+}) => import("react").JSX.Element;

package/dist/declarations/src/ValTypes.d.ts

@@ -0,0 +1,4 @@
+import type { UseValType } from "./client/initValClient.js";
+import { Schema, SelectorSource } from "@valbuild/core";
+import { SelectorOfSchema } from "@valbuild/core";
+export type inferSchema<S extends Schema<SelectorSource>> = UseValType<SelectorOfSchema<S>>;

package/dist/declarations/src/client/index.d.ts

@@ -0,0 +1 @@
+export { initValClient } from "./initValClient.js";

package/dist/declarations/src/client/initValClient.d.ts

@@ -0,0 +1,27 @@
+import { GenericSelector, JsonSource, SelectorOf, SelectorSource, SourceObject, ValModule } from "@valbuild/core";
+import { StegaOfSource } from "@valbuild/react/stega";
+import { ValConfig } from "@valbuild/core";
+export type UseValType<T extends SelectorSource> = SelectorOf<T> extends GenericSelector<infer S> ? StegaOfSource<S> : never;
+declare function useValStega<T extends SelectorSource>(selector: T): UseValType<T>;
+type JsonEntryContentOf<T extends ValModule<GenericSelector<SourceObject>>> = T extends ValModule<infer S> ? S extends Record<string, infer V> ? V extends JsonSource<infer C> ? C : never : never : never;
+/**
+ * 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.
+ */
+declare function useValKeyStega<T extends ValModule<GenericSelector<SourceObject>>>(selector: T, key: string): JsonEntryContentOf<T> | undefined;
+type UseValRouteReturnType<T extends ValModule<GenericSelector<SourceObject>>> = T extends ValModule<infer S> ? S extends SourceObject ? NonNullable<S>[string] extends JsonSource<infer C> ? C | null : StegaOfSource<NonNullable<S>[string]> | null : never : never;
+declare function useValRouteStega<T extends ValModule<GenericSelector<SourceObject>>>(selector: T, params: Record<string, string | string[]> | Promise<Record<string, string | string[]>>): UseValRouteReturnType<T>;
+declare function useValRouteUrl<T extends ValModule<GenericSelector<SourceObject>>>(selector: T, params?: Record<string, string | string[]> | Promise<Record<string, string | string[]>>): string | null;
+export declare function initValClient(config: ValConfig): {
+    useValStega: typeof useValStega;
+    useValKeyStega: typeof useValKeyStega;
+    useValRouteStega: typeof useValRouteStega;
+    useValRouteUrl: typeof useValRouteUrl;
+};
+export {};

package/dist/declarations/src/decodeValPathsOfString.d.ts

@@ -0,0 +1,2 @@
+import { ValEncodedString } from "@valbuild/react/stega";
+export declare function decodeValPathsOfString(encodedString: ValEncodedString): string[] | undefined;

package/dist/declarations/src/external_exempt_from_val_quickjs.d.ts

@@ -0,0 +1,41 @@
+export { Schema, type SerializedSchema } from "@valbuild/core";
+export type { SourceObject, SourcePrimitive, Source } from "@valbuild/core";
+export type { ValModule, SerializedModule } from "@valbuild/core";
+export type { FileSource, ImageSource, MediaSource } from "@valbuild/core";
+export type { RichTextSource } from "@valbuild/core";
+export { type Val, type SerializedVal, type ModuleFilePath, type ModulePath, type SourcePath, type JsonOfSource, } from "@valbuild/core";
+export { modules, type ValModules } from "@valbuild/core";
+export type { Json, JsonPrimitive } from "@valbuild/core";
+export type { ValidationErrors, ValidationError } from "@valbuild/core";
+export type { ValidationFix } from "@valbuild/core";
+export * as expr from "@valbuild/core";
+export { VAL_EXTENSION, type SourceArray } from "@valbuild/core";
+export { derefPatch } from "@valbuild/core";
+export { type SelectorSource, type SelectorOf, GenericSelector, } from "@valbuild/core";
+export { ValRichText } from "@valbuild/react/internal";
+export { type ValEncodedString, type File, type Image, type RichText, } from "@valbuild/react/stega";
+export { ValProvider } from "./ValProvider.js";
+export { ValImage, type ValImageProps } from "./ValImage.js";
+export { ValApp } from "./ValApp.js";
+export { ValModulesClient, useRegisterValModules } from "./ValModulesClient.js";
+import { Internal as InternalCore } from "@valbuild/core";
+import { VERSION } from "./version.js";
+export type * as t from "./ValTypes.js";
+export type { DecodeVal } from "@valbuild/react/stega";
+/**
+ * Annotated rather than inferred.
+ *
+ * The inferred type of the spread below reaches into @valbuild/core's internal
+ * declaration files for names like `NonEmptyArray` and `createValPathOfItem`,
+ * which the declaration emitter cannot write down portably: `preconstruct
+ * build` fails with a wall of TS2883 "the inferred type of 'Internal' cannot be
+ * named without a reference to ..." while `tsc --noEmit` stays happy, so it only
+ * shows up in the build job. Naming the type in terms of `typeof InternalCore`
+ * keeps everything the emitter needs reachable through the package entry point.
+ */
+type InternalWithTanStackVersion = Omit<typeof InternalCore, "VERSION"> & {
+    VERSION: typeof InternalCore.VERSION & {
+        tanstack: typeof VERSION;
+    };
+};
+export declare const Internal: InternalWithTanStackVersion;

package/dist/declarations/src/getUnpatchedUnencodedVal.d.ts

@@ -0,0 +1,3 @@
+import type { GenericSelector, SelectorOf, SelectorSource } from "@valbuild/core";
+import { type StegaOfSource } from "@valbuild/react/stega";
+export declare function getUnpatchedUnencodedVal<T extends SelectorSource>(selector: T): SelectorOf<T> extends GenericSelector<infer S> ? StegaOfSource<S> : never;

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,2 @@
+export { initVal } from "./initVal.js";
+export * from "./external_exempt_from_val_quickjs.js";

package/dist/declarations/src/initVal.d.ts

@@ -0,0 +1,74 @@
+import { type ValConfig, type InitVal, type ValConstructor, ValRouter } from "@valbuild/core";
+import { raw } from "@valbuild/react/stega";
+import { getUnpatchedUnencodedVal } from "./getUnpatchedUnencodedVal.js";
+import { decodeValPathsOfString } from "./decodeValPathsOfString.js";
+import { attrs } from "@valbuild/react/stega";
+/**
+ * Returns true if the Val Enable cookie is set. Must be called on the server —
+ * inside a server function, a server route handler, or during SSR — and
+ * returns false anywhere else.
+ *
+ * Not needed for the `suspend` prop on ValProvider, which detects the cookie
+ * client-side; reserve it for advanced server-side conditionals.
+ */
+declare function isValEnabled(): Promise<boolean>;
+export declare const initVal: (config?: ValConfig) => InitVal & {
+    /**
+     * Returns true if the Val Enable cookie is set. Must be called on the
+     * server — inside a server function, a server route handler, or during SSR —
+     * and returns false anywhere else.
+     *
+     * Not needed for the `suspend` prop on ValProvider, which detects the cookie
+     * client-side; reserve it for advanced server-side conditionals.
+     */
+    isValEnabled: typeof isValEnabled;
+    val: ValConstructor & {
+        /**
+         * Returns the original module data, without any applied patches or stega encoding.
+         *
+         * This represents the raw, canonical state of the module as it was initially defined.
+         * NOTE: images and files, will be transformed (and will therefore) include the url property.
+         *
+         * ⚠️ Prefer using `fetchVal` (on the server) or `useVal` (in components)
+         * for most application logic.
+         *
+         * This method is primarily intended for tooling and other advanced use cases
+         * outside of the actual application.
+         */
+        unstable_getUnpatchedUnencodedVal: typeof getUnpatchedUnencodedVal;
+        /**
+         * Convert any object that is encoded with Val stega encoding back to the original values
+         */
+        raw: typeof raw;
+        /**
+         * Get the Val paths of attributes for any object.
+         *
+         * This is typically used to manually set the data-val-path attribute for visual editing on any element.
+         *
+         * @example
+         * const page = useVal(pageVal)
+         * <a href={page.url.href} {...val.attrs(page)}>
+         *   {page.url.label}
+         * </a>
+         */
+        attrs: typeof attrs;
+        unstable_decodeValPathsOfString: typeof decodeValPathsOfString;
+    };
+    /**
+     * The TanStack Router for use on s.record().router(...)
+     *
+     * The Val module of a route is named after the route file it sits beside:
+     * `src/routes/posts.$postId.tsx` is served content by
+     * `src/routes/posts.$postId.val.ts`. Directory notation
+     * (`src/routes/posts/$postId.val.ts`) is the same route.
+     *
+     * @example
+     * const pages = s.record(s.object({ title: s.string() })).router(tanstackRouter);
+     * export default c.define("/src/routes/posts.$postId.val.ts", pages, {
+     *   "/posts/hello-world": { title: "Hello world" },
+     * });
+     */
+    tanstackRouter: ValRouter;
+    externalPageRouter: ValRouter;
+};
+export {};

package/dist/declarations/src/server/index.d.ts

@@ -0,0 +1,5 @@
+export { initValServer } from "./initValServer.js";
+export { initValContent } from "./initValContent.js";
+export { valDraftMode, hasValEnableCookieOnServer, VAL_DRAFT_MODE_COOKIE, type ValDraftMode, } from "./valDraftMode.js";
+export { initValMcp } from "./initValMcp.js";
+export type { ValMcp, ValMcpAuthorizationResult, ValMcpMetadataHandlers, ValOAuthConfig, ValToolImpl, } from "@valbuild/mcp";

package/dist/declarations/src/server/initValContent.d.ts

@@ -0,0 +1,122 @@
+import { type StegaOfSource } from "@valbuild/react/stega";
+import { SelectorSource, SelectorOf, GenericSelector, ValConfig, ValModules, ValModule, SourceObject, JsonSource } from "@valbuild/core";
+import { ValServer } from "@valbuild/server";
+import { type ValDraftMode } from "./valDraftMode.js";
+declare const initFetchValStega: (config: ValConfig, valApiEndpoints: string, valServerPromise: Promise<ValServer>, isEnabled: () => Promise<boolean>, getHeaders: () => Promise<{
+    get(name: string): string | null;
+}>, getCookies: () => Promise<{
+    get(name: string): {
+        name: string;
+        value: string;
+    } | undefined;
+}>) => <T extends SelectorSource>(selector: T) => Promise<SelectorOf<T> extends GenericSelector<infer S> ? StegaOfSource<S> : never>;
+type FetchValRouteReturnType<T extends ValModule<GenericSelector<SourceObject>>> = T extends ValModule<infer S> ? S extends SourceObject ? NonNullable<S>[string] extends JsonSource<infer C> ? C | null : StegaOfSource<NonNullable<S>[string]> | null : never : never;
+declare const initFetchValRouteStega: (config: ValConfig, valApiEndpoints: string, valServerPromise: Promise<ValServer>, isEnabled: () => Promise<boolean>, getHeaders: () => Promise<{
+    get(name: string): string | null;
+}>, getCookies: () => Promise<{
+    get(name: string): {
+        name: string;
+        value: string;
+    } | undefined;
+}>) => <T extends ValModule<GenericSelector<SourceObject>>>(selector: T, params: Promise<Record<string, string | string[]>> | Record<string, string | string[]> | unknown) => Promise<FetchValRouteReturnType<T>>;
+/**
+ * Loads a single `.jsonValues()` entry's DRAFT content via the in-process
+ * `/json` endpoint (which replays pending patches). Returns `undefined` when the
+ * entry has no draft content to serve — the caller then falls back to the
+ * locally-bundled committed content.
+ */
+/**
+ * What the draft state says about an entry.
+ *
+ * The three cases have to stay distinct: `absent` is an ANSWER — the entry is not
+ * there in the draft state, e.g. a pending patch removed it — while `unavailable`
+ * means we could not ask. Collapsing them into `undefined` is what made a
+ * draft-deleted entry keep rendering its committed content: the caller could not
+ * tell "it is gone" from "ask the committed source instead".
+ */
+/**
+ * The slice of `ValServer` the single-entry readers actually use. Narrower than
+ * `ValServer` on purpose: it says what the dependency IS, and it lets a test
+ * drive these readers with a one-route fake instead of casting a partial object
+ * to the whole server type.
+ */
+export type JsonEntryValServer = Pick<ValServer, "/json">;
+export type DraftJsonEntry = {
+    status: "content";
+    content: unknown;
+} | {
+    status: "absent";
+} | {
+    status: "unavailable";
+};
+/**
+ * Picks the content a draft-aware single-entry read should render.
+ *
+ * The rule the two callers share: the draft state WINS when it has an answer —
+ * including the answer "this entry is gone" — and the committed content is used
+ * only when there is no draft answer to be had (Val disabled, or we could not
+ * ask). Returning `undefined` means "render nothing"; both callers turn that into
+ * a null/undefined result.
+ */
+export declare function resolveDraftOrCommittedEntry(draft: DraftJsonEntry, loadCommitted: () => Promise<unknown | undefined>): Promise<unknown | undefined>;
+type JsonEntryContentOf<T extends ValModule<GenericSelector<SourceObject>>> = T extends ValModule<infer S> ? S extends Record<string, infer V> ? V extends JsonSource<infer C> ? C : never : never : never;
+/**
+ * Resolves ONE `.jsonValues()` entry by key, loading only that entry instead of
+ * the whole record — the runtime-scaling counterpart to the eager `fetchVal`.
+ *
+ * Production (Val disabled): resolves the entry's lazy import thunk from the
+ * locally-bundled module. One dynamic import, no server round-trip.
+ *
+ * Enabled (draft mode): reads the entry through `/json`, which replays pending
+ * patches, so uncommitted Studio edits show up. Falls back to the local thunk if
+ * the draft read yields nothing.
+ */
+export declare const initFetchValKeyStega: (valServerPromise: Promise<JsonEntryValServer>, isEnabled: () => Promise<boolean>, getCookies: () => Promise<{
+    get(name: string): {
+        name: string;
+        value: string;
+    } | undefined;
+}>) => <T extends ValModule<GenericSelector<SourceObject>>>(selector: T, key: string) => Promise<JsonEntryContentOf<T> | undefined>;
+declare const initFetchValRouteUrl: (config: ValConfig, valApiEndpoints: string, valServerPromise: Promise<ValServer>, isEnabled: () => Promise<boolean>, getHeaders: () => Promise<{
+    get(name: string): string | null;
+}>, getCookies: () => Promise<{
+    get(name: string): {
+        name: string;
+        value: string;
+    } | undefined;
+}>) => <T extends ValModule<GenericSelector<SourceObject>>>(selector: T, params?: Promise<Record<string, string | string[]>> | Record<string, string | string[]> | unknown) => Promise<string | null>;
+/**
+ * Val's content readers for the server side of a TanStack Start app.
+ *
+ * Use them where the server runs: a route `loader` during SSR, a
+ * `createServerFn`, or a server route handler. In the browser — a client
+ * navigation re-running a loader, say — there is no request to read draft
+ * state from, so they resolve the published content, which is the same answer
+ * the visitor would get.
+ *
+ * @example
+ * // src/val/server.ts
+ * import { initValContent } from "@valbuild/tanstack/server";
+ * import { config } from "../val.config";
+ * import valModules from "../val.modules";
+ *
+ * export const {
+ *   fetchValStega: fetchVal,
+ *   fetchValRouteStega: fetchValRoute,
+ * } = initValContent(config, valModules);
+ */
+export declare function initValContent(config: ValConfig, valModules: ValModules, opts?: {
+    /**
+     * How preview mode is stored for a browser.
+     *
+     * Defaults to Val's own cookie. Pass the SAME object `initValServer` got:
+     * the API turns preview on and these readers are what has to notice.
+     */
+    draftMode?: ValDraftMode;
+}): {
+    fetchValStega: ReturnType<typeof initFetchValStega>;
+    fetchValKeyStega: ReturnType<typeof initFetchValKeyStega>;
+    fetchValRouteStega: ReturnType<typeof initFetchValRouteStega>;
+    fetchValRouteUrl: ReturnType<typeof initFetchValRouteUrl>;
+};
+export {};

package/dist/declarations/src/server/initValMcp.d.ts

@@ -0,0 +1,27 @@
+import type { ValConfig, ValModules } from "@valbuild/core";
+import { type ValMcp, type ValToolImpl, type ValOAuthConfig } from "@valbuild/mcp";
+/**
+ * Val's tools over MCP, bound to this package.
+ *
+ * The MCP endpoint itself — the tools, the request guards, the access-token
+ * verification — lives in `@valbuild/mcp`, which knows nothing about any
+ * framework. All that is left here is the one thing this package can answer and
+ * that one cannot: which version of `@valbuild/tanstack` is running, which
+ * `initHandlerOptions` insists on before it will build a proxy-mode config.
+ *
+ * The version goes in the `next` field because that is the field name in the
+ * wire contract; see `initValServer`.
+ */
+export declare function initValMcp(valModules: ValModules, config: ValConfig, opts?: {
+    formatter?: (code: string, filePath: string) => string | Promise<string>;
+    /**
+     * Where to authorize, and what audience to expect. Required for proxy
+     * mode; see `initValMcp` in `@valbuild/mcp` for what omitting it means.
+     */
+    oauth?: ValOAuthConfig;
+    /**
+     * Tools to serve alongside the built-in ones — the image tool arrives this
+     * way. See `createValImageTools` in `@valbuild/mcp`.
+     */
+    extraTools?: ValToolImpl[];
+}): ValMcp;

package/dist/declarations/src/server/initValServer.d.ts

@@ -0,0 +1,41 @@
+import { ValConfig, ValModules } from "@valbuild/core";
+import { type ValDraftMode } from "./valDraftMode.js";
+export declare function initValServer(valModules: ValModules, config: ValConfig & {
+    disableCache?: boolean;
+}, opts?: {
+    formatter?: (code: string, filePath: string) => Promise<string> | string;
+    /**
+     * How preview mode is stored for a browser.
+     *
+     * Defaults to Val's own cookie (`valDraftMode()`), which is what an app
+     * wants unless it already has a preview mechanism of its own to hang this
+     * off. Whatever is passed here MUST be the same object the content readers
+     * get, or the API will enable a preview the loaders cannot see.
+     */
+    draftMode?: ValDraftMode;
+}): {
+    /**
+     * The Val API. Mount it on `/api/val/$` for every method:
+     *
+     * @example
+     * // src/routes/api/val.$.ts
+     * import { createFileRoute } from "@tanstack/react-router";
+     * import { valApiHandler } from "../../val/server";
+     *
+     * export const Route = createFileRoute("/api/val/$")({
+     *   server: {
+     *     handlers: {
+     *       GET: ({ request }) => valApiHandler(request),
+     *       POST: ({ request }) => valApiHandler(request),
+     *       PUT: ({ request }) => valApiHandler(request),
+     *       PATCH: ({ request }) => valApiHandler(request),
+     *       DELETE: ({ request }) => valApiHandler(request),
+     *       HEAD: ({ request }) => valApiHandler(request),
+     *     },
+     *   },
+     * });
+     */
+    valApiHandler: (req: Request) => Promise<Response>;
+    /** The draft-mode flag this server reads and writes. */
+    draftMode: ValDraftMode;
+};

package/dist/declarations/src/server/valDraftMode.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The cookie that says a request is previewing unpublished content.
+ *
+ * Next has `draftMode()` for this; TanStack Start has no such notion, so Val
+ * brings its own. Deliberately NOT the thing that grants access: every draft
+ * read also carries the Val session cookie, which is a signed JWT the server
+ * verifies, and a request with this cookie and no session gets published
+ * content and a 401 in the log. So this is a mode switch, not a credential —
+ * which is why an ordinary cookie is enough.
+ */
+export declare const VAL_DRAFT_MODE_COOKIE = "val_draft_mode";
+/**
+ * Reading and writing the draft-mode flag for the current request.
+ *
+ * Handed to `createValServer` as its callbacks, and exported so an app can ask
+ * the same question its loaders ask.
+ */
+export type ValDraftMode = {
+    /** Whether this request is previewing unpublished content. */
+    isEnabled(): Promise<boolean>;
+    /** Turn preview on for this browser. Called by `/api/val/draft/enable`. */
+    enable(): Promise<void>;
+    /** Turn preview off again. Called by `/api/val/draft/disable`. */
+    disable(): Promise<void>;
+};
+/**
+ * The draft-mode flag, read from and written to the current request.
+ *
+ * TanStack's request helpers resolve the current request out of async local
+ * storage, so this only works where there IS one: a server route handler, a
+ * server function, or an SSR render. Everywhere else — a client navigation, a
+ * build-time render — it answers "off", which is the right answer: there is no
+ * session to authorize a draft read either.
+ *
+ * The import is dynamic for the same reason it is in `isValEnabled`: this
+ * module is reachable from the package's server entry, and pulling TanStack's
+ * server half in eagerly would put it in front of anything that merely
+ * type-imports from here.
+ */
+export declare function valDraftMode(): ValDraftMode;
+/**
+ * The Val Enable cookie, as seen by the current request.
+ *
+ * Separate from draft mode: enabling Val is what makes the Studio overlay mount
+ * at all, and draft mode is what makes the content it shows be the unpublished
+ * one. The Studio turns the first on for the browser and the second on per
+ * preview.
+ */
+export declare function hasValEnableCookieOnServer(): Promise<boolean>;

package/dist/declarations/src/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string | null;