@valbuild/next 0.99.1 → 0.101.0

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

@@ -1,9 +1,9 @@
 import 'client-only';
+import { g as getJsonEntryStegaRoot, _ as _typeof, a as isJsonValuesRecordSchema, b as getValRouteUrlFromVal, i as initValRouteFromVal } from '../../dist/routeFromVal-263eec96.esm.js';
 import { Internal } from '@valbuild/core';
 import { getModuleIds, stegaEncode } from '@valbuild/react/stega';
 import React from 'react';
 import { useValOverlayContext } from '../../dist/ValOverlayContext-3c37e5a7.esm.js';
-import { i as initValRouteFromVal, g as getValRouteUrlFromVal } from '../../dist/routeFromVal-8855a5cc.esm.js';
 import '../../dist/createForOfIteratorHelper-5758a730.esm.js';
 import '../../dist/unsupportedIterableToArray-5baabfdc.esm.js';
 import '../../dist/objectSpread2-60d1bd93.esm.js';
@@ -50,6 +50,133 @@ function useValStega(selector) {
     }
   });
 }
+
+/**
+ * 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;
@@ -68,13 +195,45 @@ function resolveParams(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 route = initValRouteFromVal(resolvedParams || {}, "useValRoute", selector && Internal.getValPath(selector), selector && Internal.getSchema(selector), val);
+  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) {
@@ -92,6 +251,7 @@ function useValRouteUrl(selector, params) {
 function initValClient(config) {
   return {
     useValStega: useValStega,
+    useValKeyStega: useValKeyStega,
     useValRouteStega: useValRouteStega,
     useValRouteUrl: useValRouteUrl
   };

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

@@ -1,13 +1,26 @@
-import { GenericSelector, SelectorOf, SelectorSource, SourceObject, ValModule } from "@valbuild/core";
+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 UseValRouteReturnType<T extends ValModule<GenericSelector<SourceObject>>> = T extends ValModule<infer S> ? S extends SourceObject ? StegaOfSource<NonNullable<S>[string]> | null : never : never;
+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;
 };

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

@@ -37,6 +37,13 @@ export declare const Internal: {
     joinModuleFilePathAndModulePath: typeof import("@valbuild/core/dist/declarations/src/module").joinModuleFilePathAndModulePath;
     nextAppRouter: import("@valbuild/core").ValRouter;
     externalPageRouter: import("@valbuild/core").ValRouter;
+    color: {
+        parseColor: typeof import("@valbuild/core/dist/declarations/src/schema/colorFormat").parseColor;
+        formatColor: typeof import("@valbuild/core/dist/declarations/src/schema/colorFormat").formatColor;
+        convertColor: typeof import("@valbuild/core/dist/declarations/src/schema/colorFormat").convertColor;
+        detectColorFormat: typeof import("@valbuild/core/dist/declarations/src/schema/colorFormat").detectColorFormat;
+        colorToHex: typeof import("@valbuild/core/dist/declarations/src/schema/colorFormat").colorToHex;
+    };
     remote: {
         createRemoteRef: typeof import("@valbuild/core/dist/declarations/src/source/remote").createRemoteRef;
         getValidationBasis: typeof import("@valbuild/core/dist/declarations/src/remote/validationBasis").getValidationBasis;
@@ -48,6 +55,9 @@ export declare const Internal: {
     validate: (val: import("@valbuild/core").ValModule<import("@valbuild/core").SelectorSource>, path: import("@valbuild/core").SourcePath, src: unknown) => import("@valbuild/core").ValidationErrors | undefined;
     isVal: typeof import("@valbuild/core/dist/declarations/src/val").isVal;
     isFile: typeof import("@valbuild/core/dist/declarations/src/source/file").isFile;
+    isJson: typeof import("@valbuild/core/dist/declarations/src/source/json").isJson;
+    getJsonImport: typeof import("@valbuild/core/dist/declarations/src/source/json").getJsonImport;
+    resolveJsonValues: typeof import("@valbuild/core/dist/declarations/src/source/json").resolveJsonValues;
     createValPathOfItem: typeof import("@valbuild/core/dist/declarations/src/selector/SelectorProxy").createValPathOfItem;
     getSHA256Hash: (bits: Uint8Array) => string;
     initSchema: typeof import("@valbuild/core/dist/declarations/src/initSchema").initSchema;

package/dist/declarations/src/rsc/initValRsc.d.ts

@@ -1,5 +1,5 @@
 import { type StegaOfSource } from "@valbuild/react/stega";
-import { SelectorSource, SelectorOf, GenericSelector, ValConfig, ValModules, ValModule, SourceObject } from "@valbuild/core";
+import { SelectorSource, SelectorOf, GenericSelector, ValConfig, ValModules, ValModule, SourceObject, JsonSource } from "@valbuild/core";
 import { cookies, draftMode, headers } from "next/headers";
 import { ValServer } from "@valbuild/server";
 declare const initFetchValStega: (config: ValConfig, valApiEndpoints: string, valServerPromise: Promise<ValServer>, isEnabled: () => Promise<boolean>, getHeaders: () => Promise<{
@@ -10,7 +10,7 @@ declare const initFetchValStega: (config: ValConfig, valApiEndpoints: string, va
         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 ? StegaOfSource<NonNullable<S>[string]> | null : never : 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<{
@@ -19,6 +19,64 @@ declare const initFetchValRouteStega: (config: ValConfig, valApiEndpoints: strin
         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<{
@@ -34,6 +92,7 @@ type ValNextRscConfig = {
 };
 export declare function initValRsc(config: ValConfig, valModules: ValModules, rscNextConfig: ValNextRscConfig): {
     fetchValStega: ReturnType<typeof initFetchValStega>;
+    fetchValKeyStega: ReturnType<typeof initFetchValKeyStega>;
     fetchValRouteStega: ReturnType<typeof initFetchValRouteStega>;
     fetchValRouteUrl: ReturnType<typeof initFetchValRouteUrl>;
 };

package/dist/{routeFromVal-8855a5cc.esm.js → routeFromVal-263eec96.esm.js}

@@ -14,6 +14,46 @@ function _typeof(o) {
   }, _typeof(o);
 }
 
+/**
+ * True when the module's schema is a `.jsonValues()` record/router — i.e. each
+ * entry value is a lazily-loaded `c.json(() => import(...))` marker. Used by the
+ * route helpers to load ONLY the matched entry instead of the whole record.
+ */
+function isJsonValuesRecordSchema(schema) {
+  return schema instanceof RecordSchema && schema["executeSerialize"]().jsonValues === true;
+}
+
+/**
+ * Builds the `stegaEncode` `root` seed for a single `.jsonValues()` entry, so its
+ * strings get edit tags. Without a seed, `stegaEncode` on raw entry content is an
+ * identity transform (the content carries no selector path/schema).
+ *
+ * Yields e.g. `/app/support/[slug]/page.val.ts?p="/support/faq"`, so a `title`
+ * field is tagged `…?p="/support/faq"."title"` — the shape the Studio's
+ * `findUnloadedJsonEntryKey` walks, so click-to-edit + lazy load line up.
+ */
+function getJsonEntryStegaRoot(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+selector, key
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+  var modulePath = selector && Internal.getValPath(selector);
+  if (!modulePath) {
+    return undefined;
+  }
+  var schema = selector && Internal.getSchema(selector);
+  if (!(schema instanceof RecordSchema)) {
+    return undefined;
+  }
+  var path = Internal.createValPathOfItem(modulePath, key);
+  if (!path) {
+    return undefined;
+  }
+  return {
+    path: path,
+    schema: schema["executeSerialize"]().item
+  };
+}
 function getValRouteUrlFromVal(resolvedParams, methodName,
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 path,
@@ -153,4 +193,4 @@ val) {
   return actualRoute;
 }
 
