@valbuild/react 0.132.1 → 0.134.0

package/dist/{raw-7ce61255.esm.js → raw-bd3105cd.esm.js}

@@ -1,5 +1,5 @@
 import { b as _unsupportedIterableToArray, a as _typeof, _ as _slicedToArray } from './slicedToArray-0c0a3b4a.esm.js';
-import { Internal } from '@valbuild/core';
+import { Internal, isValViewSource } from '@valbuild/core';
 import { vercelStegaDecodeAll, vercelStegaSplit, vercelStegaCombine } from '@vercel/stega';
 
 function _createForOfIteratorHelper(r, e) {
@@ -142,6 +142,48 @@ function _objectSpread2(e) {
  * RichText is accessible by users (after conversion via useVal / fetchVal)
  **/
 
+/**
+ * What resolving `T` gives back — the one definition the framework readers
+ * share.
+ *
+ * Two shapes go in. A module or selector resolves as it always has. A
+ * {@link ValView}, which is what a `s.view()` field reads as, resolves to the
+ * module it points at: the page declares what it shows, and a reader follows
+ * that declaration instead of importing the target a second time.
+ *
+ * One definition rather than one per reader — `useVal`, `fetchVal`,
+ * `initValContent` and the TanStack client each had their own copy of the
+ * selector half, which is four places for the view half to be forgotten in.
+ *
+ * `Target extends Source` is checked HERE rather than on `ValView` itself:
+ * `ValView` is built from `ValViewSource`, which is a member of the `Source`
+ * union, so a constraint there is a circular type reference.
+ *
+ * The outer arms are wrapped in tuples so the conditional does not DISTRIBUTE
+ * over a union: distributing it re-entered `StegaOfSource` per member and the
+ * async readers hit "Type instantiation is excessively deep and possibly
+ * infinite" — `useVal` did not, because a `Promise<...>` around it is one more
+ * level than the checker had left.
+ */
+
+/** What a reader accepts. A view handle is a `SelectorSource`, so this is it. */
+
+/**
+ * The source of whichever arm of `ResolvableModule` a reader was given — the
+ * module's own, or that of the module a view points at.
+ */
+
+/**
+ * The (loosened) content type a single `.jsonValues()` entry resolves to.
+ *
+ * Here rather than in the framework packages because there were four identical
+ * copies of it — next's client and rsc readers, tanstack's client and server —
+ * and the view arm would have had to be added to each. Same reason
+ * {@link ResolvedVal} lives here.
+ */
+
+/** What a route reader gives back for the entry the params matched. */
+
 /**
  * Resolves the matching variant of a discriminated union from the value's tag.
  * Returns the matching schema or null if no match is found.
@@ -241,7 +283,55 @@ function handleRichTextSchema(sourceOrSelector, recOpts, rec) {
   return sourceOrSelector;
 }
 function stegaEncode(input, opts) {
+  var viewModules = new Map();
+  // Handed a view handle rather than a module: resolve it and encode what it
+  // points at. This is what makes `useVal(page.header)` read the header.
+  var resolved = Internal.viewHandleModule(input);
+  if (resolved !== undefined) {
+    return stegaEncode(resolved, opts);
+  }
+  // A view pointer with no module on it. The module rides on a symbol, and
+  // symbols do not survive serialization — so this is a handle that crossed the
+  // server/client boundary as a prop, or one read out of raw JSON. Resolving it
+  // would hand back the pointer itself, which looks like content and is not, so
+  // say what happened instead.
+  if (isValViewSource(input)) {
+    throw Error("Cannot resolve the view of '".concat(input.view, "': it carries no module. ") + "Either it crossed a server/client boundary, which drops the module because it rides on a symbol, " + "or it points at a different module than its schema declares \u2014 which `val validate --fix` repairs. " + "Resolve it in the same component that read the module containing it, or read '".concat(input.view, "' directly."));
+  }
   function rec(sourceOrSelector, recOpts) {
+    // A view is a pointer at another module. Weaving an edit tag into it would
+    // corrupt the path it holds, and there is nothing of the target here to
+    // encode — the target is its own module, encoded when it is read.
+    //
+    // The module it names rides along on a symbol, so `useVal(page.header)` can
+    // resolve it without a path-to-module registry the app does not have. The
+    // pointer itself is unchanged: symbols do not serialize, so this is still
+    // `{ view: "/foo.val.ts" }` to anything that looks at it as data.
+    if (recOpts !== null && recOpts !== void 0 && recOpts.schema && recOpts.schema.type === "view") {
+      var valModule = viewModules.get(recOpts.schema.moduleFilePath);
+      if (valModule === undefined || !isValViewSource(sourceOrSelector)) {
+        return sourceOrSelector;
+      }
+      /*
+       * The POINTER decides what may be attached, not the schema alone.
+       *
+       * The two can disagree: a `.val.ts` cannot express it (the source type is
+       * the literal path), but hand-written JSON and a patch can, which is the
+       * whole reason `view:check-module` exists as a fix. Keying only on the
+       * schema attached the schema's module to a pointer naming a different one,
+       * so `useVal(page.field)` read a module the value does not name — silently,
+       * and looking exactly like a correct read.
+       *
+       * So a mismatch gets no handle: the value stays the bare pointer, and
+       * reading it throws rather than answering with the wrong module. The
+       * Studio still renders the field and still offers the repair; nothing here
+       * refuses to encode the page over it.
+       */
+      if (sourceOrSelector.view !== recOpts.schema.moduleFilePath) {
+        return sourceOrSelector;
+      }
+      return Internal.createViewHandle(sourceOrSelector, valModule);
+    }
     if (recOpts !== null && recOpts !== void 0 && recOpts.schema && isKeyOfSchema(recOpts === null || recOpts === void 0 ? void 0 : recOpts.schema)) {
       return sourceOrSelector;
     }
@@ -304,6 +394,25 @@ function stegaEncode(input, opts) {
       var selectorPath = Internal.getValPath(sourceOrSelector);
       if (selectorPath) {
         var newSchema = Internal.getSchema(sourceOrSelector);
+        // The modules this module's views point at. Collected HERE because this
+        // is the only place with the schema INSTANCE — everything below walks
+        // the serialized schema, which carries a path and not a module. Merged
+        // rather than replaced: a handle resolved by `useVal` re-enters here as
+        // its own module, and its parent's views must stay resolvable.
+        var _iterator = _createForOfIteratorHelper(Internal.viewModulesOf(newSchema)),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _step$value = _slicedToArray(_step.value, 2),
+              path = _step$value[0],
+              _valModule = _step$value[1];
+            viewModules.set(path, _valModule);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
         return rec(opts.getModule && opts.getModule(selectorPath) !== undefined ? opts.getModule(selectorPath) : Internal.getSource(sourceOrSelector), {
           path: selectorPath,
           schema: newSchema === null || newSchema === void 0 ? void 0 : newSchema["executeSerialize"]()
@@ -421,24 +530,65 @@ function collectReferencedModulesFromSchema(schema, acc) {
   } else if (schema.type === "array" || schema.type === "record") {
     collectReferencedModulesFromSchema(schema.item, acc);
   } else if (schema.type === "discriminated-union") {
-    var _iterator = _createForOfIteratorHelper(schema.items),
-      _step;
+    var _iterator2 = _createForOfIteratorHelper(schema.items),
+      _step2;
     try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var item = _step.value;
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var item = _step2.value;
         collectReferencedModulesFromSchema(item, acc);
       }
     } catch (err) {
-      _iterator.e(err);
+      _iterator2.e(err);
     } finally {
-      _iterator.f();
+      _iterator2.f();
     }
   }
 }
 function stegaClean(source) {
   return vercelStegaSplit(source).cleaned;
 }
+
+/**
+ * Answers already computed, keyed by the selector they were computed from.
+ *
+ * `getModuleIds` is not cheap: it calls `executeSerialize()`, which rebuilds the
+ * whole serialized schema tree on every call — ~31us for a 40-field schema with
+ * a nested array, against ~4us for a small one. It is called from `useValStega`
+ * on every render whose `useMemo` misses.
+ *
+ * That memo misses on every render for a VIEW, and cannot be fixed there: the
+ * handle is built by `createViewHandle` inside `stegaEncode`, so `page.authors`
+ * is a fresh object each time the page is encoded, and `[selector]` is a new
+ * dependency every render. Caching here rather than in the hooks fixes it for
+ * both copies of the hook at once, and for any other caller.
+ *
+ * Keyed on the selector, which is the module itself for the case that matters —
+ * a view resolves to it on the line below, and a module is a module-level
+ * constant, so the entry is hit for the life of the process. A fresh nested
+ * selector misses, as it did before; a `WeakMap` lets those entries go.
+ *
+ * The array is shared, so it is frozen: nothing may sort or splice it in place.
+ * Every consumer today copies first (`createSubscriberId` does `paths.slice()`),
+ * and freezing is what keeps that true.
+ */
+var moduleIdsCache = new WeakMap();
 function getModuleIds(input) {
+  // A view handle names one module: the one it points at. Resolved first so a
+  // `useVal(page.header)` subscribes to the header rather than to nothing — and
+  // so the recursive call lands on the module, which is what the cache above
+  // can actually key on.
+  var resolved = Internal.viewHandleModule(input);
+  if (resolved !== undefined) {
+    return getModuleIds(resolved);
+  }
+  var cacheable = _typeof(input) === "object" && input !== null;
+  if (cacheable) {
+    var cached = moduleIdsCache.get(input);
+    if (cached) {
+      // Frozen, so handing the same array to every caller is safe.
+      return cached;
+    }
+  }
   var modules = new Set();
   function rec(sourceOrSelector) {
     if (_typeof(sourceOrSelector) === "object") {
@@ -482,7 +632,14 @@ function getModuleIds(input) {
     return;
   }
   rec(input);
-  return Array.from(modules);
+  var moduleIds = Array.from(modules);
+  // Frozen before it is shared, not after: a consumer that sorts in place would
+  // otherwise corrupt every later caller's answer, and silently.
+  Object.freeze(moduleIds);
+  if (cacheable) {
+    moduleIdsCache.set(input, moduleIds);
+  }
+  return moduleIds;
 }
 
 function attrs(target) {

package/dist/{raw-57f19ada.browser.esm.js → raw-d6f65f06.browser.esm.js}

@@ -1,5 +1,5 @@
 import { b as _unsupportedIterableToArray, a as _typeof, _ as _slicedToArray } from './slicedToArray-9cce0d9f.browser.esm.js';
-import { Internal } from '@valbuild/core';
+import { Internal, isValViewSource } from '@valbuild/core';
 import { vercelStegaDecodeAll, vercelStegaSplit, vercelStegaCombine } from '@vercel/stega';
 
 function _createForOfIteratorHelper(r, e) {
@@ -142,6 +142,48 @@ function _objectSpread2(e) {
  * RichText is accessible by users (after conversion via useVal / fetchVal)
  **/
 
+/**
+ * What resolving `T` gives back — the one definition the framework readers
+ * share.
+ *
+ * Two shapes go in. A module or selector resolves as it always has. A
+ * {@link ValView}, which is what a `s.view()` field reads as, resolves to the
+ * module it points at: the page declares what it shows, and a reader follows
+ * that declaration instead of importing the target a second time.
+ *
+ * One definition rather than one per reader — `useVal`, `fetchVal`,
+ * `initValContent` and the TanStack client each had their own copy of the
+ * selector half, which is four places for the view half to be forgotten in.
+ *
+ * `Target extends Source` is checked HERE rather than on `ValView` itself:
+ * `ValView` is built from `ValViewSource`, which is a member of the `Source`
+ * union, so a constraint there is a circular type reference.
+ *
+ * The outer arms are wrapped in tuples so the conditional does not DISTRIBUTE
+ * over a union: distributing it re-entered `StegaOfSource` per member and the
+ * async readers hit "Type instantiation is excessively deep and possibly
+ * infinite" — `useVal` did not, because a `Promise<...>` around it is one more
+ * level than the checker had left.
+ */
+
+/** What a reader accepts. A view handle is a `SelectorSource`, so this is it. */
+
+/**
+ * The source of whichever arm of `ResolvableModule` a reader was given — the
+ * module's own, or that of the module a view points at.
+ */
+
+/**
+ * The (loosened) content type a single `.jsonValues()` entry resolves to.
+ *
+ * Here rather than in the framework packages because there were four identical
+ * copies of it — next's client and rsc readers, tanstack's client and server —
+ * and the view arm would have had to be added to each. Same reason
+ * {@link ResolvedVal} lives here.
+ */
+
+/** What a route reader gives back for the entry the params matched. */
+
 /**
  * Resolves the matching variant of a discriminated union from the value's tag.
  * Returns the matching schema or null if no match is found.
@@ -241,7 +283,55 @@ function handleRichTextSchema(sourceOrSelector, recOpts, rec) {
   return sourceOrSelector;
 }
 function stegaEncode(input, opts) {
+  var viewModules = new Map();
+  // Handed a view handle rather than a module: resolve it and encode what it
+  // points at. This is what makes `useVal(page.header)` read the header.
+  var resolved = Internal.viewHandleModule(input);
+  if (resolved !== undefined) {
+    return stegaEncode(resolved, opts);
+  }
+  // A view pointer with no module on it. The module rides on a symbol, and
+  // symbols do not survive serialization — so this is a handle that crossed the
+  // server/client boundary as a prop, or one read out of raw JSON. Resolving it
+  // would hand back the pointer itself, which looks like content and is not, so
+  // say what happened instead.
+  if (isValViewSource(input)) {
+    throw Error("Cannot resolve the view of '".concat(input.view, "': it carries no module. ") + "Either it crossed a server/client boundary, which drops the module because it rides on a symbol, " + "or it points at a different module than its schema declares \u2014 which `val validate --fix` repairs. " + "Resolve it in the same component that read the module containing it, or read '".concat(input.view, "' directly."));
+  }
   function rec(sourceOrSelector, recOpts) {
+    // A view is a pointer at another module. Weaving an edit tag into it would
+    // corrupt the path it holds, and there is nothing of the target here to
+    // encode — the target is its own module, encoded when it is read.
+    //
+    // The module it names rides along on a symbol, so `useVal(page.header)` can
+    // resolve it without a path-to-module registry the app does not have. The
+    // pointer itself is unchanged: symbols do not serialize, so this is still
+    // `{ view: "/foo.val.ts" }` to anything that looks at it as data.
+    if (recOpts !== null && recOpts !== void 0 && recOpts.schema && recOpts.schema.type === "view") {
+      var valModule = viewModules.get(recOpts.schema.moduleFilePath);
+      if (valModule === undefined || !isValViewSource(sourceOrSelector)) {
+        return sourceOrSelector;
+      }
+      /*
+       * The POINTER decides what may be attached, not the schema alone.
+       *
+       * The two can disagree: a `.val.ts` cannot express it (the source type is
+       * the literal path), but hand-written JSON and a patch can, which is the
+       * whole reason `view:check-module` exists as a fix. Keying only on the
+       * schema attached the schema's module to a pointer naming a different one,
+       * so `useVal(page.field)` read a module the value does not name — silently,
+       * and looking exactly like a correct read.
+       *
+       * So a mismatch gets no handle: the value stays the bare pointer, and
+       * reading it throws rather than answering with the wrong module. The
+       * Studio still renders the field and still offers the repair; nothing here
+       * refuses to encode the page over it.
+       */
+      if (sourceOrSelector.view !== recOpts.schema.moduleFilePath) {
+        return sourceOrSelector;
+      }
+      return Internal.createViewHandle(sourceOrSelector, valModule);
+    }
     if (recOpts !== null && recOpts !== void 0 && recOpts.schema && isKeyOfSchema(recOpts === null || recOpts === void 0 ? void 0 : recOpts.schema)) {
       return sourceOrSelector;
     }
@@ -304,6 +394,25 @@ function stegaEncode(input, opts) {
       var selectorPath = Internal.getValPath(sourceOrSelector);
       if (selectorPath) {
         var newSchema = Internal.getSchema(sourceOrSelector);
+        // The modules this module's views point at. Collected HERE because this
+        // is the only place with the schema INSTANCE — everything below walks
+        // the serialized schema, which carries a path and not a module. Merged
+        // rather than replaced: a handle resolved by `useVal` re-enters here as
+        // its own module, and its parent's views must stay resolvable.
+        var _iterator = _createForOfIteratorHelper(Internal.viewModulesOf(newSchema)),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _step$value = _slicedToArray(_step.value, 2),
+              path = _step$value[0],
+              _valModule = _step$value[1];
+            viewModules.set(path, _valModule);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
         return rec(opts.getModule && opts.getModule(selectorPath) !== undefined ? opts.getModule(selectorPath) : Internal.getSource(sourceOrSelector), {
           path: selectorPath,
           schema: newSchema === null || newSchema === void 0 ? void 0 : newSchema["executeSerialize"]()
@@ -421,24 +530,65 @@ function collectReferencedModulesFromSchema(schema, acc) {
   } else if (schema.type === "array" || schema.type === "record") {
     collectReferencedModulesFromSchema(schema.item, acc);
   } else if (schema.type === "discriminated-union") {
-    var _iterator = _createForOfIteratorHelper(schema.items),
-      _step;
+    var _iterator2 = _createForOfIteratorHelper(schema.items),
+      _step2;
     try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var item = _step.value;
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var item = _step2.value;
         collectReferencedModulesFromSchema(item, acc);
       }
     } catch (err) {
-      _iterator.e(err);
+      _iterator2.e(err);
     } finally {
-      _iterator.f();
+      _iterator2.f();
     }
   }
 }
 function stegaClean(source) {
   return vercelStegaSplit(source).cleaned;
 }
+
+/**
+ * Answers already computed, keyed by the selector they were computed from.
+ *
+ * `getModuleIds` is not cheap: it calls `executeSerialize()`, which rebuilds the
+ * whole serialized schema tree on every call — ~31us for a 40-field schema with
+ * a nested array, against ~4us for a small one. It is called from `useValStega`
+ * on every render whose `useMemo` misses.
+ *
+ * That memo misses on every render for a VIEW, and cannot be fixed there: the
+ * handle is built by `createViewHandle` inside `stegaEncode`, so `page.authors`
+ * is a fresh object each time the page is encoded, and `[selector]` is a new
+ * dependency every render. Caching here rather than in the hooks fixes it for
+ * both copies of the hook at once, and for any other caller.
+ *
+ * Keyed on the selector, which is the module itself for the case that matters —
+ * a view resolves to it on the line below, and a module is a module-level
+ * constant, so the entry is hit for the life of the process. A fresh nested
+ * selector misses, as it did before; a `WeakMap` lets those entries go.
+ *
+ * The array is shared, so it is frozen: nothing may sort or splice it in place.
+ * Every consumer today copies first (`createSubscriberId` does `paths.slice()`),
+ * and freezing is what keeps that true.
+ */
+var moduleIdsCache = new WeakMap();
 function getModuleIds(input) {
+  // A view handle names one module: the one it points at. Resolved first so a
+  // `useVal(page.header)` subscribes to the header rather than to nothing — and
+  // so the recursive call lands on the module, which is what the cache above
+  // can actually key on.
+  var resolved = Internal.viewHandleModule(input);
+  if (resolved !== undefined) {
+    return getModuleIds(resolved);
+  }
+  var cacheable = _typeof(input) === "object" && input !== null;
+  if (cacheable) {
+    var cached = moduleIdsCache.get(input);
+    if (cached) {
+      // Frozen, so handing the same array to every caller is safe.
+      return cached;
+    }
+  }
   var modules = new Set();
   function rec(sourceOrSelector) {
     if (_typeof(sourceOrSelector) === "object") {
@@ -482,7 +632,14 @@ function getModuleIds(input) {
     return;
   }
   rec(input);
-  return Array.from(modules);
+  var moduleIds = Array.from(modules);
+  // Frozen before it is shared, not after: a consumer that sorts in place would
+  // otherwise corrupt every later caller's answer, and silently.
+  Object.freeze(moduleIds);
+  if (cacheable) {
+    moduleIdsCache.set(input, moduleIds);
+  }
+  return moduleIds;
 }
 
 function attrs(target) {

package/dist/{raw-512e7a0a.cjs.dev.js → raw-ec62616c.cjs.dev.js}

@@ -144,6 +144,48 @@ function _objectSpread2(e) {
  * RichText is accessible by users (after conversion via useVal / fetchVal)
  **/
 
+/**
+ * What resolving `T` gives back — the one definition the framework readers
+ * share.
+ *
+ * Two shapes go in. A module or selector resolves as it always has. A
+ * {@link ValView}, which is what a `s.view()` field reads as, resolves to the
+ * module it points at: the page declares what it shows, and a reader follows
+ * that declaration instead of importing the target a second time.
+ *
+ * One definition rather than one per reader — `useVal`, `fetchVal`,
+ * `initValContent` and the TanStack client each had their own copy of the
+ * selector half, which is four places for the view half to be forgotten in.
+ *
+ * `Target extends Source` is checked HERE rather than on `ValView` itself:
+ * `ValView` is built from `ValViewSource`, which is a member of the `Source`
+ * union, so a constraint there is a circular type reference.
+ *
+ * The outer arms are wrapped in tuples so the conditional does not DISTRIBUTE
+ * over a union: distributing it re-entered `StegaOfSource` per member and the
+ * async readers hit "Type instantiation is excessively deep and possibly
+ * infinite" — `useVal` did not, because a `Promise<...>` around it is one more
+ * level than the checker had left.
+ */
+
+/** What a reader accepts. A view handle is a `SelectorSource`, so this is it. */
+
+/**
+ * The source of whichever arm of `ResolvableModule` a reader was given — the
+ * module's own, or that of the module a view points at.
+ */
+
+/**
+ * The (loosened) content type a single `.jsonValues()` entry resolves to.
+ *
+ * Here rather than in the framework packages because there were four identical
+ * copies of it — next's client and rsc readers, tanstack's client and server —
+ * and the view arm would have had to be added to each. Same reason
+ * {@link ResolvedVal} lives here.
+ */
+
+/** What a route reader gives back for the entry the params matched. */
+
 /**
  * Resolves the matching variant of a discriminated union from the value's tag.
  * Returns the matching schema or null if no match is found.
@@ -243,7 +285,55 @@ function handleRichTextSchema(sourceOrSelector, recOpts, rec) {
   return sourceOrSelector;
 }
 function stegaEncode(input, opts) {
+  var viewModules = new Map();
+  // Handed a view handle rather than a module: resolve it and encode what it
+  // points at. This is what makes `useVal(page.header)` read the header.
+  var resolved = core.Internal.viewHandleModule(input);
+  if (resolved !== undefined) {
+    return stegaEncode(resolved, opts);
+  }
+  // A view pointer with no module on it. The module rides on a symbol, and
+  // symbols do not survive serialization — so this is a handle that crossed the
+  // server/client boundary as a prop, or one read out of raw JSON. Resolving it
+  // would hand back the pointer itself, which looks like content and is not, so
+  // say what happened instead.
+  if (core.isValViewSource(input)) {
+    throw Error("Cannot resolve the view of '".concat(input.view, "': it carries no module. ") + "Either it crossed a server/client boundary, which drops the module because it rides on a symbol, " + "or it points at a different module than its schema declares \u2014 which `val validate --fix` repairs. " + "Resolve it in the same component that read the module containing it, or read '".concat(input.view, "' directly."));
+  }
   function rec(sourceOrSelector, recOpts) {
+    // A view is a pointer at another module. Weaving an edit tag into it would
+    // corrupt the path it holds, and there is nothing of the target here to
+    // encode — the target is its own module, encoded when it is read.
+    //
+    // The module it names rides along on a symbol, so `useVal(page.header)` can
+    // resolve it without a path-to-module registry the app does not have. The
+    // pointer itself is unchanged: symbols do not serialize, so this is still
+    // `{ view: "/foo.val.ts" }` to anything that looks at it as data.
+    if (recOpts !== null && recOpts !== void 0 && recOpts.schema && recOpts.schema.type === "view") {
+      var valModule = viewModules.get(recOpts.schema.moduleFilePath);
+      if (valModule === undefined || !core.isValViewSource(sourceOrSelector)) {
+        return sourceOrSelector;
+      }
+      /*
+       * The POINTER decides what may be attached, not the schema alone.
+       *
+       * The two can disagree: a `.val.ts` cannot express it (the source type is
+       * the literal path), but hand-written JSON and a patch can, which is the
+       * whole reason `view:check-module` exists as a fix. Keying only on the
+       * schema attached the schema's module to a pointer naming a different one,
+       * so `useVal(page.field)` read a module the value does not name — silently,
+       * and looking exactly like a correct read.
+       *
+       * So a mismatch gets no handle: the value stays the bare pointer, and
+       * reading it throws rather than answering with the wrong module. The
+       * Studio still renders the field and still offers the repair; nothing here
+       * refuses to encode the page over it.
+       */
+      if (sourceOrSelector.view !== recOpts.schema.moduleFilePath) {
+        return sourceOrSelector;
+      }
+      return core.Internal.createViewHandle(sourceOrSelector, valModule);
+    }
     if (recOpts !== null && recOpts !== void 0 && recOpts.schema && isKeyOfSchema(recOpts === null || recOpts === void 0 ? void 0 : recOpts.schema)) {
       return sourceOrSelector;
     }
@@ -306,6 +396,25 @@ function stegaEncode(input, opts) {
       var selectorPath = core.Internal.getValPath(sourceOrSelector);
       if (selectorPath) {
         var newSchema = core.Internal.getSchema(sourceOrSelector);
+        // The modules this module's views point at. Collected HERE because this
+        // is the only place with the schema INSTANCE — everything below walks
+        // the serialized schema, which carries a path and not a module. Merged
+        // rather than replaced: a handle resolved by `useVal` re-enters here as
+        // its own module, and its parent's views must stay resolvable.
+        var _iterator = _createForOfIteratorHelper(core.Internal.viewModulesOf(newSchema)),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _step$value = slicedToArray._slicedToArray(_step.value, 2),
+              path = _step$value[0],
+              _valModule = _step$value[1];
+            viewModules.set(path, _valModule);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
         return rec(opts.getModule && opts.getModule(selectorPath) !== undefined ? opts.getModule(selectorPath) : core.Internal.getSource(sourceOrSelector), {
           path: selectorPath,
           schema: newSchema === null || newSchema === void 0 ? void 0 : newSchema["executeSerialize"]()
@@ -423,24 +532,65 @@ function collectReferencedModulesFromSchema(schema, acc) {
   } else if (schema.type === "array" || schema.type === "record") {
     collectReferencedModulesFromSchema(schema.item, acc);
   } else if (schema.type === "discriminated-union") {
-    var _iterator = _createForOfIteratorHelper(schema.items),
-      _step;
+    var _iterator2 = _createForOfIteratorHelper(schema.items),
+      _step2;
     try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var item = _step.value;
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var item = _step2.value;
         collectReferencedModulesFromSchema(item, acc);
       }
     } catch (err) {
-      _iterator.e(err);
+      _iterator2.e(err);
     } finally {
-      _iterator.f();
+      _iterator2.f();
     }
   }
 }
 function stegaClean(source) {
   return stega.vercelStegaSplit(source).cleaned;
 }
+
+/**
+ * Answers already computed, keyed by the selector they were computed from.
+ *
+ * `getModuleIds` is not cheap: it calls `executeSerialize()`, which rebuilds the
+ * whole serialized schema tree on every call — ~31us for a 40-field schema with
+ * a nested array, against ~4us for a small one. It is called from `useValStega`
+ * on every render whose `useMemo` misses.
+ *
+ * That memo misses on every render for a VIEW, and cannot be fixed there: the
+ * handle is built by `createViewHandle` inside `stegaEncode`, so `page.authors`
+ * is a fresh object each time the page is encoded, and `[selector]` is a new
+ * dependency every render. Caching here rather than in the hooks fixes it for
+ * both copies of the hook at once, and for any other caller.
+ *
+ * Keyed on the selector, which is the module itself for the case that matters —
+ * a view resolves to it on the line below, and a module is a module-level
+ * constant, so the entry is hit for the life of the process. A fresh nested
+ * selector misses, as it did before; a `WeakMap` lets those entries go.
+ *
+ * The array is shared, so it is frozen: nothing may sort or splice it in place.
+ * Every consumer today copies first (`createSubscriberId` does `paths.slice()`),
+ * and freezing is what keeps that true.
+ */
+var moduleIdsCache = new WeakMap();
 function getModuleIds(input) {
+  // A view handle names one module: the one it points at. Resolved first so a
+  // `useVal(page.header)` subscribes to the header rather than to nothing — and
+  // so the recursive call lands on the module, which is what the cache above
+  // can actually key on.
+  var resolved = core.Internal.viewHandleModule(input);
+  if (resolved !== undefined) {
+    return getModuleIds(resolved);
+  }
+  var cacheable = slicedToArray._typeof(input) === "object" && input !== null;
+  if (cacheable) {
+    var cached = moduleIdsCache.get(input);
+    if (cached) {
+      // Frozen, so handing the same array to every caller is safe.
+      return cached;
+    }
+  }
   var modules = new Set();
   function rec(sourceOrSelector) {
     if (slicedToArray._typeof(sourceOrSelector) === "object") {
@@ -484,7 +634,14 @@ function getModuleIds(input) {
     return;
   }
   rec(input);
-  return Array.from(modules);
+  var moduleIds = Array.from(modules);
+  // Frozen before it is shared, not after: a consumer that sorts in place would
+  // otherwise corrupt every later caller's answer, and silently.
+  Object.freeze(moduleIds);
+  if (cacheable) {
+    moduleIdsCache.set(input, moduleIds);
+  }
+  return moduleIds;
 }
 
 function attrs(target) {

package/internal/dist/valbuild-react-internal.browser.esm.js

@@ -1,5 +1,5 @@
 import { c as _arrayLikeToArray, b as _unsupportedIterableToArray } from '../../dist/slicedToArray-9cce0d9f.browser.esm.js';
-import { d as _objectSpread2, r as raw, c as attrs } from '../../dist/raw-57f19ada.browser.esm.js';
+import { d as _objectSpread2, r as raw, c as attrs } from '../../dist/raw-d6f65f06.browser.esm.js';
 import React from 'react';
 import { jsx } from 'react/jsx-runtime';
 import '@valbuild/core';