@valbuild/next 0.144.11 → 0.145.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @valbuild/next
 
+## 0.145.0
+
+### Patch Changes
+
+- Updated dependencies [[`b6cb939`](https://github.com/valbuild/val/commit/b6cb9395d8bdcd5182e9c6ba84f5284930de2fa5), [`f085be0`](https://github.com/valbuild/val/commit/f085be0eb5bdc195e9d8cdb15dd5f8acfdabe23c), [`dda5c52`](https://github.com/valbuild/val/commit/dda5c523698395c6dfb96ae8e39dae04307ec332), [`ac0bb7c`](https://github.com/valbuild/val/commit/ac0bb7cb5a99df022b198326a5f8a0cf61e45388)]:
+  - @valbuild/core@0.145.0
+  - @valbuild/shared@0.145.0
+  - @valbuild/ui@0.145.0
+  - @valbuild/server@0.145.0
+  - @valbuild/mcp@0.145.0
+  - @valbuild/language-server@0.145.0
+  - @valbuild/react@0.145.0
+
+## 0.144.12
+
+### Patch Changes
+
+- [#854](https://github.com/valbuild/val/pull/854) [`2193e3a`](https://github.com/valbuild/val/commit/2193e3ae133cd05dd73d0937dde7c15c88417f71) Thanks [@freekh](https://github.com/freekh)! - `useVal` and `fetchVal` on a whole `.jsonValues()` record now give every entry's content. They gave each entry back empty in production, on the server and in the browser, because the record holds only a lazy import for each entry; content showed up only where a draft or a hosted content version supplied it. They now load every entry the record names, together. `useValKey` and `fetchValKey` still load only the entry they are asked for, which is the reader to use when a page shows one entry of a large record.
+- Updated dependencies [[`2193e3a`](https://github.com/valbuild/val/commit/2193e3ae133cd05dd73d0937dde7c15c88417f71)]:
+  - @valbuild/ui@0.144.12
+  - @valbuild/react@0.144.12
+  - @valbuild/server@0.144.12
+  - @valbuild/language-server@0.144.12
+  - @valbuild/mcp@0.144.12
+
 ## 0.144.11
 
 ### Patch Changes

package/client/dist/valbuild-next-client.cjs.dev.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 require('client-only');
-var routeFromVal = require('../../dist/routeFromVal-d53d5ffb.cjs.dev.js');
+var routeFromVal = require('../../dist/routeFromVal-52811ee4.cjs.dev.js');
 var core = require('@valbuild/core');
 var stega = require('@valbuild/react/stega');
 var React = require('react');
@@ -74,12 +74,34 @@ function useValStega(selector) {
   if (valOverlayContext.suspend && valOverlayContext.draftMode !== false && !valOverlayContext.draftSourcesSynced && store && !store.hasAllLoaded(moduleIds)) {
     React__default["default"].use(store.waitForLoad(moduleIds));
   }
+  var sourceOf = function sourceOf(moduleId) {
+    return moduleMap && valOverlayContext.draftMode ? moduleMap[moduleId] : undefined;
+  };
+  /*
+   * A whole `.jsonValues()` record is read with every entry's content: its own
+   * source holds only lazy markers. The entries the draft view does not have
+   * are imported from the bundle -- all of them started before waiting on any,
+   * so they load together. `useValKey` is the reader for one entry.
+   */
+  var jsonValues = routeFromVal.jsonValuesRecordToFill(selector, function (modulePath) {
+    return [sourceOf(modulePath)];
+  });
+  var filledRecord = null;
+  if (jsonValues !== null) {
+    var pending = jsonValues.load.map(function (key) {
+      return committedJsonEntryPromise(jsonValues.module, jsonValues.modulePath, key);
+    });
+    var loaded = {};
+    jsonValues.load.forEach(function (key, index) {
+      var promise = pending[index];
+      loaded[key] = promise === undefined ? undefined : React__default["default"].use(promise);
+    });
+    filledRecord = routeFromVal.fillJsonValuesRecord(jsonValues.record, loaded);
+  }
   return stega.stegaEncode(selector, {
     disabled: !valOverlayContext.draftMode,
     getModule: function getModule(moduleId) {
-      if (moduleMap && valOverlayContext.draftMode) {
-        return moduleMap[moduleId];
-      }
+      return jsonValues !== null && moduleId === jsonValues.modulePath ? filledRecord : sourceOf(moduleId);
     }
   });
 }
@@ -191,7 +213,6 @@ function useValKeyStega(selector, key) {
  * 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)) {
@@ -201,15 +222,31 @@ function readCommittedJsonEntry(selector, key) {
   if (!thunk) {
     return undefined;
   }
-  var cacheKey = "".concat((_Internal$getValPath = core.Internal.getValPath(selector)) !== null && _Internal$getValPath !== void 0 ? _Internal$getValPath : "", " ").concat(key);
+  var promise = committedJsonEntryPromise(selector, core.Internal.getValPath(selector), key);
+  return promise === undefined ? undefined : React__default["default"].use(promise);
+}
+
+/**
+ * The bundle's import of one entry, started once and kept, so every render
+ * that waits on it is handed the same promise (`React.use` needs that).
+ * `undefined` when the module has no import for `key`.
+ */
+function committedJsonEntryPromise(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+module, modulePath, key) {
+  var cacheKey = "".concat(modulePath !== null && modulePath !== void 0 ? modulePath : "", " ").concat(key);
   var promise = jsonEntryPromiseCache.get(cacheKey);
   if (!promise) {
+    var thunk = routeFromVal.bundledJsonEntryImport(module, key);
+    if (!thunk) {
+      return undefined;
+    }
     promise = thunk().then(function (mod) {
       return mod["default"];
     });
     jsonEntryPromiseCache.set(cacheKey, promise);
   }
-  return React__default["default"].use(promise);
+  return promise;
 }
 function resolveParams(params) {
   if (!params) {

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 require('client-only');
-var routeFromVal = require('../../dist/routeFromVal-e0995830.cjs.prod.js');
+var routeFromVal = require('../../dist/routeFromVal-6fc9f240.cjs.prod.js');
 var core = require('@valbuild/core');
 var stega = require('@valbuild/react/stega');
 var React = require('react');
@@ -74,12 +74,34 @@ function useValStega(selector) {
   if (valOverlayContext.suspend && valOverlayContext.draftMode !== false && !valOverlayContext.draftSourcesSynced && store && !store.hasAllLoaded(moduleIds)) {
     React__default["default"].use(store.waitForLoad(moduleIds));
   }
+  var sourceOf = function sourceOf(moduleId) {
+    return moduleMap && valOverlayContext.draftMode ? moduleMap[moduleId] : undefined;
+  };
+  /*
+   * A whole `.jsonValues()` record is read with every entry's content: its own
+   * source holds only lazy markers. The entries the draft view does not have
+   * are imported from the bundle -- all of them started before waiting on any,
+   * so they load together. `useValKey` is the reader for one entry.
+   */
+  var jsonValues = routeFromVal.jsonValuesRecordToFill(selector, function (modulePath) {
+    return [sourceOf(modulePath)];
+  });
+  var filledRecord = null;
+  if (jsonValues !== null) {
+    var pending = jsonValues.load.map(function (key) {
+      return committedJsonEntryPromise(jsonValues.module, jsonValues.modulePath, key);
+    });
+    var loaded = {};
+    jsonValues.load.forEach(function (key, index) {
+      var promise = pending[index];
+      loaded[key] = promise === undefined ? undefined : React__default["default"].use(promise);
+    });
+    filledRecord = routeFromVal.fillJsonValuesRecord(jsonValues.record, loaded);
+  }
   return stega.stegaEncode(selector, {
     disabled: !valOverlayContext.draftMode,
     getModule: function getModule(moduleId) {
-      if (moduleMap && valOverlayContext.draftMode) {
-        return moduleMap[moduleId];
-      }
+      return jsonValues !== null && moduleId === jsonValues.modulePath ? filledRecord : sourceOf(moduleId);
     }
   });
 }
@@ -191,7 +213,6 @@ function useValKeyStega(selector, key) {
  * 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)) {
@@ -201,15 +222,31 @@ function readCommittedJsonEntry(selector, key) {
   if (!thunk) {
     return undefined;
   }
-  var cacheKey = "".concat((_Internal$getValPath = core.Internal.getValPath(selector)) !== null && _Internal$getValPath !== void 0 ? _Internal$getValPath : "", " ").concat(key);
+  var promise = committedJsonEntryPromise(selector, core.Internal.getValPath(selector), key);
+  return promise === undefined ? undefined : React__default["default"].use(promise);
+}
+
+/**
+ * The bundle's import of one entry, started once and kept, so every render
+ * that waits on it is handed the same promise (`React.use` needs that).
+ * `undefined` when the module has no import for `key`.
+ */
+function committedJsonEntryPromise(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+module, modulePath, key) {
+  var cacheKey = "".concat(modulePath !== null && modulePath !== void 0 ? modulePath : "", " ").concat(key);
   var promise = jsonEntryPromiseCache.get(cacheKey);
   if (!promise) {
+    var thunk = routeFromVal.bundledJsonEntryImport(module, key);
+    if (!thunk) {
+      return undefined;
+    }
     promise = thunk().then(function (mod) {
       return mod["default"];
     });
     jsonEntryPromiseCache.set(cacheKey, promise);
   }
-  return React__default["default"].use(promise);
+  return promise;
 }
 function resolveParams(params) {
   if (!params) {

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

@@ -1,5 +1,5 @@
 import 'client-only';
-import { g as getJsonEntryStegaRoot, _ as _typeof, a as isJsonValuesRecordSchema, b as getValRouteUrlFromVal, i as initValRouteFromVal } from '../../dist/routeFromVal-544e8318.esm.js';
+import { j as jsonValuesRecordToFill, f as fillJsonValuesRecord, g as getJsonEntryStegaRoot, _ as _typeof, c as bundledJsonEntryImport, a as isJsonValuesRecordSchema, b as getValRouteUrlFromVal, i as initValRouteFromVal } from '../../dist/routeFromVal-fe1264b3.esm.js';
 import { Internal } from '@valbuild/core';
 import { getModuleIds, stegaEncode } from '@valbuild/react/stega';
 import React from 'react';
@@ -66,12 +66,34 @@ function useValStega(selector) {
   if (valOverlayContext.suspend && valOverlayContext.draftMode !== false && !valOverlayContext.draftSourcesSynced && store && !store.hasAllLoaded(moduleIds)) {
     React.use(store.waitForLoad(moduleIds));
   }
+  var sourceOf = function sourceOf(moduleId) {
+    return moduleMap && valOverlayContext.draftMode ? moduleMap[moduleId] : undefined;
+  };
+  /*
+   * A whole `.jsonValues()` record is read with every entry's content: its own
+   * source holds only lazy markers. The entries the draft view does not have
+   * are imported from the bundle -- all of them started before waiting on any,
+   * so they load together. `useValKey` is the reader for one entry.
+   */
+  var jsonValues = jsonValuesRecordToFill(selector, function (modulePath) {
+    return [sourceOf(modulePath)];
+  });
+  var filledRecord = null;
+  if (jsonValues !== null) {
+    var pending = jsonValues.load.map(function (key) {
+      return committedJsonEntryPromise(jsonValues.module, jsonValues.modulePath, key);
+    });
+    var loaded = {};
+    jsonValues.load.forEach(function (key, index) {
+      var promise = pending[index];
+      loaded[key] = promise === undefined ? undefined : React.use(promise);
+    });
+    filledRecord = fillJsonValuesRecord(jsonValues.record, loaded);
+  }
   return stegaEncode(selector, {
     disabled: !valOverlayContext.draftMode,
     getModule: function getModule(moduleId) {
-      if (moduleMap && valOverlayContext.draftMode) {
-        return moduleMap[moduleId];
-      }
+      return jsonValues !== null && moduleId === jsonValues.modulePath ? filledRecord : sourceOf(moduleId);
     }
   });
 }
@@ -183,7 +205,6 @@ function useValKeyStega(selector, key) {
  * 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)) {
@@ -193,15 +214,31 @@ function readCommittedJsonEntry(selector, key) {
   if (!thunk) {
     return undefined;
   }
-  var cacheKey = "".concat((_Internal$getValPath = Internal.getValPath(selector)) !== null && _Internal$getValPath !== void 0 ? _Internal$getValPath : "", " ").concat(key);
+  var promise = committedJsonEntryPromise(selector, Internal.getValPath(selector), key);
+  return promise === undefined ? undefined : React.use(promise);
+}
+
+/**
+ * The bundle's import of one entry, started once and kept, so every render
+ * that waits on it is handed the same promise (`React.use` needs that).
+ * `undefined` when the module has no import for `key`.
+ */
+function committedJsonEntryPromise(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+module, modulePath, key) {
+  var cacheKey = "".concat(modulePath !== null && modulePath !== void 0 ? modulePath : "", " ").concat(key);
   var promise = jsonEntryPromiseCache.get(cacheKey);
   if (!promise) {
+    var thunk = bundledJsonEntryImport(module, key);
+    if (!thunk) {
+      return undefined;
+    }
     promise = thunk().then(function (mod) {
       return mod["default"];
     });
     jsonEntryPromiseCache.set(cacheKey, promise);
   }
-  return React.use(promise);
+  return promise;
 }
 function resolveParams(params) {
   if (!params) {

package/dist/{routeFromVal-d53d5ffb.cjs.dev.js → routeFromVal-52811ee4.cjs.dev.js}

@@ -25,6 +25,116 @@ function isJsonValuesRecordSchema(schema) {
   return schema instanceof core.RecordSchema && schema["executeSerialize"]().jsonValues === true;
 }
 
+/**
+ * A whole `.jsonValues()` record, as `useVal` and `fetchVal` read it: with
+ * every entry's content. In the record's own source each entry is a lazy
+ * `c.json(() => import(...))` marker, so a reader that encodes that source
+ * renders every entry empty. (`useValKey` and `fetchValKey` read one entry,
+ * and load only that one.)
+ *
+ * `sourcesOf(modulePath)` are what the reader has before the bundle, the first
+ * that has the record winning: a draft view, then a snapshot (a proposal's saves, or the
+ * content version the site serves). An entry that is still a marker there is
+ * taken from a later source that has its content; the rest are named in
+ * `load`, for the reader to load from the bundle by key and hand to
+ * {@link fillJsonValuesRecord}.
+ *
+ * `null` when the selector is not a `.jsonValues()` module, or its record is
+ * not an object (a nullable record that is null): there is nothing to fill.
+ */
+function jsonValuesRecordToFill(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+selector, sourcesOf) {
+  // Untyped, as `getJsonEntryStegaRoot`'s selector is: a module or a view of
+  // one, whichever source type it was defined with.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var module = core.Internal.resolveViewedModule(selector);
+  if (!module || !isJsonValuesRecordSchema(core.Internal.getSchema(module))) {
+    return null;
+  }
+  var modulePath = core.Internal.getValPath(module);
+  if (!modulePath) {
+    return null;
+  }
+  var sources = sourcesOf(modulePath);
+  var isRecord = function isRecord(value) {
+    return _typeof(value) === "object" && value !== null && !Array.isArray(value);
+  };
+  var chosen = sources.find(function (source) {
+    return source !== undefined;
+  });
+  var base = chosen !== undefined ? chosen : core.Internal.getSource(module);
+  if (!isRecord(base)) {
+    return null;
+  }
+  var record = {};
+  var load = [];
+  var _loop = function _loop() {
+    var _Object$entries$_i = slicedToArray._slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      entry = _Object$entries$_i[1];
+    if (!core.Internal.isJson(entry)) {
+      record[key] = entry;
+      return 1; // continue
+    }
+    var later = sources.slice(sources.indexOf(chosen) + 1).map(function (source) {
+      return isRecord(source) && Object.prototype.hasOwnProperty.call(source, key) ? source[key] : undefined;
+    }).find(function (content) {
+      return content !== undefined && !core.Internal.isJson(content);
+    });
+    if (later !== undefined) {
+      record[key] = later;
+    } else {
+      // Left as the marker until it is loaded: see `fillJsonValuesRecord`.
+      record[key] = entry;
+      load.push(key);
+    }
+  };
+  for (var _i = 0, _Object$entries = Object.entries(base); _i < _Object$entries.length; _i++) {
+    if (_loop()) continue;
+  }
+  return {
+    modulePath: modulePath,
+    module: module,
+    record: record,
+    load: load
+  };
+}
+
+/**
+ * The record from {@link jsonValuesRecordToFill}, with the entries it named in
+ * `load` put in: `loaded[key]`, as the bundle's import of that entry gave it.
+ * An entry the bundle has no import for keeps its marker.
+ */
+function fillJsonValuesRecord(record, loaded) {
+  var filled = objectSpread2._objectSpread2({}, record);
+  for (var _i2 = 0, _Object$entries2 = Object.entries(loaded); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = slicedToArray._slicedToArray(_Object$entries2[_i2], 2),
+      key = _Object$entries2$_i[0],
+      content = _Object$entries2$_i[1];
+    if (content !== undefined) {
+      filled[key] = content;
+    }
+  }
+  return filled;
+}
+
+/**
+ * The bundle's import of one `.jsonValues()` entry, started: `undefined` when
+ * the module's own source has no marker for `key` to import from.
+ */
+function bundledJsonEntryImport(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+module, key) {
+  var _Internal$getJsonImpo;
+  var source = module && core.Internal.getSource(module);
+  var marker = _typeof(source) === "object" && source !== null && !Array.isArray(source) ? source[key] : undefined;
+  if (!core.Internal.isJson(marker)) {
+    return undefined;
+  }
+  return (_Internal$getJsonImpo = core.Internal.getJsonImport(marker)) !== null && _Internal$getJsonImpo !== void 0 ? _Internal$getJsonImpo : undefined;
+}
+
 /**
  * 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
@@ -196,7 +306,10 @@ val) {
 }
 
 exports._typeof = _typeof;
+exports.bundledJsonEntryImport = bundledJsonEntryImport;
+exports.fillJsonValuesRecord = fillJsonValuesRecord;
 exports.getJsonEntryStegaRoot = getJsonEntryStegaRoot;
 exports.getValRouteUrlFromVal = getValRouteUrlFromVal;
 exports.initValRouteFromVal = initValRouteFromVal;
 exports.isJsonValuesRecordSchema = isJsonValuesRecordSchema;
+exports.jsonValuesRecordToFill = jsonValuesRecordToFill;

package/dist/{routeFromVal-e0995830.cjs.prod.js → routeFromVal-6fc9f240.cjs.prod.js}

@@ -25,6 +25,116 @@ function isJsonValuesRecordSchema(schema) {
   return schema instanceof core.RecordSchema && schema["executeSerialize"]().jsonValues === true;
 }
 
+/**
+ * A whole `.jsonValues()` record, as `useVal` and `fetchVal` read it: with
+ * every entry's content. In the record's own source each entry is a lazy
+ * `c.json(() => import(...))` marker, so a reader that encodes that source
+ * renders every entry empty. (`useValKey` and `fetchValKey` read one entry,
+ * and load only that one.)
+ *
+ * `sourcesOf(modulePath)` are what the reader has before the bundle, the first
+ * that has the record winning: a draft view, then a snapshot (a proposal's saves, or the
+ * content version the site serves). An entry that is still a marker there is
+ * taken from a later source that has its content; the rest are named in
+ * `load`, for the reader to load from the bundle by key and hand to
+ * {@link fillJsonValuesRecord}.
+ *
+ * `null` when the selector is not a `.jsonValues()` module, or its record is
+ * not an object (a nullable record that is null): there is nothing to fill.
+ */
+function jsonValuesRecordToFill(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+selector, sourcesOf) {
+  // Untyped, as `getJsonEntryStegaRoot`'s selector is: a module or a view of
+  // one, whichever source type it was defined with.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var module = core.Internal.resolveViewedModule(selector);
+  if (!module || !isJsonValuesRecordSchema(core.Internal.getSchema(module))) {
+    return null;
+  }
+  var modulePath = core.Internal.getValPath(module);
+  if (!modulePath) {
+    return null;
+  }
+  var sources = sourcesOf(modulePath);
+  var isRecord = function isRecord(value) {
+    return _typeof(value) === "object" && value !== null && !Array.isArray(value);
+  };
+  var chosen = sources.find(function (source) {
+    return source !== undefined;
+  });
+  var base = chosen !== undefined ? chosen : core.Internal.getSource(module);
+  if (!isRecord(base)) {
+    return null;
+  }
+  var record = {};
+  var load = [];
+  var _loop = function _loop() {
+    var _Object$entries$_i = slicedToArray._slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      entry = _Object$entries$_i[1];
+    if (!core.Internal.isJson(entry)) {
+      record[key] = entry;
+      return 1; // continue
+    }
+    var later = sources.slice(sources.indexOf(chosen) + 1).map(function (source) {
+      return isRecord(source) && Object.prototype.hasOwnProperty.call(source, key) ? source[key] : undefined;
+    }).find(function (content) {
+      return content !== undefined && !core.Internal.isJson(content);
+    });
+    if (later !== undefined) {
+      record[key] = later;
+    } else {
+      // Left as the marker until it is loaded: see `fillJsonValuesRecord`.
+      record[key] = entry;
+      load.push(key);
+    }
+  };
+  for (var _i = 0, _Object$entries = Object.entries(base); _i < _Object$entries.length; _i++) {
+    if (_loop()) continue;
+  }
+  return {
+    modulePath: modulePath,
+    module: module,
+    record: record,
+    load: load
+  };
+}
+
+/**
+ * The record from {@link jsonValuesRecordToFill}, with the entries it named in
+ * `load` put in: `loaded[key]`, as the bundle's import of that entry gave it.
+ * An entry the bundle has no import for keeps its marker.
+ */
+function fillJsonValuesRecord(record, loaded) {
+  var filled = objectSpread2._objectSpread2({}, record);
+  for (var _i2 = 0, _Object$entries2 = Object.entries(loaded); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = slicedToArray._slicedToArray(_Object$entries2[_i2], 2),
+      key = _Object$entries2$_i[0],
+      content = _Object$entries2$_i[1];
+    if (content !== undefined) {
+      filled[key] = content;
+    }
+  }
+  return filled;
+}
+
+/**
+ * The bundle's import of one `.jsonValues()` entry, started: `undefined` when
+ * the module's own source has no marker for `key` to import from.
+ */
+function bundledJsonEntryImport(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+module, key) {
+  var _Internal$getJsonImpo;
+  var source = module && core.Internal.getSource(module);
+  var marker = _typeof(source) === "object" && source !== null && !Array.isArray(source) ? source[key] : undefined;
+  if (!core.Internal.isJson(marker)) {
+    return undefined;
+  }
+  return (_Internal$getJsonImpo = core.Internal.getJsonImport(marker)) !== null && _Internal$getJsonImpo !== void 0 ? _Internal$getJsonImpo : undefined;
+}
+
 /**
  * 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
@@ -196,7 +306,10 @@ val) {
 }
 
 exports._typeof = _typeof;
+exports.bundledJsonEntryImport = bundledJsonEntryImport;
+exports.fillJsonValuesRecord = fillJsonValuesRecord;
 exports.getJsonEntryStegaRoot = getJsonEntryStegaRoot;
 exports.getValRouteUrlFromVal = getValRouteUrlFromVal;
 exports.initValRouteFromVal = initValRouteFromVal;
 exports.isJsonValuesRecordSchema = isJsonValuesRecordSchema;
+exports.jsonValuesRecordToFill = jsonValuesRecordToFill;

package/dist/{routeFromVal-544e8318.esm.js → routeFromVal-fe1264b3.esm.js}

@@ -23,6 +23,116 @@ function isJsonValuesRecordSchema(schema) {
   return schema instanceof RecordSchema && schema["executeSerialize"]().jsonValues === true;
 }
 
+/**
+ * A whole `.jsonValues()` record, as `useVal` and `fetchVal` read it: with
+ * every entry's content. In the record's own source each entry is a lazy
+ * `c.json(() => import(...))` marker, so a reader that encodes that source
+ * renders every entry empty. (`useValKey` and `fetchValKey` read one entry,
+ * and load only that one.)
+ *
+ * `sourcesOf(modulePath)` are what the reader has before the bundle, the first
+ * that has the record winning: a draft view, then a snapshot (a proposal's saves, or the
+ * content version the site serves). An entry that is still a marker there is
+ * taken from a later source that has its content; the rest are named in
+ * `load`, for the reader to load from the bundle by key and hand to
+ * {@link fillJsonValuesRecord}.
+ *
+ * `null` when the selector is not a `.jsonValues()` module, or its record is
+ * not an object (a nullable record that is null): there is nothing to fill.
+ */
+function jsonValuesRecordToFill(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+selector, sourcesOf) {
+  // Untyped, as `getJsonEntryStegaRoot`'s selector is: a module or a view of
+  // one, whichever source type it was defined with.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var module = Internal.resolveViewedModule(selector);
+  if (!module || !isJsonValuesRecordSchema(Internal.getSchema(module))) {
+    return null;
+  }
+  var modulePath = Internal.getValPath(module);
+  if (!modulePath) {
+    return null;
+  }
+  var sources = sourcesOf(modulePath);
+  var isRecord = function isRecord(value) {
+    return _typeof(value) === "object" && value !== null && !Array.isArray(value);
+  };
+  var chosen = sources.find(function (source) {
+    return source !== undefined;
+  });
+  var base = chosen !== undefined ? chosen : Internal.getSource(module);
+  if (!isRecord(base)) {
+    return null;
+  }
+  var record = {};
+  var load = [];
+  var _loop = function _loop() {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      entry = _Object$entries$_i[1];
+    if (!Internal.isJson(entry)) {
+      record[key] = entry;
+      return 1; // continue
+    }
+    var later = sources.slice(sources.indexOf(chosen) + 1).map(function (source) {
+      return isRecord(source) && Object.prototype.hasOwnProperty.call(source, key) ? source[key] : undefined;
+    }).find(function (content) {
+      return content !== undefined && !Internal.isJson(content);
+    });
+    if (later !== undefined) {
+      record[key] = later;
+    } else {
+      // Left as the marker until it is loaded: see `fillJsonValuesRecord`.
+      record[key] = entry;
+      load.push(key);
+    }
+  };
+  for (var _i = 0, _Object$entries = Object.entries(base); _i < _Object$entries.length; _i++) {
+    if (_loop()) continue;
+  }
+  return {
+    modulePath: modulePath,
+    module: module,
+    record: record,
+    load: load
+  };
+}
+
+/**
+ * The record from {@link jsonValuesRecordToFill}, with the entries it named in
+ * `load` put in: `loaded[key]`, as the bundle's import of that entry gave it.
+ * An entry the bundle has no import for keeps its marker.
+ */
+function fillJsonValuesRecord(record, loaded) {
+  var filled = _objectSpread2({}, record);
+  for (var _i2 = 0, _Object$entries2 = Object.entries(loaded); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+      key = _Object$entries2$_i[0],
+      content = _Object$entries2$_i[1];
+    if (content !== undefined) {
+      filled[key] = content;
+    }
+  }
+  return filled;
+}
+
+/**
+ * The bundle's import of one `.jsonValues()` entry, started: `undefined` when
+ * the module's own source has no marker for `key` to import from.
+ */
+function bundledJsonEntryImport(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+module, key) {
+  var _Internal$getJsonImpo;
+  var source = module && Internal.getSource(module);
+  var marker = _typeof(source) === "object" && source !== null && !Array.isArray(source) ? source[key] : undefined;
+  if (!Internal.isJson(marker)) {
+    return undefined;
+  }
+  return (_Internal$getJsonImpo = Internal.getJsonImport(marker)) !== null && _Internal$getJsonImpo !== void 0 ? _Internal$getJsonImpo : undefined;
+}
+
 /**
  * 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
@@ -193,4 +303,4 @@ val) {
   return actualRoute;
 }
 
-export { _typeof as _, isJsonValuesRecordSchema as a, getValRouteUrlFromVal as b, getJsonEntryStegaRoot as g, initValRouteFromVal as i };
+export { _typeof as _, isJsonValuesRecordSchema as a, getValRouteUrlFromVal as b, bundledJsonEntryImport as c, fillJsonValuesRecord as f, getJsonEntryStegaRoot as g, initValRouteFromVal as i, jsonValuesRecordToFill as j };

package/dist/valbuild-next.cjs.dev.js

@@ -14,7 +14,7 @@ var jsxRuntime = require('react/jsx-runtime');
 var ValVideo = require('./ValVideo-b8130c1b.cjs.dev.js');
 var ValApp = require('./ValApp-294e5b53.cjs.dev.js');
 var ValModulesClient = require('./ValModulesClient-4ecabf99.cjs.dev.js');
-var version = require('./version-a2a4b93c.cjs.dev.js');
+var version = require('./version-82277719.cjs.dev.js');
 var createForOfIteratorHelper = require('./createForOfIteratorHelper-0445603c.cjs.dev.js');
 require('./defineProperty-f90345d7.cjs.dev.js');
 require('./unsupportedIterableToArray-c8ab77c9.cjs.dev.js');