-export { getValRouteUrlFromVal as g, initValRouteFromVal as i };
+export { _typeof as _, isJsonValuesRecordSchema as a, getValRouteUrlFromVal as b, getJsonEntryStegaRoot as g, initValRouteFromVal as i };

package/dist/{routeFromVal-13c832b2.cjs.prod.js → routeFromVal-8ac2f984.cjs.prod.js}

@@ -16,6 +16,46 @@ function _typeof(o) {
   }, _typeof(o);
 }
 
+/**
+ * True when the module's schema is a `.jsonValues()` record/router — i.e. each
+ * entry value is a lazily-loaded `c.json(() => import(...))` marker. Used by the
+ * route helpers to load ONLY the matched entry instead of the whole record.
+ */
+function isJsonValuesRecordSchema(schema) {
+  return schema instanceof core.RecordSchema && schema["executeSerialize"]().jsonValues === true;
+}
+
+/**
+ * Builds the `stegaEncode` `root` seed for a single `.jsonValues()` entry, so its
+ * strings get edit tags. Without a seed, `stegaEncode` on raw entry content is an
+ * identity transform (the content carries no selector path/schema).
+ *
+ * Yields e.g. `/app/support/[slug]/page.val.ts?p="/support/faq"`, so a `title`
+ * field is tagged `…?p="/support/faq"."title"` — the shape the Studio's
+ * `findUnloadedJsonEntryKey` walks, so click-to-edit + lazy load line up.
+ */
+function getJsonEntryStegaRoot(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+selector, key
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+  var modulePath = selector && core.Internal.getValPath(selector);
+  if (!modulePath) {
+    return undefined;
+  }
+  var schema = selector && core.Internal.getSchema(selector);
+  if (!(schema instanceof core.RecordSchema)) {
+    return undefined;
+  }
+  var path = core.Internal.createValPathOfItem(modulePath, key);
+  if (!path) {
+    return undefined;
+  }
+  return {
+    path: path,
+    schema: schema["executeSerialize"]().item
+  };
+}
 function getValRouteUrlFromVal(resolvedParams, methodName,
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 path,
@@ -155,5 +195,8 @@ val) {
   return actualRoute;
 }
 
+exports._typeof = _typeof;
+exports.getJsonEntryStegaRoot = getJsonEntryStegaRoot;
 exports.getValRouteUrlFromVal = getValRouteUrlFromVal;
 exports.initValRouteFromVal = initValRouteFromVal;
+exports.isJsonValuesRecordSchema = isJsonValuesRecordSchema;

package/dist/{routeFromVal-9b610e77.cjs.dev.js → routeFromVal-b48a454a.cjs.dev.js}

@@ -16,6 +16,46 @@ function _typeof(o) {
   }, _typeof(o);
 }
 
+/**
+ * True when the module's schema is a `.jsonValues()` record/router — i.e. each
+ * entry value is a lazily-loaded `c.json(() => import(...))` marker. Used by the
+ * route helpers to load ONLY the matched entry instead of the whole record.
+ */
+function isJsonValuesRecordSchema(schema) {
+  return schema instanceof core.RecordSchema && schema["executeSerialize"]().jsonValues === true;
+}
+
+/**
+ * Builds the `stegaEncode` `root` seed for a single `.jsonValues()` entry, so its
+ * strings get edit tags. Without a seed, `stegaEncode` on raw entry content is an
+ * identity transform (the content carries no selector path/schema).
+ *
+ * Yields e.g. `/app/support/[slug]/page.val.ts?p="/support/faq"`, so a `title`
+ * field is tagged `…?p="/support/faq"."title"` — the shape the Studio's
+ * `findUnloadedJsonEntryKey` walks, so click-to-edit + lazy load line up.
+ */
+function getJsonEntryStegaRoot(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+selector, key
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+  var modulePath = selector && core.Internal.getValPath(selector);
+  if (!modulePath) {
+    return undefined;
+  }
+  var schema = selector && core.Internal.getSchema(selector);
+  if (!(schema instanceof core.RecordSchema)) {
+    return undefined;
+  }
+  var path = core.Internal.createValPathOfItem(modulePath, key);
+  if (!path) {
+    return undefined;
+  }
+  return {
+    path: path,
+    schema: schema["executeSerialize"]().item
+  };
+}
 function getValRouteUrlFromVal(resolvedParams, methodName,
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 path,
@@ -155,5 +195,8 @@ val) {
   return actualRoute;
 }
 
+exports._typeof = _typeof;
+exports.getJsonEntryStegaRoot = getJsonEntryStegaRoot;
 exports.getValRouteUrlFromVal = getValRouteUrlFromVal;
 exports.initValRouteFromVal = initValRouteFromVal;
+exports.isJsonValuesRecordSchema = isJsonValuesRecordSchema;

package/package.json

@@ -12,7 +12,7 @@
     "next",
     "react"
   ],
-  "version": "0.99.1",
+  "version": "0.101.0",
   "main": "dist/valbuild-next.cjs.js",
   "module": "dist/valbuild-next.esm.js",
   "exports": {
@@ -47,12 +47,12 @@
   "dependencies": {
     "client-only": "^0.0.1",
     "server-only": "^0.0.1",
-    "@valbuild/core": "0.99.1",
-    "@valbuild/language-server": "0.99.1",
-    "@valbuild/react": "0.99.1",
-    "@valbuild/server": "0.99.1",
-    "@valbuild/shared": "0.99.1",
-    "@valbuild/ui": "0.99.1"
+    "@valbuild/core": "0.101.0",
+    "@valbuild/language-server": "0.101.0",
+    "@valbuild/react": "0.101.0",
+    "@valbuild/server": "0.101.0",
+    "@valbuild/shared": "0.101.0",
+    "@valbuild/ui": "0.101.0"
   },
   "devDependencies": {
     "@testing-library/react": "^14.0.0",