@valbuild/shared 0.150.18 → 0.151.0

package/internal/dist/valbuild-shared-internal.cjs.prod.js

@@ -5,11 +5,13 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var createForOfIteratorHelper = require('../../dist/createForOfIteratorHelper-9ca2078d.cjs.prod.js');
 var core = require('@valbuild/core');
 var zod = require('zod');
-var protocol = require('../../dist/protocol-b1055ef0.cjs.prod.js');
+var projectSource = require('../../dist/projectSource-ed6aec39.cjs.prod.js');
+var wrapNativeSuper = require('../../dist/wrapNativeSuper-8673414f.cjs.prod.js');
 var zodValidationError = require('zod-validation-error');
-var getSitemapTree = require('../../dist/getSitemapTree-97713490.cjs.prod.js');
+var fp = require('@valbuild/core/fp');
+var patch = require('@valbuild/core/patch');
+var getSitemapTree = require('../../dist/getSitemapTree-6b9024d1.cjs.prod.js');
 var FlexSearch = require('flexsearch');
-var wrapNativeSuper = require('../../dist/wrapNativeSuper-8673414f.cjs.prod.js');
 var utils = require('../../dist/utils-32bcaca2.cjs.prod.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
@@ -204,7 +206,7 @@ var convertToNumber = function convertToNumber(value) {
   var parsedValue = parseInt(value, 10);
   return isNaN(parsedValue) ? 0 : parsedValue;
 };
-var textEncoder = new TextEncoder();
+var textEncoder$1 = new TextEncoder();
 function convertImageNode(path, node, files, configDirectory, remoteOptions) {
   if (node.attrs && node.attrs.src.startsWith("data:")) {
     var binaryData = utils.base64DataUrlToUint8Array(node.attrs.src);
@@ -230,7 +232,7 @@ function convertImageNode(path, node, files, configDirectory, remoteOptions) {
       validationHash: core.Internal.remote.getValidationHash(remoteOptions.coreVersion, remoteOptions.schema, mimeType, {
         width: typeof node.attrs.width === "number" ? node.attrs.width : 0,
         height: typeof node.attrs.height === "number" ? node.attrs.height : 0
-      }, remoteFileHash, textEncoder),
+      }, remoteFileHash, textEncoder$1),
       filePath: filePath.slice(1)
     })) : filePath;
     if (existingFilesEntry) {
@@ -748,62 +750,9 @@ var VAL_STATE_COOKIE = core.Internal.VAL_STATE_COOKIE;
 var VAL_ENABLE_COOKIE_NAME = core.Internal.VAL_ENABLE_COOKIE_NAME;
 
 /**
- * One value, computed once per REQUEST.
- *
- * `fetchVal` in draft mode reads the whole module tree out of `/sources/~`, and
- * a page that calls it three times used to ask three times — the answer being
- * byte-identical each time, because the query and the session are fixed for the
- * length of a request. This is what makes the second and third call free.
- *
- * ## Why the scope is the REQUEST
- *
- * The memoised response is a DRAFT -- unpublished work, read with the caller's
- * session cookie. Every caller allowed to read drafts gets the same draft (patch
- * groups, which made it per author, are gone), but whether a caller is allowed
- * at all is decided per session. A memo that outlived the request would hand
- * the draft to the next visitor without asking, and it would be invisible: the
- * page would simply render somebody's half-finished sentence. Sharing it across
- * requests is possible now, keyed on the chain's head, and would be its own
- * measured change.
- *
- * So this module holds NO state of its own. The caller supplies the box, and
- * the box has to come from something the framework already scopes to the
- * request — React's `cache()` in an RSC, a `WeakMap` keyed on the `Request` in
- * TanStack Start. `null` means "no request scope available", and that is not an
- * error: it falls back to computing every time, which is what the code did
- * before this existed. Ineffective is a safe failure here; leaking is not.
- *
- * The `key` is the second half of that guarantee. It carries whatever the
- * answer depends on — the session — so a box that somehow outlived its request,
- * or is shared by two sessions, MISSES rather than serving the wrong draft.
- *
- * ## The promise is cached, not the value
- *
- * React renders siblings concurrently, so three `fetchVal` calls in one page
- * are usually in flight at the same time rather than one after another.
- * Caching the resolved value would dedupe none of them; caching the promise
- * dedupes both orderings.
- */
-
-/**
- * Returns the memoised promise for `key`, computing it only on a miss.
- *
- * A rejection is memoised along with everything else, on purpose: one failed
- * read per request is the same answer for every caller in it, and retrying it
- * two more times only makes a broken draft slower to render.
+ * Nothing moved since the ETag the caller sent back: no body, as HTTP
+ * requires of a 304.
  */
-function memoizePerRequest(box, key, compute) {
-  if (box === null) {
-    return compute();
-  }
-  if (box.promise !== undefined && box.key === key) {
-    return box.promise;
-  }
-  var promise = compute();
-  box.key = key;
-  box.promise = promise;
-  return promise;
-}
 
 /**
  * JSON, recursively — the shape of a Source over the wire.
@@ -1054,7 +1003,7 @@ var readLegacyDirectoryAsDir = function readLegacyDirectoryAsDir(value) {
   }
   var _ref = value,
     directory = _ref.directory,
-    rest = protocol._objectWithoutProperties(_ref, _excluded);
+    rest = projectSource._objectWithoutProperties(_ref, _excluded);
   return createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, rest), {}, {
     dir: directory
   });
@@ -1309,6 +1258,228 @@ var ValDeployment = zod.z.object({
   commitMessage: zod.z.string().nullable().optional()
 });
 
+var _Internal$VERSION$cor;
+
+/**
+ * What a module's content IS: the schema it is read and patched with, the
+ * base it starts from, and the chain of patches on top. Three parts because
+ * each kind of change moves exactly one of them (see
+ * `docs/plans/one-content-model.md`, "A version, per module, with the code in
+ * it"):
+ *
+ * - a schema change, or a new engine (`@valbuild/*` upgraded), moves `schema`;
+ * - a publish, a content version, a literal edited in code, moves `base`;
+ * - an edit, a discard, a publish (which empties the chain) moves `chain`.
+ *
+ * Two answers with the same version are the same content, wherever they came
+ * from. That is the whole point: comparing contents becomes comparing three
+ * strings.
+ *
+ * Computed when content CHANGES -- a module evaluated, a base adopted, a patch
+ * appended -- never when it is read (risk 3 in the plan): every function here
+ * that hashes counts itself ({@link versionHashCount}), so a reader that
+ * hashes is caught by a counted budget rather than by a profile.
+ */
+
+/**
+ * What a project answer is relative to: which build served it, and how far
+ * along the project's changes it is.
+ */
+
+/**
+ * What the schema version of a module staged after the build serving a
+ * proposal starts with: `staged:<inputs>`. Val's server has not got that
+ * module's schema, so it names the staging instead; a Studio compares no
+ * build's code against it.
+ */
+var STAGED_SCHEMA_PREFIX = "staged:";
+
+/** The chain of no patches. */
+var EMPTY_CHAIN = "";
+
+/**
+ * The engine: how patches are applied and content is read. Part of every
+ * schema version, because content read by another engine is not the same
+ * content even under the same schema.
+ */
+var ENGINE = "@valbuild/core@".concat((_Internal$VERSION$cor = core.Internal.VERSION.core) !== null && _Internal$VERSION$cor !== void 0 ? _Internal$VERSION$cor : "unknown");
+var hashes = 0;
+var textEncoder;
+function sha256Hex(input) {
+  hashes++;
+  textEncoder !== null && textEncoder !== void 0 ? textEncoder : textEncoder = new TextEncoder();
+  return core.Internal.getSHA256Hash(textEncoder.encode(input));
+}
+
+/**
+ * How many times a version has been hashed in this process: the counted
+ * budget behind "versions are computed when content changes, never when it
+ * is read" (`version:hash`). A test takes it before and after a read.
+ */
+function versionHashCount() {
+  return hashes;
+}
+
+/** A chain one patch longer. */
+function extendChain(prev, id) {
+  return sha256Hex("".concat(prev, "\n").concat(id));
+}
+
+/** The chain of these patch ids, in order, on top of a base. */
+function chainOf(ids) {
+  var chain = EMPTY_CHAIN;
+  var _iterator = createForOfIteratorHelper._createForOfIteratorHelper(ids),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var id = _step.value;
+      chain = extendChain(chain, id);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return chain;
+}
+
+/**
+ * A module's schema version, from its serialized schema. The same function
+ * on the server (from what `extractValModules` serialized) and in the Studio
+ * (from what it holds in `SchemaStore`), so the two compare.
+ */
+function schemaVersionOf(serializedSchema) {
+  return sha256Hex("".concat(ENGINE, "\n").concat(JSON.stringify(serializedSchema)));
+}
+
+/**
+ * A module's base version, from its base source: what the module evaluates
+ * to, or what a content version or a publish put in its place. `.jsonValues()`
+ * entries are markers here; an entry's own version comes with entries stored
+ * as modules of their own (phase 6).
+ */
+function baseVersionOf(source) {
+  var _JSON$stringify;
+  return sha256Hex((_JSON$stringify = JSON.stringify(source)) !== null && _JSON$stringify !== void 0 ? _JSON$stringify : "undefined");
+}
+
+/** The address of a module's content. Never changes meaning. */
+function moduleKey(path, v) {
+  return "".concat(path, "@").concat(v.schema, ".").concat(v.base, ".").concat(v.chain);
+}
+
+/** Whether two versions name the same content. */
+function sameModuleVersion(a, b) {
+  return a.schema === b.schema && a.base === b.base && a.chain === b.chain;
+}
+
+/**
+ * The chains of every module, from the patches a draft applies (in chain
+ * order), folded incrementally.
+ *
+ * A read asks for the chains every time; the fold is extended only by the
+ * patches the chain has gained since the last call, and a call that finds the
+ * chain as it was hashes nothing. A chain that changed anywhere but at its end
+ * (a discard in the middle, a publish) is folded again from the start --
+ * once, when that is first noticed.
+ */
+var ChainFold = /*#__PURE__*/function () {
+  function ChainFold() {
+    wrapNativeSuper._classCallCheck(this, ChainFold);
+    createForOfIteratorHelper._defineProperty(this, "ids", []);
+    createForOfIteratorHelper._defineProperty(this, "paths", []);
+    createForOfIteratorHelper._defineProperty(this, "chains", new Map());
+    /**
+     * Every module's chain after each of its patches, in order: what
+     * {@link chainAt} answers for a module whose content stopped part way
+     * along its chain (a patch that does not apply). Kept as the chains are
+     * extended, so asking hashes nothing.
+     */
+    createForOfIteratorHelper._defineProperty(this, "prefixes", new Map());
+    /**
+     * Bumped whenever the chains move: a cheap identity for "the same chains as
+     * before", in-process. With {@link instance} in front, two folds never name
+     * one epoch: two processes (or isolates) holding the same chains answer
+     * differently, which only costs a cache a miss, where two holding
+     * DIFFERENT chains at the same count must never answer alike (an ETag
+     * answered 304 for content the caller does not have).
+     */
+    createForOfIteratorHelper._defineProperty(this, "epochValue", 0);
+    createForOfIteratorHelper._defineProperty(this, "instance", Math.random().toString(36).slice(2, 10));
+  }
+  return wrapNativeSuper._createClass(ChainFold, [{
+    key: "chainsOf",
+    value: /** Every module's chain, for these patches. Modules with none are absent. */
+    function chainsOf(patches) {
+      var known = this.ids.length;
+      var extends_ = patches.length >= known;
+      for (var i = 0; extends_ && i < known; i++) {
+        var patch = patches[i];
+        extends_ = patch !== undefined && patch.patchId === this.ids[i] && patch.path === this.paths[i];
+      }
+      if (extends_ && patches.length === known) {
+        return this.chains;
+      }
+      var chains = extends_ ? new Map(this.chains) : new Map();
+      var from = extends_ ? known : 0;
+      if (!extends_) {
+        this.ids = [];
+        this.paths = [];
+        this.prefixes = new Map();
+      }
+      for (var _i = from; _i < patches.length; _i++) {
+        var _chains$get;
+        var _patch = patches[_i];
+        if (_patch === undefined) continue;
+        var chain = extendChain((_chains$get = chains.get(_patch.path)) !== null && _chains$get !== void 0 ? _chains$get : EMPTY_CHAIN, _patch.patchId);
+        chains.set(_patch.path, chain);
+        var prefixes = this.prefixes.get(_patch.path);
+        if (prefixes === undefined) this.prefixes.set(_patch.path, [chain]);else prefixes.push(chain);
+        this.ids.push(_patch.patchId);
+        this.paths.push(_patch.path);
+      }
+      this.chains = chains;
+      this.epochValue++;
+      return chains;
+    }
+
+    /**
+     * A module's chain after its first `count` patches, of those the last
+     * {@link chainsOf} was given: the version of content that stopped at a
+     * patch that does not apply, so the version names the chain the content
+     * is AT. Hashes nothing.
+     */
+  }, {
+    key: "chainAt",
+    value: function chainAt(path, count) {
+      var _this$prefixes$get, _ref, _prefixes;
+      if (count <= 0) return EMPTY_CHAIN;
+      var prefixes = (_this$prefixes$get = this.prefixes.get(path)) !== null && _this$prefixes$get !== void 0 ? _this$prefixes$get : [];
+      return (_ref = (_prefixes = prefixes[Math.min(count, prefixes.length) - 1]) !== null && _prefixes !== void 0 ? _prefixes : this.chains.get(path)) !== null && _ref !== void 0 ? _ref : EMPTY_CHAIN;
+    }
+
+    /** See {@link epochValue}. */
+  }, {
+    key: "epoch",
+    value: function epoch() {
+      return "".concat(this.instance, "-").concat(this.epochValue);
+    }
+  }]);
+}();
+
+/** {@link ModuleVersion} on the wire. */
+var ModuleVersionSchema = zod.z.object({
+  schema: zod.z.string(),
+  base: zod.z.string(),
+  chain: zod.z.string()
+});
+
+/** {@link ProjectVersion} on the wire. */
+var ProjectVersionSchema = zod.z.object({
+  build: zod.z.string(),
+  seq: zod.z.number()
+});
+
 /**
  * The wire shapes for reading history.
  *
@@ -1430,6 +1601,10 @@ var ModuleComparison = zod.z.object({
   verdict: RestoreVerdict
 });
 
+/** An `EntryVersion` on the wire. */
+var EntryVersionSchema = ModuleVersionSchema.extend({
+  key: zod.z.string()
+});
 var ModuleFilePath = zod.z.string().refine(function (_path) {
   return true;
 } // TODO: validation
@@ -2052,11 +2227,112 @@ var Api = {
       })])
     }
   },
+  /**
+   * What each module IS, right now: its version (`schema`, `base`, `chain`),
+   * and the project version that is relative to. What `/stat` answers, per
+   * module; see `docs/plans/one-content-model.md`, "The Studio loads
+   * everything from one place".
+   *
+   * It has its own ETag, so a client that sends it back (`If-None-Match`)
+   * gets a 304 and no body while nothing has moved. Computed from versions
+   * kept as content changes: answering it hashes nothing.
+   *
+   * "Since `seq` N" (`?since=N`, with the ETag of the manifest the client
+   * holds, which was answered at `seq` N, as `If-None-Match`): the modules
+   * whose version moved since that manifest, and no others, with `since: N`
+   * on the answer to say it is a delta. The ETag is in the body too (`tag`),
+   * for a client that reads answers through `ValClient`, which hands over
+   * the body and not the headers. Answered whole -- no `since` -- when the server no
+   * longer holds the manifest that ETag names (another process, another
+   * build, too long ago), and by a server of the release before, which
+   * ignores the parameter. Optional both ways.
+   */
+  "/manifest": {
+    GET: {
+      req: {
+        cookies: {
+          val_session: zod.z.string().optional()
+        },
+        headers: {
+          "if-none-match": zod.z.string().optional()
+        },
+        query: {
+          since: onlyOneStringQueryParam.optional()
+        }
+      },
+      res: zod.z.union([unauthorizedResponse, zod.z.object({
+        status: zod.z.literal(500),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(200),
+        json: zod.z.object({
+          project: ProjectVersionSchema,
+          modules: zod.z.record(ModuleFilePath, ModuleVersionSchema),
+          /** This answer's ETag, as the header has it. */
+          tag: zod.z.string().optional(),
+          /**
+           * Present on a delta only: the `seq` of the manifest it is
+           * relative to, whose modules that are not named here did not
+           * move. Absent: every module is named.
+           */
+          since: zod.z.number().optional(),
+          /**
+           * The build that answered is a previous build still answering
+           * (http mode: the content service counted a newer one live).
+           * Its versions are right for its own bases, which the site does
+           * not serve any more: a Studio does not move to them, and asks
+           * again. Optional: absent from a live build and a server of the
+           * release before.
+           */
+          superseded: zod.z["boolean"]().optional(),
+          /**
+           * The answering build's `val.modules` registry, as an entry a
+           * Studio can import (`valModulesEntryPath`), and the Val it
+           * runs: where a Studio opened on another build takes this
+           * build's code in without reloading the page. Only a build the
+           * platform made and names (`publishBuild`) has one. Optional
+           * both ways: absent from any other server (local development,
+           * where HMR brings the code; a self-hosted deploy) and from a
+           * server of the release before, and ignored by a Studio of the
+           * release before.
+           */
+          registry: zod.z.object({
+            entry: zod.z.string(),
+            core: zod.z.string()
+          }).optional()
+        })
+      }),
+      /*
+       * Nothing moved since the ETag the client sent. No body on the wire;
+       * the client reads it as `json: null`.
+       */
+      zod.z.object({
+        status: zod.z.literal(304),
+        json: zod.z["null"]().optional()
+      })])
+    }
+  },
   "/stat": {
     POST: {
       req: {
         body: zod.z.object({
+          /**
+           * @deprecated Echoed by the Studio, and compared by the fs and
+           * memory long poll to see that another build answers. This
+           * release's Studio reads each module's version from
+           * `GET /manifest`; goes once the long poll compares the echoed
+           * version instead (see "Release-delayed deletions" in
+           * `docs/plans/one-content-model.md`).
+           */
           sourcesSha: zod.z.string(),
+          /**
+           * @deprecated Echoed by the Studio, and compared by the fs and
+           * memory long poll to see that another build answers. This
+           * release's Studio reads each module's version from
+           * `GET /manifest`; goes once the long poll compares the echoed
+           * version instead (see "Release-delayed deletions" in
+           * `docs/plans/one-content-model.md`).
+           */
           schemaSha: zod.z.string(),
           baseSha: zod.z.string(),
           patches: zod.z.array(zod.z.string()).optional(),
@@ -2086,7 +2362,21 @@ var Api = {
         json: zod.z.union([zod.z.object({
           type: zod.z.union([zod.z.literal("request-again"), zod.z.literal("no-change"), zod.z.literal("did-change")]),
           baseSha: zod.z.string(),
+          /**
+           * @deprecated Read by a Studio of the release before
+           * (`BaseAlignment`, `SchemaFreshnessWatch`); this release's
+           * only echoes it, and reads each module's version from
+           * `GET /manifest`. Goes in two steps (see "Release-delayed
+           * deletions" in `docs/plans/one-content-model.md`).
+           */
           schemaSha: zod.z.string(),
+          /**
+           * @deprecated Read by a Studio of the release before
+           * (`BaseAlignment`, `SchemaFreshnessWatch`); this release's
+           * only echoes it, and reads each module's version from
+           * `GET /manifest`. Goes in two steps (see "Release-delayed
+           * deletions" in `docs/plans/one-content-model.md`).
+           */
           sourcesSha: zod.z.string(),
           patches: zod.z.array(PatchId),
           /**
@@ -2184,13 +2474,34 @@ var Api = {
            * the git mirror's or the one content reports for the project.
            * Absent where there is no history to show.
            */
-          historyBranch: zod.z.string().optional()
+          historyBranch: zod.z.string().optional(),
+          /**
+           * What this answer is relative to: the build that served it
+           * and how far along the project's changes it is (`seq`). Of two
+           * answers, the higher `seq` is the newer. Optional: a server
+           * that predates versions sends none.
+           */
+          version: ProjectVersionSchema.optional()
         }), zod.z.object({
           type: zod.z.literal("use-websocket"),
           url: zod.z.string(),
           nonce: zod.z.string(),
           baseSha: zod.z.string(),
+          /**
+           * @deprecated Read by a Studio of the release before
+           * (`BaseAlignment`, `SchemaFreshnessWatch`); this release's
+           * only echoes it, and reads each module's version from
+           * `GET /manifest`. Goes in two steps (see "Release-delayed
+           * deletions" in `docs/plans/one-content-model.md`).
+           */
           schemaSha: zod.z.string(),
+          /**
+           * @deprecated Read by a Studio of the release before
+           * (`BaseAlignment`, `SchemaFreshnessWatch`); this release's
+           * only echoes it, and reads each module's version from
+           * `GET /manifest`. Goes in two steps (see "Release-delayed
+           * deletions" in `docs/plans/one-content-model.md`).
+           */
           sourcesSha: zod.z.string(),
           /**
            * The commit this deployment was built from.
@@ -2312,7 +2623,14 @@ var Api = {
            * the git mirror's or the one content reports for the project.
            * Absent where there is no history to show.
            */
-          historyBranch: zod.z.string().optional()
+          historyBranch: zod.z.string().optional(),
+          /**
+           * What this answer is relative to: the build that served it
+           * and how far along the project's changes it is (`seq`). Of two
+           * answers, the higher `seq` is the newer. Optional: a server
+           * that predates versions sends none.
+           */
+          version: ProjectVersionSchema.optional()
         })])
       })])
     }
@@ -2354,6 +2672,14 @@ var Api = {
         path: zod.z.string().optional(),
         cookies: {
           val_session: zod.z.string().optional()
+        },
+        /*
+         * Carried to content, which answers 304 when it names the answer
+         * (`/project-source` does: valbuild/home sends its `ETag`). The
+         * `ETag` comes back as a header, and a 304 with no body.
+         */
+        headers: {
+          "if-none-match": zod.z.string().optional()
         }
       },
       /*
@@ -2365,10 +2691,18 @@ var Api = {
        * `{ message }` rather than throwing, because a publish failing is
        * something the editor has to be told about in words.
        */
-      res: zod.z.object({
+      res: zod.z.union([zod.z.object({
         status: zod.z.number(),
         json: zod.z.unknown()
-      })
+      }),
+      /*
+       * Content said the caller holds the answer already (`If-None-Match`).
+       * No body on the wire: a 304 cannot carry one.
+       */
+      zod.z.object({
+        status: zod.z.literal(304),
+        json: zod.z["null"]().optional()
+      })])
     },
     POST: {
       req: {
@@ -2804,7 +3138,9 @@ var Api = {
           })),
           baseSha: zod.z.string(),
           error: GenericError.optional(),
-          errors: zod.z.record(PatchId, GenericError).optional()
+          errors: zod.z.record(PatchId, GenericError).optional(),
+          /** The project version these patches were read at. See `/stat`. */
+          version: ProjectVersionSchema.optional()
         })
       })])
     }
@@ -2837,6 +3173,15 @@ var Api = {
       })])
     }
   },
+  /**
+   * @deprecated The whole tree. Nothing of this release asks it: the Studio
+   * reads modules by version (`GET /manifest`, `GET /modules/~`), the draft
+   * readers and MCP read the head in-process. Kept, with `exclude_patches`
+   * (`BaseAlignment`'s fetch) and the ignored `validate_sources` and
+   * `validate_binary_files`, for a Studio of the release before; goes in the
+   * release after the one that ships this (see "Release-delayed deletions"
+   * in `docs/plans/one-content-model.md`).
+   */
   "/sources/~": {
     PUT: {
       req: {
@@ -2888,12 +3233,100 @@ var Api = {
               skipped: zod.z.array(PatchId).optional(),
               errors: zod.z.record(PatchId, GenericError).optional()
             }).optional(),
-            validationErrors: zod.z.record(zod.z.string(), zod.z.array(ValidationError)).optional()
-          }))
+            validationErrors: zod.z.record(zod.z.string(), zod.z.array(ValidationError)).optional(),
+            /**
+             * The version of `source` as answered: with the chain the
+             * server applied, or the empty chain when it applied none
+             * (`apply_patches=false`). Optional: an older server sends
+             * none.
+             */
+            version: ModuleVersionSchema.optional()
+          })),
+          /** The project version this tree was read at. See `/stat`. */
+          project: ProjectVersionSchema.optional()
         })
       })])
     }
   },
+  /**
+   * One module by version: phase 6 of `docs/plans/one-content-model.md`
+   * ("The Studio loads everything from one place"). `GET /modules/~<path>`,
+   * with `v` the version wanted as its `moduleKey` (the newest when absent;
+   * a base is a version with the empty chain) and `have` the version the
+   * caller holds: when the caller's chain is a start of the answer's under
+   * the same schema and base, the answer is the patches from it (`delta`),
+   * otherwise the whole module. An answer for an asked `v` is immutable.
+   */
+  "/modules/~": {
+    GET: {
+      req: {
+        path: zod.z.string(),
+        query: {
+          v: onlyOneStringQueryParam.optional(),
+          have: onlyOneStringQueryParam.optional()
+        },
+        cookies: {
+          val_session: zod.z.string().optional()
+        }
+      },
+      res: zod.z.union([unauthorizedResponse, zod.z.object({
+        status: zod.z.literal(404),
+        json: zod.z.object({
+          message: zod.z.string(),
+          /** The version held now, when the one asked for is not. */
+          current: ModuleVersionSchema.optional()
+        })
+      }), zod.z.object({
+        status: zod.z.literal(500),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(200),
+        headers: zod.z.object({
+          "Cache-Control": zod.z.string()
+        }).optional(),
+        json: zod.z.union([zod.z.object({
+          kind: zod.z.literal("module"),
+          version: ModuleVersionSchema,
+          source: zod.z.any(),
+          /**
+           * The `.jsonValues()` entries the module's chain touched, read,
+           * each with its own version. Every other entry is the base's,
+           * behind its marker in `source`.
+           */
+          entries: zod.z.record(zod.z.string(), zod.z.union([zod.z.object({
+            content: zod.z.any(),
+            version: EntryVersionSchema
+          }), zod.z.object({
+            deleted: zod.z.literal(true),
+            version: EntryVersionSchema
+          }), zod.z.object({
+            error: zod.z.string(),
+            /** The patch that made it unreadable, when known. */
+            patchId: PatchId.optional(),
+            version: EntryVersionSchema
+          })])),
+          /**
+           * The patch ids its chain is made of, in chain order: what a
+           * client holding this knows the server already has. Optional:
+           * a server of the release before sends none.
+           */
+          patches: zod.z.array(PatchId).optional(),
+          failed: zod.z.object({
+            patchId: PatchId,
+            message: zod.z.string()
+          }).optional()
+        }), zod.z.object({
+          kind: zod.z.literal("delta"),
+          from: ModuleVersionSchema,
+          to: ModuleVersionSchema,
+          patches: zod.z.array(zod.z.object({
+            patchId: PatchId,
+            patch: Patch
+          }))
+        })])
+      })])
+    }
+  },
   /**
    * The Studio's full check, one module per request: its sources against its
    * schema and its local files against their bytes, on the content the caller
@@ -3614,7 +4047,14 @@ var Api = {
           path: ModuleFilePath,
           key: zod.z.string(),
           // The entry's JSON content (or null if the entry has no value).
-          content: zod.z.any()
+          content: zod.z.any(),
+          /**
+           * The version of the record module the entry was read from, with
+           * the chain that was applied (the empty chain without
+           * `apply_patches`). An entry's own version comes with entries
+           * stored as modules of their own.
+           */
+          version: ModuleVersionSchema.optional()
         })
       }),
       // Shapes (2) and (3): `keys` or `offset`+`limit`.
@@ -3637,7 +4077,9 @@ var Api = {
           // All-mode only: the resolved window and the record's total key count.
           offset: zod.z.number().optional(),
           limit: zod.z.number().optional(),
-          total: zod.z.number().optional()
+          total: zod.z.number().optional(),
+          /** As for a single `key`. */
+          version: ModuleVersionSchema.optional()
         })
       }), zod.z.object({
         status: zod.z.literal(400),
@@ -4100,8 +4542,8 @@ var createValClient = function createValClient(host, config, options) {
               body: anyReq.body !== undefined ? JSON.stringify(anyReq.body) : undefined
             }).then(/*#__PURE__*/function () {
               var _ref2 = createForOfIteratorHelper._asyncToGenerator(/*#__PURE__*/createForOfIteratorHelper._regenerator().m(function _callee(res) {
-                var _apiEndpoint$res;
-                var contentTypeHeaders, json, valClientResult, message, responseResult;
+                var _apiEndpoint$res2;
+                var contentTypeHeaders, _apiEndpoint$res, notModified, json, valClientResult, message, responseResult;
                 return createForOfIteratorHelper._regenerator().w(function (_context) {
                   while (1) switch (_context.n) {
                     case 0:
@@ -4119,10 +4561,38 @@ var createValClient = function createValClient(host, config, options) {
                         }
                       });
                     case 1:
-                      if (contentTypeHeaders !== null && contentTypeHeaders !== void 0 && contentTypeHeaders.includes("application/json")) {
+                      if (!(res.status === 304)) {
+                        _context.n = 3;
+                        break;
+                      }
+                      notModified = {
+                        status: 304,
+                        json: null
+                      };
+                      if (!(((_apiEndpoint$res = apiEndpoint.res) === null || _apiEndpoint$res === void 0 ? void 0 : _apiEndpoint$res.safeParse(notModified).success) === false)) {
                         _context.n = 2;
                         break;
                       }
+                      return _context.a(2, {
+                        status: null,
+                        json: {
+                          type: "client_side_validation_error",
+                          message: "Invalid response (304 from a route that does not answer one). This could be a result of mismatched Val versions.",
+                          details: {
+                            validationError: "Unexpected 304",
+                            data: {
+                              status: res.status
+                            }
+                          }
+                        }
+                      });
+                    case 2:
+                      return _context.a(2, notModified);
+                    case 3:
+                      if (contentTypeHeaders !== null && contentTypeHeaders !== void 0 && contentTypeHeaders.includes("application/json")) {
+                        _context.n = 4;
+                        break;
+                      }
                       return _context.a(2, {
                         status: null,
                         json: {
@@ -4137,17 +4607,17 @@ var createValClient = function createValClient(host, config, options) {
                           }
                         }
                       });
-                    case 2:
-                      _context.n = 3;
+                    case 4:
+                      _context.n = 5;
                       return res.json();
-                    case 3:
+                    case 5:
                       json = _context.v;
                       valClientResult = {
                         status: res.status,
                         json: json
                       };
                       if (!(res.status === 500)) {
-                        _context.n = 4;
+                        _context.n = 6;
                         break;
                       }
                       core.Internal.log.error("Server responded with an error", json);
@@ -4159,10 +4629,10 @@ var createValClient = function createValClient(host, config, options) {
                           message: message
                         }
                       });
-                    case 4:
-                      responseResult = (_apiEndpoint$res = apiEndpoint.res) === null || _apiEndpoint$res === void 0 ? void 0 : _apiEndpoint$res.safeParse(valClientResult);
+                    case 6:
+                      responseResult = (_apiEndpoint$res2 = apiEndpoint.res) === null || _apiEndpoint$res2 === void 0 ? void 0 : _apiEndpoint$res2.safeParse(valClientResult);
                       if (!(responseResult && !responseResult.success)) {
-                        _context.n = 5;
+                        _context.n = 7;
                         break;
                       }
                       return _context.a(2, {
@@ -4176,7 +4646,7 @@ var createValClient = function createValClient(host, config, options) {
                           }
                         }
                       });
-                    case 5:
+                    case 7:
                       return _context.a(2, {
                         status: res.status,
                         json: json
@@ -4320,6 +4790,44 @@ var urlOf = function urlOf() {
   return "".concat(route);
 };
 
+/**
+ * Which Val package, at which version, sent a request to Val Build.
+ *
+ * Sent on every request a Val package makes to Val's own services from a
+ * server or a CLI -- the content host, `/api/login`, the analytics ingest --
+ * so Val Build can tell which versions are still out there and which old
+ * endpoints they still call. Without it an endpoint can never be retired with
+ * any confidence: a request from a site nobody has upgraded in a year looks
+ * exactly like one from yesterday's release.
+ *
+ * The value is a product token, `@valbuild/server@0.152.0`: the package whose
+ * code built the request, because that is what decides which endpoints are
+ * called. Not the framework binding or the app: those do not choose URLs.
+ *
+ * NOT sent from the browser. A custom header on a cross-origin request makes
+ * the browser send a CORS preflight, and a host that does not list the header
+ * in `Access-Control-Allow-Headers` refuses the request outright -- so adding
+ * it there is a change to every such host first.
+ *
+ * It identifies the code, not the caller: anyone can send any value, so it is
+ * for counting, never for deciding what a request may do.
+ */
+var VAL_CLIENT_HEADER = "x-val-client";
+
+/** Packages that send {@link VAL_CLIENT_HEADER}. */
+
+/**
+ * `{ "x-val-client": "@valbuild/server@0.152.0" }`, to spread into a
+ * request's headers.
+ *
+ * A version that could not be read is sent as `unknown` rather than leaving
+ * the header out: "a server too broken to know its version" is still a thing
+ * worth counting, and it is not the same as "a version older than the header".
+ */
+function valClientHeaders(pkg, version) {
+  return createForOfIteratorHelper._defineProperty({}, VAL_CLIENT_HEADER, "".concat(pkg, "@").concat(version || "unknown"));
+}
+
 /**
  * Can this value, taken from one schema, be written into another?
  *
@@ -4753,23 +5261,1517 @@ function chainHeadOf(reportedHead, listed) {
   return (_listed = listed[listed.length - 1]) !== null && _listed !== void 0 ? _listed : null;
 }
 
-var SharedValConfig = zod.z.object({
-  contentHostUrl: zod.z.string().optional(),
-  appHostUrl: zod.z.string().optional(),
-  project: zod.z.string().optional(),
-  root: zod.z.string().optional(),
-  gitCommit: zod.z.string().optional(),
-  gitBranch: zod.z.string().optional(),
-  defaultTheme: zod.z["enum"](["dark", "light"]).optional(),
-  ai: zod.z.object({
-    commitMessages: zod.z.object({
-      disabled: zod.z["boolean"]().optional()
-    }).optional()
-  }).optional()
-});
-
 /**
- * Config that is shared between the client and server.
+ * Where a build's `val.modules` registry can be imported from: phase 9 of
+ * `docs/plans/one-content-model.md`, "Reloading the schema while the Studio
+ * runs".
+ *
+ * A build made by `@valbuild/tanstack-build` (every build the platform
+ * serves) emits its `val.modules` as an ES module of its own beside its
+ * client chunks, named after the build: `/_app/val-modules-<build>.js`,
+ * whose default export is the registry. The server running that build knows
+ * its name (`VAL_BUILD`, Val's `publishBuild`) and names the entry on
+ * `GET /manifest` (`registry`), so a Studio opened on an older build imports
+ * the new one's code and reloads it in place (`HostStore.reloadCode`)
+ * instead of being told to reload the page.
+ *
+ * The convention is the builder's and this file's together: the builder
+ * writes the file (`valModulesEntryFile` in `@valbuild/tanstack-build`, which
+ * does not depend on this package), and each side pins the same literal,
+ * `val-modules-<build>.js` (`buildRegistry.test.ts` here, `valModules.test.ts`
+ * there).
+ */
+
+/** The file a build's registry is emitted as, among its client chunks. */
+function valModulesEntryFile(build) {
+  return "val-modules-".concat(build, ".js");
+}
+
+/** Where a build served by the platform serves its registry. */
+function valModulesEntryPath(build) {
+  return "/_app/".concat(valModulesEntryFile(build));
+}
+
+/**
+ * What `GET /manifest` says about the code of the build that answered:
+ * where its registry is, and which Val it runs. A Studio running another
+ * Val cannot take the build's code in (its own stores would run against a
+ * new core), so it reloads itself instead (`other-val-version`).
+ */
+
+/*
+ * How a patch op relates to a `.jsonValues()` record: which ops reach into an
+ * entry, what a write of the whole record says about each entry, and how an
+ * op inside an entry is rebased onto the entry's own file.
+ *
+ * Here, in shared, because the engine (`applyChain.ts`) is built on them and
+ * runs wherever content is patched; the commit flow (`ValOps.prepare`), the
+ * CLI's fixes and the language server use the same functions, through
+ * `@valbuild/server`, which re-exports them. One rule, one implementation:
+ * a draft that shows one thing while publishing writes another is the failure
+ * nobody sees until it is published.
+ */
+
+/**
+ * Classification of a single patch op against a module's serialized schema,
+ * used by the commit flow to route ops for `.jsonValues()` records:
+ *
+ * - `normal`: the op does not descend into a `.jsonValues()` entry; apply it to
+ *   the `.val.ts` as usual.
+ * - `entry`: the op targets a `.jsonValues()` entry. `recordPath` is the path to
+ *   the record within the module source (empty for a root record/router),
+ *   `entryKey` is the entry key, and `subPath` is the remaining path inside the
+ *   entry (empty when the op targets the entry value itself, e.g. add/remove of
+ *   the whole entry).
+ */
+
+/**
+ * Walks the serialized schema following the op path. When a `.jsonValues()`
+ * record is encountered, the next path segment is the entry key and everything
+ * after it lives inside the entry's `*.val.json` (so it does not touch the
+ * `.val.ts`). Returns `{ kind: "normal" }` when the op never enters a
+ * `.jsonValues()` record.
+ */
+function classifyJsonValuesOp(schema, opPath) {
+  var current = schema;
+  var recordPath = [];
+  for (var i = 0; i < opPath.length; i++) {
+    if (!current) {
+      return {
+        kind: "normal"
+      };
+    }
+    if (current.type === "record" && current.jsonValues) {
+      return {
+        kind: "entry",
+        recordPath: recordPath.slice(),
+        entryKey: opPath[i],
+        subPath: opPath.slice(i + 1)
+      };
+    }
+    var seg = opPath[i];
+    current = descend(current, seg);
+    recordPath.push(seg);
+  }
+  return {
+    kind: "normal"
+  };
+}
+function descend(schema, key) {
+  switch (schema.type) {
+    case "object":
+      return schema.items[key];
+    case "record":
+      return schema.item;
+    case "array":
+      return schema.item;
+    default:
+      // Unions / primitives / leaf schemas: we cannot (or need not) descend
+      // further to find a jsonValues record. Anything below is a normal
+      // `.val.ts` edit.
+      return undefined;
+  }
+}
+
+/**
+ * Is this op a write of the WHOLE record at the root of a `.jsonValues()`
+ * module?
+ *
+ * The one op {@link classifyJsonValuesOp} cannot classify: it finds the entry
+ * key by walking the op path, and the root path has no segments to walk, so a
+ * root write reads as `normal` and gets applied to the `.val.ts` - writing
+ * markers over the `c.json(() => import(...))` calls that make the entries load
+ * at all. {@link expandJsonValuesRootOp} turns it into ops that DO name a key,
+ * which everything downstream already handles.
+ *
+ * `add` counts as well as `replace`: at the root both mean "the document is now
+ * this" (see `JSONOps`), so both have to be expanded or the unexpanded one is
+ * the same bug again.
+ *
+ * The value has to BE a record, and that is part of the question rather than a
+ * check inside the expansion: a `.jsonValues()` record can be nullable, and
+ * `null` at the root means the module no longer has a record at all - there are
+ * no entries to write, and it is an ordinary `.val.ts` write, exactly as it was
+ * before any of this existed. Same for any other non-record value: not a
+ * whole-record write, so not this conversion's to route.
+ */
+function isJsonValuesRootOp(schema, op) {
+  return (op.op === "replace" || op.op === "add") && op.path.length === 0 && isJsonValuesRecord(op.value) && schema.type === "record" && schema.jsonValues === true;
+}
+function isJsonValuesRecord(value) {
+  return createForOfIteratorHelper._typeof(value) === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * One entry as it stands right now, for {@link expandJsonValuesRootOp} to
+ * expand against.
+ *
+ * The key set decides add-vs-replace-vs-remove. The content, where the caller
+ * has it, decides whether an op is emitted at all: an entry whose content is
+ * already what the root write says is left alone rather than rewritten, so
+ * putting a module back does not touch every `*.val.json` it did not change.
+ * `undefined` means "this entry exists, content unknown" - which is what the
+ * Studio's draft source has, because the source holds markers - and yields a
+ * `replace`, the safe answer.
+ */
+
+/**
+ * Fans a whole-record write at a `.jsonValues()` module's root out into ops
+ * that each name an entry key.
+ *
+ * This is THE conversion, and it has exactly one implementation on purpose: the
+ * commit flow (`ValOps.prepare`) and the engine that builds draft content
+ * (`applyPatchRecord`) both expand through here, so a draft
+ * cannot show something other than what publishing writes. A second
+ * implementation of the same rule would differ silently, which is the whole
+ * failure mode this exists to prevent.
+ *
+ * The value must be the entries' CONTENT. A module's Source is markers, not
+ * content, so a Source handed over here is refused rather than written: that is
+ * the shape of the original bug (a revert replaying the archived Source), and
+ * it is not recoverable afterwards - the markers replace the entries' content
+ * on disk.
+ */
+function expandJsonValuesRootOp(op, currentEntries) {
+  var valueRes = jsonValuesRootValue(op);
+  if (fp.result.isErr(valueRes)) {
+    return valueRes;
+  }
+  var value = valueRes.value;
+  var expanded = [];
+  for (var _i = 0, _Object$keys = Object.keys(value); _i < _Object$keys.length; _i++) {
+    var entryKey = _Object$keys[_i];
+    var write = writeForEntry(value, entryKey, currentEntries);
+    if (write !== null) {
+      expanded.push(write);
+    }
+  }
+  var _iterator = createForOfIteratorHelper._createForOfIteratorHelper(currentEntries.keys()),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _entryKey = _step.value;
+      if (!Object.prototype.hasOwnProperty.call(value, _entryKey)) {
+        expanded.push({
+          op: "remove",
+          path: [_entryKey]
+        });
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return fp.result.ok(expanded);
+}
+
+/**
+ * What a whole-record write says about ONE entry: the same rule
+ * {@link expandJsonValuesRootOp} applies to all of them.
+ *
+ * For a reader that is about one entry. Expanding the whole record to find the
+ * one op that names its key costs an op per entry per entry read - the record
+ * squared, on exactly the large records this feature is for. The rule itself is
+ * `writeForEntry`, shared with the expansion above, so the two cannot come to
+ * disagree; only the loop around it differs.
+ *
+ * `null` means the write says nothing about this entry: it holds that content
+ * already, or the record does not name it and it does not exist.
+ */
+function expandJsonValuesRootOpForKey(op, entryKey, currentEntries) {
+  var valueRes = jsonValuesRootValue(op);
+  if (fp.result.isErr(valueRes)) {
+    return valueRes;
+  }
+  var value = valueRes.value;
+  if (Object.prototype.hasOwnProperty.call(value, entryKey)) {
+    return fp.result.ok(writeForEntry(value, entryKey, currentEntries));
+  }
+  if (currentEntries.has(entryKey)) {
+    return fp.result.ok({
+      op: "remove",
+      path: [entryKey]
+    });
+  }
+  return fp.result.ok(null);
+}
+
+/**
+ * The record a whole-record write carries, once it is known to be one.
+ *
+ * Every entry's value is checked here rather than where each one is written:
+ * a marker anywhere in the record means the writer handed over a module's
+ * Source, and the answer to that is to refuse the write, not to write the rest
+ * of it. Both entry points ask, so an entry read reports it too rather than
+ * showing a draft of a patch that publishing will refuse.
+ */
+function jsonValuesRootValue(op) {
+  if (op.op !== "replace" && op.op !== "add") {
+    return fp.result.err(new patch.PatchError("Cannot '".concat(op.op, "' the root of a .jsonValues() record: only add and replace write the whole record")));
+  }
+  var value = op.value;
+  if (!isJsonValuesRecord(value)) {
+    return fp.result.err(new patch.PatchError("Cannot write the root of a .jsonValues() record with a non-record value: it must be an object of entry key to entry content"));
+  }
+  for (var _i2 = 0, _Object$keys2 = Object.keys(value); _i2 < _Object$keys2.length; _i2++) {
+    var entryKey = _Object$keys2[_i2];
+    /*
+     * A marker is what a module's Source holds WHERE THE CONTENT IS NOT: it
+     * says the content is in the entry's own file. Handed back as an entry's
+     * value - which is what replaying an archived Source does - it would
+     * replace that content with the note saying where it used to be, and
+     * nothing downstream could tell the difference.
+     */
+    if (core.Internal.isJson(value[entryKey])) {
+      return fp.result.err(new patch.PatchError("Cannot write the .jsonValues() entry '".concat(entryKey, "' from a '").concat(core.VAL_EXTENSION, ": \"json\"' marker: a marker says the content is in the entry's own file, so write the entry's CONTENT here, not the module's Source")));
+    }
+  }
+  return fp.result.ok(value);
+}
+
+/** THE rule, for one entry the record names. `null` = nothing to write. */
+function writeForEntry(value, entryKey, currentEntries) {
+  var content = value[entryKey];
+  if (!currentEntries.has(entryKey)) {
+    return {
+      op: "add",
+      path: [entryKey],
+      value: content
+    };
+  }
+  var current = currentEntries.get(entryKey);
+  if (current !== undefined && patch.deepEqual(current, content)) {
+    // Unchanged: emitting a replace here would rewrite the entry's file with
+    // the bytes it already holds, so putting a module back would show up as a
+    // change to every entry in it.
+    return null;
+  }
+  return {
+    op: "replace",
+    path: [entryKey],
+    value: content
+  };
+}
+
+/**
+ * Rebases a patch op that targets a `.jsonValues()` entry's content so its paths
+ * are relative to the entry's `*.val.json` root (drops the record + entry-key
+ * prefix). Used to replay the op against the backing JSON file.
+ */
+function rebaseContentOp(op, prefixLen) {
+  var path = op.path.slice(prefixLen);
+  switch (op.op) {
+    case "add":
+    case "replace":
+    case "test":
+      return fp.result.ok(createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, op), {}, {
+        path: path
+      }));
+    case "remove":
+      {
+        if (!fp.array.isNonEmpty(path)) {
+          return fp.result.err(new patch.PatchError("Cannot remove the root of a jsonValues entry"));
+        }
+        return fp.result.ok(createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, op), {}, {
+          path: path
+        }));
+      }
+    case "move":
+      {
+        var from = op.from.slice(prefixLen);
+        if (!fp.array.isNonEmpty(from)) {
+          return fp.result.err(new patch.PatchError("Cannot move from the root of a jsonValues entry"));
+        }
+        return fp.result.ok(createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, op), {}, {
+          path: path,
+          from: from
+        }));
+      }
+    case "copy":
+      return fp.result.ok(createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, op), {}, {
+        path: path,
+        from: op.from.slice(prefixLen)
+      }));
+    case "file":
+      // A file op carries bytes, not content. The binary goes through the
+      // normal upload pipeline; what lands in the entry is the `patch_id` that
+      // marks the bytes as not yet committed, which the caller writes.
+      return fp.result.err(new patch.PatchError("A file op is not a content op: rebase it via its path"));
+  }
+}
+
+/**
+ * The entry a path names when it names a WHOLE entry of the root
+ * `.jsonValues()` record, and `undefined` for anything else.
+ */
+function wholeEntryKey(serializedSchema, path) {
+  if (!serializedSchema) {
+    return undefined;
+  }
+  var cls = classifyJsonValuesOp(serializedSchema, path);
+  return cls.kind === "entry" && cls.recordPath.length === 0 && cls.subPath.length === 0 ? cls.entryKey : undefined;
+}
+
+/*
+ * THE engine: one function that turns a module's content and a patch into
+ * the module's next content. See `docs/plans/one-content-model.md`, "One
+ * engine".
+ *
+ * It owns the rules the server's two readers used to follow each in their own
+ * way (`ValOps.getSources` for the module, and a replay of its own for a
+ * `.jsonValues()` entry, kept test-only in `legacyEngine.ts` in
+ * `@valbuild/server` for the conformance cases):
+ *
+ * - where a file's `patch_id` lands: the field's path plus `nestedFilePath`,
+ *   after every other op of the patch;
+ * - what an edit inside an entry does: applied to the entry's content when it
+ *   is loaded, held (`waiting`) until it is when it is not;
+ * - what a whole entry added does: a marker in the module, content in the
+ *   entry;
+ * - that a module's chain stops at its first failing patch, and that the
+ *   entries stop with it.
+ *
+ * Copy-on-write along each op's path: nothing is mutated, so a subtree no op
+ * touched keeps its identity (which makes "did this path change?" a `===`),
+ * and a patch costs the depth of its path, not the module's size. Every
+ * container it copies is counted ({@link engineWork}).
+ */
+
+/** What one `.jsonValues()` entry is at a point in a module's chain. */
+
+/**
+ * The ops held for an entry, newest first: a list that is extended without
+ * copying, so a chain of N edits to an entry nobody loaded costs N, not N².
+ */
+
+/**
+ * A module's content: its source, and what its `.jsonValues()` entries are.
+ *
+ * `entries` holds only the entries the chain has touched. An entry it has
+ * not is the base's: `waiting` on its own key with nothing held, as long as
+ * the source has its marker ({@link entryState}). So a module with no
+ * entries, or a chain that never touches one, costs nothing here.
+ */
+
+/** One patch of a module's chain. */
+
+var NO_ENTRIES = new Map();
+
+/** A module's content with nothing applied yet: its base. */
+function baseModuleContent(source) {
+  return {
+    source: source,
+    entries: NO_ENTRIES
+  };
+}
+
+// #region counted work
+
+/**
+ * What a copied container costs, per slot copied (an object's entry or an
+ * array's element): one reference. Strings and numbers are shared, never
+ * copied, so this is what a copy really moves -- and what the whole module
+ * cost per patch before copy-on-write (`applyPatch(deepClone(module))`).
+ */
+var SLOT_BYTES = 8;
+var applies = 0;
+var clonedBytes = 0;
+
+/**
+ * The work the engine has done in this process: patches applied
+ * (`engine:apply-patch`) and bytes copied (`engine:clone-bytes`, see
+ * {@link SLOT_BYTES}). A test takes it before and after; never reset, so two
+ * readers of it cannot disturb each other.
+ */
+function engineWork() {
+  return {
+    applyPatch: applies,
+    cloneBytes: clonedBytes
+  };
+}
+
+// #region the patch
+
+/**
+ * Applies one patch to a module's content. Nothing is mutated: the module
+ * passed in is still what it was, and the one returned shares every subtree
+ * the patch did not touch.
+ *
+ * `failed` means the patch does not apply, and then none of it does: half a
+ * patch is half an edit. The caller stops the module's chain there.
+ *
+ * `schema` is the module's serialized schema: it says which ops reach into a
+ * `.jsonValues()` entry. Without one, every op is an op on the source.
+ */
+function applyPatchRecord(module, record, schema) {
+  applies++;
+  var patchId = record.patchId;
+  var fail = function fail(message) {
+    return {
+      status: "failed",
+      patchId: patchId,
+      message: message
+    };
+  };
+  var source = module.source;
+  var entries = null;
+  var stateOf = function stateOf(key) {
+    var _get;
+    return (_get = (entries !== null && entries !== void 0 ? entries : module.entries).get(key)) !== null && _get !== void 0 ? _get : implicitState(source, key);
+  };
+  var setEntry = function setEntry(key, state) {
+    if (entries === null) {
+      clonedBytes += SLOT_BYTES * module.entries.size;
+      entries = new Map(module.entries);
+    }
+    entries.set(key, state);
+  };
+  /** Sets it, unless the entry already failed: an entry's error is sticky. */
+  var settle = function settle(key, state) {
+    var _stateOf;
+    if (((_stateOf = stateOf(key)) === null || _stateOf === void 0 ? void 0 : _stateOf.kind) !== "error") setEntry(key, state);
+  };
+  /**
+   * The record's keys as they stand while this patch is walked, for a write
+   * of the whole record to expand against. Only the key set: the source holds
+   * markers, and an entry's content may not be loaded. Seeded from the source
+   * BEFORE this patch and kept current by the whole-entry ops below.
+   */
+  var keys = null;
+  var currentKeys = function currentKeys() {
+    if (keys === null) {
+      keys = new Map();
+      if (isObjectNode(module.source)) {
+        for (var _i = 0, _Object$keys = Object.keys(module.source); _i < _Object$keys.length; _i++) {
+          var _key = _Object$keys[_i];
+          keys.set(_key, undefined);
+        }
+      }
+    }
+    return keys;
+  };
+  /** Where a file's `patch_id` lands in the source; last write wins its place. */
+  var fileMarks = new Map();
+  /** And in an entry's content. */
+  var entryFileMarks = [];
+  var _iterator = createForOfIteratorHelper._createForOfIteratorHelper(record.patch),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var rawOp = _step.value;
+      /*
+       * A write of the WHOLE record fans out into per-entry ops first, through
+       * the expansion the commit flow uses too (`expandJsonValuesRootOp`).
+       * Left as it is, it would put content where the source holds markers.
+       */
+      var ops = [rawOp];
+      if (schema !== undefined && isJsonValuesRootOp(schema, rawOp)) {
+        var expanded = expandJsonValuesRootOp(rawOp, currentKeys());
+        if (fp.result.isErr(expanded)) return fail(expanded.error.message);
+        ops = expanded.value;
+      }
+      var _iterator3 = createForOfIteratorHelper._createForOfIteratorHelper(ops),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _op = _step3.value;
+          var cls = schema === undefined ? {
+            kind: "normal"
+          } : classifyJsonValuesOp(schema, _op.path);
+          if (_op.op === "file") {
+            var _op$nestedFilePath;
+            /*
+             * A file op carries bytes, not content. What the content needs is
+             * the `patch_id` saying those bytes are not published yet, so the
+             * file is served from the patch rather than from a `/public` path
+             * that holds nothing. Keyed by where it LANDS -- the field's path
+             * plus `nestedFilePath` -- because a video's poster and captions are
+             * file ops on the video's own path. A delete has no bytes to point at.
+             */
+            if (_op.value === null) continue;
+            var nested = (_op$nestedFilePath = _op.nestedFilePath) !== null && _op$nestedFilePath !== void 0 ? _op$nestedFilePath : [];
+            if (cls.kind === "entry" && cls.subPath.length > 0) {
+              if (cls.recordPath.length === 0) {
+                entryFileMarks.push({
+                  key: cls.entryKey,
+                  path: cls.subPath.concat(nested, "patch_id")
+                });
+              }
+              continue;
+            }
+            var at = _op.path.concat(nested, "patch_id");
+            fileMarks.set(JSON.stringify(at), at);
+            if (cls.kind === "entry" && cls.recordPath.length === 0) {
+              // The entry IS the media: its content gets the mark too.
+              entryFileMarks.push({
+                key: cls.entryKey,
+                path: nested.concat("patch_id")
+              });
+            }
+            continue;
+          }
+          if (cls.kind === "normal") {
+            var _applied = applyOp(source, _op);
+            if (fp.result.isErr(_applied)) return fail(_applied.error.message);
+            source = _applied.value;
+            if (_op.op === "move") {
+              var fromKey = wholeEntryKey(schema, _op.from);
+              if (fromKey !== undefined) settle(fromKey, {
+                kind: "deleted"
+              });
+            }
+            if (_op.path.length === 0 && (schema === null || schema === void 0 ? void 0 : schema.type) === "record" && schema.jsonValues === true) {
+              // The record itself was replaced (by something that is not a
+              // record): every entry went with it.
+              clonedBytes += SLOT_BYTES * (entries !== null && entries !== void 0 ? entries : module.entries).size;
+              entries = new Map();
+            }
+            continue;
+          }
+          if (cls.recordPath.length > 0) {
+            return fail("Nested .jsonValues() records are not supported: '".concat(cls.recordPath.join("."), "'. Use .jsonValues() only on a module's root record/router."));
+          }
+          var _key3 = cls.entryKey;
+          if (cls.subPath.length > 0) {
+            // An edit INSIDE an entry: its content, never the source's marker.
+            if (_op.op === "move" || _op.op === "copy") {
+              var fromCls = schema === undefined ? {
+                kind: "normal"
+              } : classifyJsonValuesOp(schema, _op.from);
+              if (fromCls.kind !== "entry" || fromCls.entryKey !== _key3) {
+                return fail("Cannot '".concat(_op.op, "' between different jsonValues entries"));
+              }
+            }
+            var rebased = rebaseContentOp(_op, cls.recordPath.length + 1);
+            if (fp.result.isErr(rebased)) return fail(rebased.error.message);
+            var _state = stateOf(_key3);
+            if (_state === undefined || _state.kind === "deleted") {
+              setEntry(_key3, {
+                kind: "error",
+                patchId: patchId,
+                message: "Cannot edit jsonValues entry '".concat(_key3, "': it does not exist")
+              });
+            } else if (_state.kind === "waiting") {
+              setEntry(_key3, {
+                kind: "waiting",
+                from: _state.from,
+                ops: {
+                  op: rebased.value,
+                  patchId: patchId,
+                  before: _state.ops
+                }
+              });
+            } else if (_state.kind === "content") {
+              var _applied2 = applyOp(_state.content, rebased.value);
+              setEntry(_key3, fp.result.isErr(_applied2) ? {
+                kind: "error",
+                patchId: patchId,
+                message: _applied2.error.message
+              } : {
+                kind: "content",
+                content: _applied2.value
+              });
+            }
+            continue;
+          }
+
+          // A WHOLE entry: a marker in the source, content in the entry.
+          var marker = createForOfIteratorHelper._defineProperty(createForOfIteratorHelper._defineProperty({}, core.VAL_EXTENSION, "json"), "patch_id", patchId);
+          if (_op.op === "add" || _op.op === "replace") {
+            var written = _op.op === "add" ? addAt(source, _op.path, marker) : replaceAt(source, _op.path, marker);
+            if (fp.result.isErr(written)) return fail(written.error.message);
+            source = written.value;
+            currentKeys().set(_key3, undefined);
+            settle(_key3, {
+              kind: "content",
+              content: _op.value
+            });
+          } else if (_op.op === "remove") {
+            var removed = removeAt(source, _op.path);
+            if (fp.result.isErr(removed)) return fail(removed.error.message);
+            source = removed.value.doc;
+            currentKeys()["delete"](_key3);
+            settle(_key3, {
+              kind: "deleted"
+            });
+          } else if (_op.op === "move" || _op.op === "copy") {
+            var _fromCls = schema === undefined ? {
+              kind: "normal"
+            } : classifyJsonValuesOp(schema, _op.from);
+            if (_fromCls.kind !== "entry" || _fromCls.subPath.length !== 0 || _fromCls.recordPath.length !== 0) {
+              return fail("Cannot '".concat(_op.op, "' a jsonValues entry across records or from a non-entry path (from '").concat(_op.from.join("."), "' to '").concat(_op.path.join("."), "')"));
+            }
+            var _fromKey = _fromCls.entryKey;
+            // Read before anything moves: the destination is the source entry
+            // as it stood at this op.
+            var fromState = stateOf(_fromKey);
+            var added = addAt(source, _op.path, marker);
+            if (fp.result.isErr(added)) return fail(added.error.message);
+            source = added.value;
+            currentKeys().set(_key3, undefined);
+            if (_op.op === "move") {
+              var _removed = removeAt(source, _op.from);
+              if (fp.result.isErr(_removed)) return fail(_removed.error.message);
+              source = _removed.value.doc;
+              currentKeys()["delete"](_fromKey);
+            }
+            settle(_key3, fromState === undefined || fromState.kind === "deleted" ? {
+              kind: "error",
+              patchId: patchId,
+              message: "Cannot resolve '".concat(_op.op, "' of jsonValues entry '").concat(_key3, "' from its own content")
+            } : fromState);
+            if (_op.op === "move" && _fromKey !== _key3) {
+              settle(_fromKey, {
+                kind: "deleted"
+              });
+            }
+          } else {
+            // `test` of a whole entry: the commit refuses it (`ValOps.prepare`),
+            // so the read does too, rather than showing a patch publishing fails.
+            return fail("Unsupported op '".concat(_op.op, "' on jsonValues entry '").concat(_key3, "' (supported: add, remove, replace, move, copy)"));
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var _iterator2 = createForOfIteratorHelper._createForOfIteratorHelper(fileMarks.values()),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _at = _step2.value;
+      var marked = addAt(source, _at, patchId);
+      if (fp.result.isErr(marked)) return fail(marked.error.message);
+      source = marked.value;
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  for (var _i2 = 0, _entryFileMarks = entryFileMarks; _i2 < _entryFileMarks.length; _i2++) {
+    var _entryFileMarks$_i = _entryFileMarks[_i2],
+      _key2 = _entryFileMarks$_i.key,
+      path = _entryFileMarks$_i.path;
+    var state = stateOf(_key2);
+    var op = {
+      op: "add",
+      path: path,
+      value: patchId
+    };
+    if ((state === null || state === void 0 ? void 0 : state.kind) === "content") {
+      var applied = applyOp(state.content, op);
+      setEntry(_key2, fp.result.isErr(applied) ? {
+        kind: "error",
+        patchId: patchId,
+        message: applied.error.message
+      } : {
+        kind: "content",
+        content: applied.value
+      });
+    } else if ((state === null || state === void 0 ? void 0 : state.kind) === "waiting") {
+      setEntry(_key2, {
+        kind: "waiting",
+        from: state.from,
+        ops: {
+          op: op,
+          patchId: patchId,
+          before: state.ops
+        }
+      });
+    }
+  }
+  return {
+    status: "applied",
+    module: {
+      source: source,
+      entries: entries !== null && entries !== void 0 ? entries : module.entries
+    }
+  };
+}
+
+/**
+ * A module's chain: every patch in order, stopping at the first that does
+ * not apply. `applied` is how many did, so the chain the content is AT is
+ * the first `applied` ids -- what its version names.
+ */
+function applyChain(module, records, schema) {
+  var current = module;
+  var _iterator4 = createForOfIteratorHelper._createForOfIteratorHelper(records.entries()),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var _step4$value = createForOfIteratorHelper._slicedToArray(_step4.value, 2),
+        index = _step4$value[0],
+        record = _step4$value[1];
+      var res = applyPatchRecord(current, record, schema);
+      if (res.status === "failed") {
+        return {
+          module: current,
+          applied: index,
+          failed: {
+            patchId: res.patchId,
+            message: res.message
+          }
+        };
+      }
+      current = res.module;
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return {
+    module: current,
+    applied: records.length,
+    failed: null
+  };
+}
+
+// #region entries
+
+/**
+ * What an entry is in this module: what the chain made it, or -- for one the
+ * chain never touched -- the base's, if the source has its marker.
+ */
+function entryState(module, key) {
+  var _module$entries$get;
+  return (_module$entries$get = module.entries.get(key)) !== null && _module$entries$get !== void 0 ? _module$entries$get : implicitState(module.source, key);
+}
+function implicitState(source, key) {
+  return isObjectNode(source) && Object.prototype.hasOwnProperty.call(source, key) && core.Internal.isJson(source[key]) ? {
+    kind: "waiting",
+    from: key,
+    ops: null
+  } : undefined;
+}
+
+/** An entry's content, read. */
+
+/**
+ * An entry's content: what {@link entryState} says, with what it was waiting
+ * for applied. `baseContentOf` is the BASE content of an entry by key (its
+ * `*.val.json`, or what a save left there), `undefined` for one the base does
+ * not have.
+ */
+function resolveEntry(key, state, baseContentOf) {
+  if (state === undefined || state.kind === "deleted") {
+    return {
+      kind: "missing"
+    };
+  }
+  if (state.kind === "error") {
+    return {
+      kind: "error",
+      message: state.message,
+      patchId: state.patchId
+    };
+  }
+  if (state.kind === "content") {
+    return {
+      kind: "content",
+      content: state.content
+    };
+  }
+  var held = [];
+  for (var at = state.ops; at !== null; at = at.before) held.push(at);
+  var content = baseContentOf(state.from);
+  if (content === undefined) {
+    var first = held[held.length - 1];
+    return first === undefined ? {
+      kind: "missing"
+    } : {
+      kind: "error",
+      message: "Cannot edit jsonValues entry '".concat(key, "': it does not exist"),
+      patchId: first.patchId
+    };
+  }
+  for (var i = held.length - 1; i >= 0; i--) {
+    var _held$i = held[i],
+      op = _held$i.op,
+      patchId = _held$i.patchId;
+    var applied = applyOp(content, op);
+    if (fp.result.isErr(applied)) {
+      return {
+        kind: "error",
+        message: applied.error.message,
+        patchId: patchId
+      };
+    }
+    content = applied.value;
+  }
+  return {
+    kind: "content",
+    content: content
+  };
+}
+
+// #region copy-on-write JSON ops
+
+/*
+ * RFC 6902 as `JSONOps` (in `@valbuild/core/patch`) applies it -- the same
+ * results and the same error messages, which the conformance cases hold --
+ * but without mutating anything: a container on an op's path is copied, and
+ * everything else is shared.
+ */
+
+function isArrayNode(node) {
+  return Array.isArray(node);
+}
+function isObjectNode(node) {
+  return createForOfIteratorHelper._typeof(node) === "object" && node !== null && !Array.isArray(node);
+}
+function hasOwn(node, key) {
+  return Object.prototype.hasOwnProperty.call(node, key);
+}
+function patchError(message) {
+  return fp.result.err(new patch.PatchError(message));
+}
+function copyArray(node) {
+  clonedBytes += SLOT_BYTES * node.length;
+  return node.slice();
+}
+
+/**
+ * A shallow copy, key by key. Not a spread, which was tried: a module's root
+ * is a large object in dictionary mode, and V8 spreads one of forty thousand
+ * keys at about half this speed (the 5 MB keystroke of
+ * `scenarios/measure/keystroke.ts` went from 19 ms to 33).
+ */
+function copyObject(node) {
+  var copy = {};
+  var slots = 0;
+  for (var _i3 = 0, _Object$keys2 = Object.keys(node); _i3 < _Object$keys2.length; _i3++) {
+    var _key4 = _Object$keys2[_i3];
+    setOwn(copy, _key4, node[_key4]);
+    slots++;
+  }
+  clonedBytes += SLOT_BYTES * slots;
+  return copy;
+}
+
+/** An own property, even for `__proto__`, which `=` would not create. */
+function setOwn(target, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value: value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  } else {
+    target[key] = value;
+  }
+}
+function arrayIndex(key, node, inclusive) {
+  if (inclusive && key === "-") return fp.result.ok(node.length);
+  var index = patch.parseAndValidateArrayIndex(key);
+  if (fp.result.isErr(index)) return index;
+  return (inclusive ? index.value <= node.length : index.value < node.length) ? index : patchError("Array index out of bounds");
+}
+function childOf(node, key) {
+  if (isArrayNode(node)) {
+    var index = patch.parseAndValidateArrayIndex(key);
+    if (fp.result.isErr(index)) return index;
+    return index.value >= node.length ? patchError("Array index out of bounds") : fp.result.ok(node[index.value]);
+  }
+  if (isObjectNode(node)) {
+    return fp.result.ok(hasOwn(node, key) ? node[key] : undefined);
+  }
+  return patchError("Cannot access non-object/array");
+}
+
+/** `node` with `key` set to `value`: the one copy a step on a path costs. */
+function withChild(node, key, value) {
+  if (isArrayNode(node)) {
+    var copy = copyArray(node);
+    copy[Number(key)] = value;
+    return copy;
+  }
+  if (isObjectNode(node)) {
+    var _copy = copyObject(node);
+    setOwn(_copy, key, value);
+    return _copy;
+  }
+  return node;
+}
+
+/**
+ * Walks `path` to the parent of its last segment, lets `leaf` change that
+ * parent, and copies every container on the way back up. Errors as
+ * `JSONOps`'s pointer walk: the first missing step is reported.
+ */
+function updateAt(node, path, index, leaf) {
+  var key = path[index];
+  if (index === path.length - 1) return leaf(node, key);
+  var child = childOf(node, key);
+  if (fp.result.isErr(child)) return child;
+  if (child.value === undefined) {
+    return patchError("Path refers to non-existing object/array");
+  }
+  var updated = updateAt(child.value, path, index + 1, leaf);
+  if (fp.result.isErr(updated)) return updated;
+  return fp.result.ok({
+    node: updated.value.node === child.value ? node : withChild(node, key, updated.value.node),
+    out: updated.value.out
+  });
+}
+function isNonEmpty(path) {
+  return path.length > 0;
+}
+function getAt(doc, path) {
+  var node = doc;
+  var _iterator5 = createForOfIteratorHelper._createForOfIteratorHelper(path),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var _key5 = _step5.value;
+      var child = childOf(node, _key5);
+      if (fp.result.isErr(child)) return child;
+      if (child.value === undefined) {
+        return patchError("Path refers to non-existing object/array");
+      }
+      node = child.value;
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  return fp.result.ok(node);
+}
+function addAt(doc, path, value) {
+  if (!isNonEmpty(path)) return fp.result.ok(value);
+  var res = updateAt(doc, path, 0, function (parent, key) {
+    if (isArrayNode(parent)) {
+      var index = arrayIndex(key, parent, true);
+      if (fp.result.isErr(index)) return index;
+      var copy = copyArray(parent);
+      copy.splice(index.value, 0, value);
+      return fp.result.ok({
+        node: copy,
+        out: null
+      });
+    }
+    if (isObjectNode(parent)) {
+      var _copy2 = copyObject(parent);
+      setOwn(_copy2, key, value);
+      return fp.result.ok({
+        node: _copy2,
+        out: null
+      });
+    }
+    return patchError("Cannot add to non-object/array");
+  });
+  return fp.result.isErr(res) ? res : fp.result.ok(res.value.node);
+}
+function replaceAt(doc, path, value) {
+  if (!isNonEmpty(path)) return fp.result.ok(value);
+  var res = updateAt(doc, path, 0, function (parent, key) {
+    if (isArrayNode(parent)) {
+      var index = arrayIndex(key, parent, false);
+      if (fp.result.isErr(index)) return index;
+      var copy = copyArray(parent);
+      copy[index.value] = value;
+      return fp.result.ok({
+        node: copy,
+        out: null
+      });
+    }
+    if (isObjectNode(parent)) {
+      if (!hasOwn(parent, key)) {
+        return patchError("Cannot replace object element which does not exist");
+      }
+      var _copy3 = copyObject(parent);
+      setOwn(_copy3, key, value);
+      return fp.result.ok({
+        node: _copy3,
+        out: null
+      });
+    }
+    return patchError("Cannot replace in non-object/array");
+  });
+  return fp.result.isErr(res) ? res : fp.result.ok(res.value.node);
+}
+function removeAt(doc, path) {
+  if (!isNonEmpty(path)) {
+    return patchError("Cannot remove from non-object/array");
+  }
+  var res = updateAt(doc, path, 0, function (parent, key) {
+    if (isArrayNode(parent)) {
+      var index = arrayIndex(key, parent, false);
+      if (fp.result.isErr(index)) return index;
+      var copy = copyArray(parent);
+      var _copy$splice = copy.splice(index.value, 1),
+        _copy$splice2 = createForOfIteratorHelper._slicedToArray(_copy$splice, 1),
+        removed = _copy$splice2[0];
+      return fp.result.ok({
+        node: copy,
+        out: removed
+      });
+    }
+    if (isObjectNode(parent) && hasOwn(parent, key)) {
+      var _copy4 = copyObject(parent);
+      var _removed2 = parent[key];
+      delete _copy4[key];
+      return fp.result.ok({
+        node: _copy4,
+        out: _removed2
+      });
+    }
+    return patchError("Cannot remove from non-object/array");
+  });
+  return fp.result.isErr(res) ? res : fp.result.ok({
+    doc: res.value.node,
+    removed: res.value.out
+  });
+}
+
+/** One op on a document. `file` is not an op on content: the caller marks. */
+function applyOp(doc, op) {
+  switch (op.op) {
+    case "add":
+      return addAt(doc, op.path, op.value);
+    case "replace":
+      return replaceAt(doc, op.path, op.value);
+    case "remove":
+      {
+        var removed = removeAt(doc, op.path);
+        return fp.result.isErr(removed) ? removed : fp.result.ok(removed.value.doc);
+      }
+    case "move":
+      {
+        var _removed3 = removeAt(doc, op.from);
+        if (fp.result.isErr(_removed3)) return _removed3;
+        return addAt(_removed3.value.doc, op.path, _removed3.value.removed);
+      }
+    case "copy":
+      {
+        // Shared, not cloned: nothing here mutates, so two places can hold one
+        // value.
+        var value = getAt(doc, op.from);
+        if (fp.result.isErr(value)) return value;
+        return addAt(doc, op.path, value.value);
+      }
+    case "test":
+      {
+        // As `applyPatch` in `@valbuild/core/patch`, which the commit applies
+        // `.val.ts` text through: a path that does not exist, or a value there
+        // that is not deeply equal, fails the patch (RFC 6902, 4.6). The two
+        // have to agree, or a draft shows a patch Publish refuses.
+        var _value = getAt(doc, op.path);
+        if (fp.result.isErr(_value)) return _value;
+        if (!patch.deepEqual(op.value, _value.value)) return patchError("Test failed");
+        return fp.result.ok(doc);
+      }
+    case "file":
+      return patchError("Cannot apply a file patch here");
+  }
+}
+
+/*
+ * The store: modules by address. See `docs/plans/one-content-model.md`,
+ * "The store: one address, immutable values, tiers".
+ *
+ * Content at a version never changes, so a store of modules by `moduleKey`
+ * needs no invalidation, only eviction. A base is a version with the empty
+ * chain, so the same store holds both. Every place that keeps modules uses
+ * the same tiers, in the order that fits it: Val's server keeps
+ * `[memoryTier, bundleTier, …]` in front of its head (`ValHead` in
+ * `@valbuild/server`), and the Studio's will put an origin tier behind them
+ * (phase 7).
+ */
+
+/** One module's content at one version, as a tier holds it. */
+
+// #region counted work
+
+var tierHits = new Map();
+var tierMisses = 0;
+
+/**
+ * What the stores in this process have answered, by tier, and how often
+ * none of them had a key: a test takes it before and after. Never reset.
+ */
+function storeWork() {
+  return {
+    hits: Object.fromEntries(tierHits),
+    misses: tierMisses
+  };
+}
+
+// #region tiered
+
+/**
+ * Asks each tier in turn; what a slower tier answers is written to the faster
+ * ones before it. A tier that answers `null` has no say.
+ */
+function tiered(tiers) {
+  return {
+    name: tiers.map(function (tier) {
+      return tier.name;
+    }).join(">"),
+    get: function get(key) {
+      return createForOfIteratorHelper._asyncToGenerator(/*#__PURE__*/createForOfIteratorHelper._regenerator().m(function _callee() {
+        var _iterator, _step, _tierHits$get, _step$value, index, tier, found, _iterator2, _step2, _faster$put, faster, _t;
+        return createForOfIteratorHelper._regenerator().w(function (_context) {
+          while (1) switch (_context.p = _context.n) {
+            case 0:
+              _iterator = createForOfIteratorHelper._createForOfIteratorHelper(tiers.entries());
+              _context.p = 1;
+              _iterator.s();
+            case 2:
+              if ((_step = _iterator.n()).done) {
+                _context.n = 6;
+                break;
+              }
+              _step$value = createForOfIteratorHelper._slicedToArray(_step.value, 2), index = _step$value[0], tier = _step$value[1];
+              _context.n = 3;
+              return tier.get(key);
+            case 3:
+              found = _context.v;
+              if (!(found === null)) {
+                _context.n = 4;
+                break;
+              }
+              return _context.a(3, 5);
+            case 4:
+              tierHits.set(tier.name, ((_tierHits$get = tierHits.get(tier.name)) !== null && _tierHits$get !== void 0 ? _tierHits$get : 0) + 1);
+              _iterator2 = createForOfIteratorHelper._createForOfIteratorHelper(tiers.slice(0, index));
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  faster = _step2.value;
+                  (_faster$put = faster.put) === null || _faster$put === void 0 || _faster$put.call(faster, key, found, found.bytes);
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
+              }
+              return _context.a(2, found);
+            case 5:
+              _context.n = 2;
+              break;
+            case 6:
+              _context.n = 8;
+              break;
+            case 7:
+              _context.p = 7;
+              _t = _context.v;
+              _iterator.e(_t);
+            case 8:
+              _context.p = 8;
+              _iterator.f();
+              return _context.f(8);
+            case 9:
+              tierMisses++;
+              return _context.a(2, null);
+          }
+        }, _callee, null, [[1, 7, 8, 9]]);
+      }))();
+    },
+    put: function put(key, value, bytes) {
+      var _tiers$, _tiers$$put;
+      (_tiers$ = tiers[0]) === null || _tiers$ === void 0 || (_tiers$$put = _tiers$.put) === null || _tiers$$put === void 0 || _tiers$$put.call(_tiers$, key, value, bytes);
+    }
+  };
+}
+
+// #region memory
+
+/**
+ * Bounded by bytes; keeps the last `lastPerModule` versions per module path
+ * (and, apart from them, the last `lastPerModule` bases), and lets go of the least recently read value when over `budgetBytes`. A
+ * value bigger than the whole budget is still held while it is the newest,
+ * so the read that made it is answered; the next put lets it go.
+ */
+function memoryTier(opts) {
+  var _opts$name;
+  /** In least-recently-read order: a read moves a key to the end. */
+  var held = new Map();
+  /** Per module, its keys oldest first. */
+  var rings = new Map();
+  var bytes = 0;
+  var evicted = 0;
+  var versionOf = function versionOf(key) {
+    var _held$get;
+    return (_held$get = held.get(key)) === null || _held$get === void 0 ? void 0 : _held$get.value.version;
+  };
+  var drop = function drop(key) {
+    var entry = held.get(key);
+    if (entry === undefined) return;
+    held["delete"](key);
+    bytes -= entry.bytes;
+    evicted++;
+    var ring = rings.get(entry.value.path);
+    if (ring !== undefined) {
+      var at = ring.indexOf(key);
+      if (at >= 0) ring.splice(at, 1);
+      if (ring.length === 0) rings["delete"](entry.value.path);
+    }
+  };
+  return {
+    name: (_opts$name = opts.name) !== null && _opts$name !== void 0 ? _opts$name : "memory",
+    get: function get(key) {
+      var entry = held.get(key);
+      if (entry === undefined) return null;
+      held["delete"](key);
+      held.set(key, entry);
+      return entry.value;
+    },
+    put: function put(key, value, valueBytes) {
+      var _rings$get;
+      if (held.has(key)) {
+        drop(key);
+        evicted--;
+      }
+      held.set(key, {
+        value: value,
+        bytes: valueBytes
+      });
+      bytes += valueBytes;
+      var ring = (_rings$get = rings.get(value.path)) !== null && _rings$get !== void 0 ? _rings$get : [];
+      ring.push(key);
+      rings.set(value.path, ring);
+      // The last N versions, and apart from them the last N bases: a base
+      // is what a slower tier answered (the bundle's own object, held
+      // anyway) and written up here, and it must not push out the version
+      // before the newest -- which a reader of the previous version still
+      // asks for.
+      var isBase = value.version.chain === EMPTY_CHAIN;
+      var sameKind = ring.filter(function (held) {
+        var _versionOf;
+        return ((_versionOf = versionOf(held)) === null || _versionOf === void 0 ? void 0 : _versionOf.chain) === EMPTY_CHAIN === isBase;
+      });
+      var _iterator3 = createForOfIteratorHelper._createForOfIteratorHelper(sameKind.slice(0, Math.max(0, sameKind.length - opts.lastPerModule))),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var oldest = _step3.value;
+          drop(oldest);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      var _iterator4 = createForOfIteratorHelper._createForOfIteratorHelper(held.keys()),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var lru = _step4.value;
+          if (bytes <= opts.budgetBytes) break;
+          if (lru === key) continue;
+          drop(lru);
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+    },
+    charge: function charge(key, extra) {
+      var entry = held.get(key);
+      if (entry === undefined) return;
+      entry.bytes += extra;
+      bytes += extra;
+    },
+    latest: function latest(path) {
+      var _held$get$value, _held$get2;
+      var ring = rings.get(path);
+      var newest = ring === null || ring === void 0 ? void 0 : ring[ring.length - 1];
+      return newest === undefined ? null : (_held$get$value = (_held$get2 = held.get(newest)) === null || _held$get2 === void 0 ? void 0 : _held$get2.value) !== null && _held$get$value !== void 0 ? _held$get$value : null;
+    },
+    stats: function stats() {
+      // Versions: what a chain made. A base written up from a slower tier is
+      // the build's own object (counted at no bytes), held beside them, and
+      // not one of the module's versions.
+      var mostVersions = 0;
+      var mostBytes = 0;
+      var versions = 0;
+      var modules = 0;
+      var _iterator5 = createForOfIteratorHelper._createForOfIteratorHelper(rings.values()),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var ring = _step5.value;
+          var made = ring.filter(function (key) {
+            var _versionOf2;
+            return ((_versionOf2 = versionOf(key)) === null || _versionOf2 === void 0 ? void 0 : _versionOf2.chain) !== EMPTY_CHAIN;
+          });
+          versions += made.length;
+          if (made.length > 0) modules++;
+          mostVersions = Math.max(mostVersions, made.length);
+          var moduleBytes = 0;
+          var _iterator6 = createForOfIteratorHelper._createForOfIteratorHelper(ring),
+            _step6;
+          try {
+            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+              var _held$get$bytes, _held$get3;
+              var _key = _step6.value;
+              moduleBytes += (_held$get$bytes = (_held$get3 = held.get(_key)) === null || _held$get3 === void 0 ? void 0 : _held$get3.bytes) !== null && _held$get$bytes !== void 0 ? _held$get$bytes : 0;
+            }
+          } catch (err) {
+            _iterator6.e(err);
+          } finally {
+            _iterator6.f();
+          }
+          mostBytes = Math.max(mostBytes, moduleBytes);
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      return {
+        bytes: bytes,
+        versions: versions,
+        modules: modules,
+        mostVersionsOfOneModule: mostVersions,
+        mostBytesOfOneModule: mostBytes,
+        evicted: evicted
+      };
+    }
+  };
+}
+
+// #region bundle
+
+/**
+ * The build's own modules, free: answers only a key whose version is the
+ * bundle's -- its schema, its base and the empty chain -- with the bundle's
+ * own object, which the process holds for every visitor anyway. `bundle`
+ * says what the build evaluated each module to; `null` for a module the
+ * build does not have.
+ */
+function bundleTier(bundle) {
+  var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "bundle";
+  return {
+    name: name,
+    get: function get(key) {
+      return createForOfIteratorHelper._asyncToGenerator(/*#__PURE__*/createForOfIteratorHelper._regenerator().m(function _callee2() {
+        var path, own, version;
+        return createForOfIteratorHelper._regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              path = pathOfModuleKey(key);
+              if (!(path === null)) {
+                _context2.n = 1;
+                break;
+              }
+              return _context2.a(2, null);
+            case 1:
+              _context2.n = 2;
+              return bundle(path);
+            case 2:
+              own = _context2.v;
+              if (!(own === null)) {
+                _context2.n = 3;
+                break;
+              }
+              return _context2.a(2, null);
+            case 3:
+              version = createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, own.version), {}, {
+                chain: EMPTY_CHAIN
+              });
+              if (!(moduleKey(path, version) !== key)) {
+                _context2.n = 4;
+                break;
+              }
+              return _context2.a(2, null);
+            case 4:
+              return _context2.a(2, {
+                path: path,
+                version: version,
+                content: baseModuleContent(own.source),
+                patches: [],
+                bytes: 0
+              });
+          }
+        }, _callee2);
+      }))();
+    }
+  };
+}
+
+/** The module a {@link moduleKey} is the address of, or `null` for none. */
+function pathOfModuleKey(key) {
+  var at = key.lastIndexOf("@");
+  return at <= 0 ? null : key.slice(0, at);
+}
+
+/**
+ * The version a {@link moduleKey} names, or `null` when it is not one. The
+ * three parts are hex or empty, so the split is unambiguous.
+ */
+function parseModuleKey(key) {
+  var path = pathOfModuleKey(key);
+  if (path === null) return null;
+  var parts = key.slice(path.length + 1).split(".");
+  var _parts = createForOfIteratorHelper._slicedToArray(parts, 3),
+    schema = _parts[0],
+    base = _parts[1],
+    chain = _parts[2];
+  if (parts.length !== 3 || schema === undefined || base === undefined || chain === undefined) {
+    return null;
+  }
+  return {
+    path: path,
+    version: {
+      schema: schema,
+      base: base,
+      chain: chain
+    }
+  };
+}
+
+// #region entries
+
+/**
+ * A `.jsonValues()` entry's version: the record's schema and base, the
+ * entry's key, and the chain of the record's patches that touched THIS
+ * entry -- so an entry no patch touched keeps its version while the record's
+ * chain grows, and two reads at one entry version are the same content.
+ * Entries are stored on their own, so a large record is not copied because
+ * one entry changed.
+ */
+
+/** The address of an entry's content. Never changes meaning. */
+function entryAddress(path, v) {
+  return "".concat(moduleKey(path, v), "#").concat(v.key);
+}
+
+/** Whether two entry versions name the same content. */
+function sameEntryVersion(a, b) {
+  return a.key === b.key && a.schema === b.schema && a.base === b.base && a.chain === b.chain;
+}
+
+var SharedValConfig = zod.z.object({
+  contentHostUrl: zod.z.string().optional(),
+  appHostUrl: zod.z.string().optional(),
+  project: zod.z.string().optional(),
+  root: zod.z.string().optional(),
+  gitCommit: zod.z.string().optional(),
+  gitBranch: zod.z.string().optional(),
+  defaultTheme: zod.z["enum"](["dark", "light"]).optional(),
+  ai: zod.z.object({
+    commitMessages: zod.z.object({
+      disabled: zod.z["boolean"]().optional()
+    }).optional()
+  }).optional()
+});
+
+/**
+ * Config that is shared between the client and server.
  */
 
 /**
@@ -7969,7 +9971,9 @@ function createSearchIndex() {
       tokenize: "forward"
     }),
     pathToLabel: new Map(),
-    docsByModule: new Map()
+    docsByModule: new Map(),
+    walkedByModule: new Map(),
+    entriesByModule: new Map()
   };
 }
 
@@ -7983,77 +9987,230 @@ function createSearchIndex() {
  * `.jsonValues()` entries are indexed only once their content is loaded — an
  * un-loaded entry is an opaque marker that {@link traverseSchemaSource} skips, so
  * the index is naturally PARTIAL and grows as batches land. That is why the search
- * UI loads the entries on the first query and re-indexes (debounced) as they
- * arrive, rather than pretending an empty result set is an answer.
+ * UI loads the entries on the first query and re-indexes as they arrive, rather
+ * than pretending an empty result set is an answer -- and why a module whose
+ * root is a record is re-indexed by entry ({@link indexRecordModule}): a pass
+ * per batch walks the batch, not the record.
  */
-function indexModule(searchIndex, moduleFilePath, source, schema) {
-  var index = searchIndex.index,
-    pathToLabel = searchIndex.pathToLabel,
-    docsByModule = searchIndex.docsByModule;
+function indexModule(searchIndex, moduleFilePath, source, schema,
+/**
+ * Stop by this time (`performance.now()`), for a caller that must not hold
+ * the thread: answers `false` when it stopped with entries of a record
+ * module still to walk, and the same call again goes on from there. A
+ * module that is not a record is walked whole, whatever the time.
+ */
+until) {
+  var walked = searchIndex.walkedByModule.get(moduleFilePath);
+  if (walked !== undefined && walked.source === source && walked.schema === schemaKeyOf(schema)) {
+    return true;
+  }
+  if (schema.type === "record" && isJsonRecord(source)) {
+    var done = indexRecordModule(searchIndex, moduleFilePath, source, schema, until);
+    if (done) {
+      searchIndex.walkedByModule.set(moduleFilePath, {
+        source: source,
+        schema: schemaKeyOf(schema)
+      });
+    }
+    return done;
+  }
   removeModule(searchIndex, moduleFilePath);
   var docs = new Set();
-  docsByModule.set(moduleFilePath, docs);
+  searchIndex.docsByModule.set(moduleFilePath, docs);
   var path = moduleFilePath + "?p=";
-  traverseSchemaSource(source, schema, path, function (_ref) {
-    var source = _ref.source,
-      schema = _ref.schema,
-      path = _ref.path;
-    if (source === null) {
-      return;
-    }
-    var searchText = "";
-    var label = "";
-
-    // Handle primitives
-    if (schema.type === "string" || schema.type === "number" || schema.type === "boolean" || schema.type === "date" || schema.type === "dateTime" || schema.type === "color" || schema.type === "code" || schema.type === "keyOf" || schema.type === "route" ||
-    // An enum's value is a string the editor chose; it is as searchable as
-    // any other string leaf. The old string union was never indexed at all,
-    // which is the gap this closes.
-    schema.type === "enum" ||
-    // A locale tag, for the same reason: it is what the editor picked and
-    // what they see in the field, so searching "nb-NO" has to find the
-    // Norwegian rows. `traverseSchemaSource` visits these, and visiting a
-    // leaf only to index it as the empty string is worse than not visiting
-    // it — it looks like content that does not exist.
-    schema.type === "locale") {
-      var _source$toString, _source$toString2;
-      searchText = (_source$toString = source === null || source === void 0 ? void 0 : source.toString()) !== null && _source$toString !== void 0 ? _source$toString : "";
-      label = (_source$toString2 = source === null || source === void 0 ? void 0 : source.toString()) !== null && _source$toString2 !== void 0 ? _source$toString2 : "";
-    } else if (schema.type === "literal") {
-      searchText = schema.value.toString();
-      label = schema.value.toString();
-    }
-    // Handle richtext - flatten to get text content
-    else if (schema.type === "richtext") {
-      searchText = flattenRichText(source);
-      // Use first 50 chars as label
-      label = searchText.substring(0, 50) || "richtext";
-    }
-    // Handle file/image/video
-    else if (schema.type === "file" || schema.type === "image" || schema.type === "video") {
-      if (source !== null && createForOfIteratorHelper._typeof(source) === "object" && "path" in source && typeof source.path === "string") {
-        // The label is the bare filename - the folder is shown separately in
-        // the UI - but both are searchable.
-        var _getRefParts = getRefParts(source.path),
-          filename = _getRefParts.filename,
-          folder = _getRefParts.folder;
-        var alt = "alt" in source ? source.alt : "";
-        searchText = filename + " " + folder + " " + alt;
-        label = filename;
+  traverseSchemaSource(source, schema, path, function (leaf) {
+    var id = indexLeaf(searchIndex, leaf);
+    if (id !== null) docs.add(id);
+  });
+  searchIndex.walkedByModule.set(moduleFilePath, {
+    source: source,
+    schema: schemaKeyOf(schema)
+  });
+  return true;
+}
+
+/** How many entries are walked between two looks at the clock. */
+var ENTRIES_PER_CLOCK_CHECK = 32;
+
+/**
+ * A module whose root is a record, indexed entry by entry: an entry whose
+ * value is the SAME OBJECT it was indexed from keeps its documents, and only
+ * the others are walked.
+ *
+ * What makes loading a `.jsonValues()` record of 10,000 entries searchable
+ * while it loads. The Studio asks again as each batch lands, and the record's
+ * value is copy-on-write -- an entry nothing touched is the object it was --
+ * so each pass indexes the batch that arrived, not the record. Walked whole,
+ * that was the whole record per batch: quadratic, and a long task each time.
+ *
+ * Identity is only ever a shortcut: a value that is equal but a new object
+ * (a structured clone across a worker, a module read again) is walked again,
+ * never skipped. A different schema starts the module over.
+ */
+function indexRecordModule(searchIndex, moduleFilePath, source, schema, until) {
+  var index = searchIndex.index,
+    pathToLabel = searchIndex.pathToLabel,
+    docsByModule = searchIndex.docsByModule,
+    entriesByModule = searchIndex.entriesByModule;
+  var indexed = entriesByModule.get(moduleFilePath);
+  var docs = docsByModule.get(moduleFilePath);
+  if (indexed === undefined || docs === undefined || indexed.schema !== schema && schemaKeyOf(indexed.schema) !== schemaKeyOf(schema)) {
+    removeModule(searchIndex, moduleFilePath);
+    indexed = {
+      schema: schema,
+      entries: new Map()
+    };
+    docs = new Set();
+    entriesByModule.set(moduleFilePath, indexed);
+    docsByModule.set(moduleFilePath, docs);
+  }
+  var _indexed = indexed,
+    entries = _indexed.entries;
+  var _iterator = createForOfIteratorHelper._createForOfIteratorHelper(entries),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = createForOfIteratorHelper._slicedToArray(_step.value, 2),
+        _key = _step$value[0],
+        was = _step$value[1];
+      if (Object.prototype.hasOwnProperty.call(source, _key) && source[_key] === was.source) {
+        continue;
+      }
+      var _iterator2 = createForOfIteratorHelper._createForOfIteratorHelper(was.docs),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _id = _step2.value;
+          index.remove(_id);
+          pathToLabel["delete"](_id);
+          docs["delete"](_id);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
       }
+      entries["delete"](_key);
     }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var path = moduleFilePath + "?p=";
+  var walked = 0;
+  var _loop = function _loop() {
+      if (entries.has(key)) return 0; // continue
+      if (until !== undefined && ++walked % ENTRIES_PER_CLOCK_CHECK === 0 && performance.now() > until) {
+        return {
+          v: false
+        };
+      }
+      var value = source[key];
+      var entryDocs = [];
+      traverseSchemaSource(value, schema.item, sourcePathOfChild(path, key), function (leaf) {
+        var id = indexLeaf(searchIndex, leaf);
+        if (id === null) return;
+        entryDocs.push(id);
+        docs.add(id);
+      });
+      entries.set(key, {
+        source: value,
+        docs: entryDocs
+      });
+    },
+    _ret;
+  for (var key in source) {
+    _ret = _loop();
+    if (_ret === 0) continue;
+    if (_ret) return _ret.v;
+  }
+  return true;
+}
+function isJsonRecord(source) {
+  return createForOfIteratorHelper._typeof(source) === "object" && source !== null && !Array.isArray(source);
+}
+
+/**
+ * A schema by its content, kept per schema object. Its object is not enough:
+ * the Studio receives a module's schema again (new code, a re-read of the
+ * project) as a new object that says the same, and starting a record of
+ * 10,000 entries over for that was seconds of removing and adding
+ * documents in one go.
+ */
+var schemaKeys = new WeakMap();
+function schemaKeyOf(schema) {
+  var key = schemaKeys.get(schema);
+  if (key === undefined) {
+    key = JSON.stringify(schema);
+    schemaKeys.set(schema, key);
+  }
+  return key;
+}
+
+/** One leaf as a document, if it has anything to find. Its id, or `null`. */
+function indexLeaf(searchIndex, _ref) {
+  var source = _ref.source,
+    schema = _ref.schema,
+    path = _ref.path;
+  if (source === null) {
+    return null;
+  }
+  var index = searchIndex.index,
+    pathToLabel = searchIndex.pathToLabel;
+  var searchText = "";
+  var label = "";
 
-    // Add to index if we have search text
-    if (searchText) {
-      var _Internal$splitModule = core.Internal.splitModuleFilePathAndModulePath(path),
-        _Internal$splitModule2 = createForOfIteratorHelper._slicedToArray(_Internal$splitModule, 2),
-        modulePath = _Internal$splitModule2[1];
-      var cleanPath = fastRemoveNonWordChars(modulePath) + " ";
-      index.add(path, cleanPath + " " + path + " " + searchText);
-      pathToLabel.set(path, label);
-      docs.add(path);
+  // Handle primitives
+  if (schema.type === "string" || schema.type === "number" || schema.type === "boolean" || schema.type === "date" || schema.type === "dateTime" || schema.type === "color" || schema.type === "code" || schema.type === "keyOf" || schema.type === "route" ||
+  // An enum's value is a string the editor chose; it is as searchable as
+  // any other string leaf. The old string union was never indexed at all,
+  // which is the gap this closes.
+  schema.type === "enum" ||
+  // A locale tag, for the same reason: it is what the editor picked and
+  // what they see in the field, so searching "nb-NO" has to find the
+  // Norwegian rows. `traverseSchemaSource` visits these, and visiting a
+  // leaf only to index it as the empty string is worse than not visiting
+  // it — it looks like content that does not exist.
+  schema.type === "locale") {
+    var _source$toString, _source$toString2;
+    searchText = (_source$toString = source === null || source === void 0 ? void 0 : source.toString()) !== null && _source$toString !== void 0 ? _source$toString : "";
+    label = (_source$toString2 = source === null || source === void 0 ? void 0 : source.toString()) !== null && _source$toString2 !== void 0 ? _source$toString2 : "";
+  } else if (schema.type === "literal") {
+    searchText = schema.value.toString();
+    label = schema.value.toString();
+  }
+  // Handle richtext - flatten to get text content
+  else if (schema.type === "richtext") {
+    searchText = flattenRichText(source);
+    // Use first 50 chars as label
+    label = searchText.substring(0, 50) || "richtext";
+  }
+  // Handle file/image/video
+  else if (schema.type === "file" || schema.type === "image" || schema.type === "video") {
+    if (source !== null && createForOfIteratorHelper._typeof(source) === "object" && "path" in source && typeof source.path === "string") {
+      // The label is the bare filename - the folder is shown separately in
+      // the UI - but both are searchable.
+      var _getRefParts = getRefParts(source.path),
+        filename = _getRefParts.filename,
+        folder = _getRefParts.folder;
+      var alt = "alt" in source ? source.alt : "";
+      searchText = filename + " " + folder + " " + alt;
+      label = filename;
     }
-  });
+  }
+
+  // Add to index if we have search text
+  if (!searchText) {
+    return null;
+  }
+  var _Internal$splitModule = core.Internal.splitModuleFilePathAndModulePath(path),
+    _Internal$splitModule2 = createForOfIteratorHelper._slicedToArray(_Internal$splitModule, 2),
+    modulePath = _Internal$splitModule2[1];
+  var cleanPath = fastRemoveNonWordChars(modulePath) + " ";
+  index.add(path, cleanPath + " " + path + " " + searchText);
+  pathToLabel.set(path, label);
+  return path;
 }
 
 /**
@@ -8065,21 +10222,24 @@ function indexModule(searchIndex, moduleFilePath, source, schema) {
 function removeModule(searchIndex, moduleFilePath) {
   var index = searchIndex.index,
     pathToLabel = searchIndex.pathToLabel,
-    docsByModule = searchIndex.docsByModule;
+    docsByModule = searchIndex.docsByModule,
+    entriesByModule = searchIndex.entriesByModule;
+  entriesByModule["delete"](moduleFilePath);
+  searchIndex.walkedByModule["delete"](moduleFilePath);
   var existing = docsByModule.get(moduleFilePath);
   if (existing === undefined) return;
-  var _iterator = createForOfIteratorHelper._createForOfIteratorHelper(existing),
-    _step;
+  var _iterator3 = createForOfIteratorHelper._createForOfIteratorHelper(existing),
+    _step3;
   try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _id = _step.value;
-      index.remove(_id);
-      pathToLabel["delete"](_id);
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _id2 = _step3.value;
+      index.remove(_id2);
+      pathToLabel["delete"](_id2);
     }
   } catch (err) {
-    _iterator.e(err);
+    _iterator3.e(err);
   } finally {
-    _iterator.f();
+    _iterator3.f();
   }
   docsByModule["delete"](moduleFilePath);
 }
@@ -9554,27 +11714,30 @@ var messageOf = function messageOf(error) {
   return error instanceof Error ? error.message : String(error);
 };
 
-exports.PublishProtocolError = protocol.PublishProtocolError;
-exports.parseArtifacts = protocol.parseArtifacts;
-exports.parseBuildTarget = protocol.parseBuildTarget;
-exports.parseCancel = protocol.parseCancel;
-exports.parseDeclare = protocol.parseDeclare;
-exports.parseDiscard = protocol.parseDiscard;
-exports.parseJob = protocol.parseJob;
-exports.parseNewestCiRun = protocol.parseNewestCiRun;
-exports.parsePress = protocol.parsePress;
-exports.parseProblems = protocol.parseProblems;
-exports.parseProjectSource = protocol.parseProjectSource;
-exports.parsePromote = protocol.parsePromote;
-exports.parsePublishToken = protocol.parsePublishToken;
-exports.parseRenew = protocol.parseRenew;
-exports.parseRequestStatus = protocol.parseRequestStatus;
-exports.parseStatus = protocol.parseStatus;
-exports.parseUpdateTarget = protocol.parseUpdateTarget;
-exports.parseVerify = protocol.parseVerify;
+exports.PublishProtocolError = projectSource.PublishProtocolError;
+exports.createProjectSourceReader = projectSource.createProjectSourceReader;
+exports.parseArtifacts = projectSource.parseArtifacts;
+exports.parseBuildTarget = projectSource.parseBuildTarget;
+exports.parseCancel = projectSource.parseCancel;
+exports.parseDeclare = projectSource.parseDeclare;
+exports.parseDiscard = projectSource.parseDiscard;
+exports.parseJob = projectSource.parseJob;
+exports.parseNewestCiRun = projectSource.parseNewestCiRun;
+exports.parsePress = projectSource.parsePress;
+exports.parseProblems = projectSource.parseProblems;
+exports.parseProjectSource = projectSource.parseProjectSource;
+exports.parsePromote = projectSource.parsePromote;
+exports.parsePublishToken = projectSource.parsePublishToken;
+exports.parseRenew = projectSource.parseRenew;
+exports.parseRequestStatus = projectSource.parseRequestStatus;
+exports.parseStatus = projectSource.parseStatus;
+exports.parseUpdateTarget = projectSource.parseUpdateTarget;
+exports.parseVerify = projectSource.parseVerify;
+exports.publishApiOf = projectSource.publishApiOf;
 exports.DEFAULT_CANVAS_SELECTION = getSitemapTree.DEFAULT_CANVAS_SELECTION;
 exports.DEFAULT_CANVAS_SELECTION_SOFT = getSitemapTree.DEFAULT_CANVAS_SELECTION_SOFT;
 exports.QUICK_PREVIEW_PARAM = getSitemapTree.QUICK_PREVIEW_PARAM;
+exports.QUICK_PREVIEW_RENDER_SCRIPT = getSitemapTree.QUICK_PREVIEW_RENDER_SCRIPT;
 exports.QUICK_PREVIEW_SERVICE_WORKER_PATH = getSitemapTree.QUICK_PREVIEW_SERVICE_WORKER_PATH;
 exports.QUICK_PREVIEW_SERVICE_WORKER_SOURCE = getSitemapTree.QUICK_PREVIEW_SERVICE_WORKER_SOURCE;
 exports.QUICK_PREVIEW_STORE_MESSAGE = getSitemapTree.QUICK_PREVIEW_STORE_MESSAGE;
@@ -9619,12 +11782,15 @@ exports.AnalyticsBeacon = AnalyticsBeacon;
 exports.Api = Api;
 exports.BRAND_CONTRAST_PAIRS = BRAND_CONTRAST_PAIRS;
 exports.BinaryFileRef = BinaryFileRef;
+exports.ChainFold = ChainFold;
 exports.CodeOptions = CodeOptions;
 exports.ColorOptions = ColorOptions;
 exports.DEFAULT_ERROR_MESSAGE = DEFAULT_ERROR_MESSAGE;
 exports.DateOptions = DateOptions;
+exports.EMPTY_CHAIN = EMPTY_CHAIN;
 exports.ENCODE_DEFAULTS = ENCODE_DEFAULTS;
 exports.ENCODE_MIME_TYPE_OF = ENCODE_MIME_TYPE_OF;
+exports.ENGINE = ENGINE;
 exports.FileOptions = FileOptions;
 exports.HistoricalCommit = HistoricalCommit;
 exports.HistoricalModule = HistoricalModule;
@@ -9637,6 +11803,7 @@ exports.JSON_ENTRIES_BATCH_MAX = JSON_ENTRIES_BATCH_MAX;
 exports.LOCAL_FILE_IN_REMOTE_PROJECT_HINT = LOCAL_FILE_IN_REMOTE_PROJECT_HINT;
 exports.LOCAL_FILE_IN_REMOTE_PROJECT_WARNING = LOCAL_FILE_IN_REMOTE_PROJECT_WARNING;
 exports.ModuleComparison = ModuleComparison;
+exports.ModuleVersionSchema = ModuleVersionSchema;
 exports.NEVER_ENCODED = NEVER_ENCODED;
 exports.ParentRef = ParentRef$1;
 exports.Patch = Patch;
@@ -9645,6 +11812,7 @@ exports.PatchId = PatchId;
 exports.PatchJSON = PatchJSON;
 exports.PatchSets = PatchSets;
 exports.PlanRefusalError = PlanRefusalError;
+exports.ProjectVersionSchema = ProjectVersionSchema;
 exports.RAMP_STEPS = RAMP_STEPS;
 exports.RemirrorBr = RemirrorBr;
 exports.RemirrorBulletList = RemirrorBulletList;
@@ -9662,6 +11830,7 @@ exports.RichTextOptions = RichTextOptions;
 exports.SCHEMA_SOURCE_FIXES = SCHEMA_SOURCE_FIXES;
 exports.SELF_CHECK_VERSION = SELF_CHECK_VERSION;
 exports.SKETCHPAD_MAX_TEXT_LENGTH = SKETCHPAD_MAX_TEXT_LENGTH;
+exports.STAGED_SCHEMA_PREFIX = STAGED_SCHEMA_PREFIX;
 exports.STUDIO_FIXES = STUDIO_FIXES;
 exports.SerializedArraySchema = SerializedArraySchema;
 exports.SerializedBooleanSchema = SerializedBooleanSchema;
@@ -9689,6 +11858,7 @@ exports.SerializedVideoSchema = SerializedVideoSchema;
 exports.SharedValConfig = SharedValConfig;
 exports.Sketchpad = Sketchpad;
 exports.SketchpadSummary = SketchpadSummary;
+exports.VAL_CLIENT_HEADER = VAL_CLIENT_HEADER;
 exports.VAL_ENABLE_COOKIE_NAME = VAL_ENABLE_COOKIE_NAME;
 exports.VAL_GREEN_RAMP = VAL_GREEN_RAMP;
 exports.VAL_SESSION_COOKIE = VAL_SESSION_COOKIE;
@@ -9701,17 +11871,24 @@ exports.VideoStreamOption = VideoStreamOption;
 exports.WARNING_FIXES = WARNING_FIXES;
 exports.WASM_ENCODED_MIME_TYPES = WASM_ENCODED_MIME_TYPES;
 exports.accentRamp = accentRamp;
+exports.applyChain = applyChain;
+exports.applyPatchRecord = applyPatchRecord;
+exports.baseModuleContent = baseModuleContent;
+exports.baseVersionOf = baseVersionOf;
 exports.buildDuplicatePatch = buildDuplicatePatch;
 exports.buildEmptyAtPathPatch = buildEmptyAtPathPatch;
 exports.buildFileRefValue = buildFileRefValue;
 exports.buildImageGalleryPatch = buildImageGalleryPatch;
 exports.buildRemoveImageGalleryEntryPatch = buildRemoveImageGalleryEntryPatch;
 exports.buildSearchIndex = buildSearchIndex;
+exports.bundleTier = bundleTier;
 exports.chainHeadOf = chainHeadOf;
+exports.chainOf = chainOf;
 exports.checkCompatibility = checkCompatibility;
 exports.checkSketch = checkSketch;
 exports.childSource = childSource;
 exports.chooseEncoded = chooseEncoded;
+exports.classifyJsonValuesOp = classifyJsonValuesOp;
 exports.concatModulePath = concatModulePath;
 exports.contrastRatio = contrastRatio;
 exports.createRegExpFromPattern = createRegExpFromPattern;
@@ -9720,8 +11897,14 @@ exports.createValClient = createValClient;
 exports.declaredLocales = declaredLocales;
 exports.describeContainerAtPath = describeContainerAtPath;
 exports.emptyOf = emptyOf;
+exports.engineWork = engineWork;
+exports.entryAddress = entryAddress;
+exports.entryState = entryState;
 exports.enumLocaleTag = enumLocaleTag;
+exports.expandJsonValuesRootOp = expandJsonValuesRootOp;
+exports.expandJsonValuesRootOpForKey = expandJsonValuesRootOpForKey;
 exports.explainIncompatible = explainIncompatible;
+exports.extendChain = extendChain;
 exports.fallbackMimeType = fallbackMimeType;
 exports.filterBlockingValidationErrors = filterBlockingValidationErrors;
 exports.filterRoutesByPatterns = filterRoutesByPatterns;
@@ -9745,6 +11928,7 @@ exports.hasLocaleRouteParam = hasLocaleRouteParam;
 exports.indexModule = indexModule;
 exports.isInsidePatchSetPath = isInsidePatchSetPath;
 exports.isJsonObject = isJsonObject;
+exports.isJsonValuesRootOp = isJsonValuesRootOp;
 exports.isLocaleSchema = isLocaleSchema;
 exports.isMimeTypeAccepted = isMimeTypeAccepted;
 exports.isRemoteSchema = isRemoteSchema;
@@ -9763,17 +11947,22 @@ exports.localeOfModuleRoot = localeOfModuleRoot;
 exports.localeOfRouteKey = localeOfRouteKey;
 exports.localeParamOfRouteKey = localeParamOfRouteKey;
 exports.localeScopeAt = localeScopeAt;
-exports.memoizePerRequest = memoizePerRequest;
+exports.memoryTier = memoryTier;
+exports.moduleKey = moduleKey;
 exports.newestCommitSha = newestCommitSha;
+exports.parseModuleKey = parseModuleKey;
 exports.parseSketch = parseSketch;
 exports.partitionValidationErrors = partitionValidationErrors;
+exports.pathOfModuleKey = pathOfModuleKey;
 exports.performSearch = performSearch;
 exports.proposalCustomProperties = proposalCustomProperties;
+exports.rebaseContentOp = rebaseContentOp;
 exports.relativeLuminance = relativeLuminance;
 exports.relocateForLocale = relocateForLocale;
 exports.remirrorToRichTextSource = remirrorToRichTextSource;
 exports.removeModule = removeModule;
 exports.resolveEncodeSettings = resolveEncodeSettings;
+exports.resolveEntry = resolveEntry;
 exports.resolvePairGround = resolvePairGround;
 exports.resolveSchemaSourceFixForError = resolveSchemaSourceFixForError;
 exports.resolveSchemaSourceFixes = resolveSchemaSourceFixes;
@@ -9781,8 +11970,11 @@ exports.resolveSerializedSchemaAtPath = resolveSerializedSchemaAtPath;
 exports.richTextImageSchema = richTextImageSchema;
 exports.richTextToRemirror = richTextToRemirror;
 exports.safeParsePatch = safeParsePatch;
+exports.sameEntryVersion = sameEntryVersion;
+exports.sameModuleVersion = sameModuleVersion;
 exports.schemaErrorsOf = schemaErrorsOf;
 exports.schemaTypesOfPath = schemaTypesOfPath;
+exports.schemaVersionOf = schemaVersionOf;
 exports.selectionClosure = selectionClosure;
 exports.selfCheck = selfCheck;
 exports.shouldEncodeWithWasm = shouldEncodeWithWasm;
@@ -9790,9 +11982,16 @@ exports.sideFiles = sideFiles;
 exports.sideSource = sideSource;
 exports.sketchTitle = sketchTitle;
 exports.sourcePathOfChild = sourcePathOfChild;
+exports.storeWork = storeWork;
 exports.themeCustomProperties = themeCustomProperties;
+exports.tiered = tiered;
 exports.toolNames = toolNames;
 exports.traverseSchemaSource = traverseSchemaSource;
 exports.urlOf = urlOf;
+exports.valClientHeaders = valClientHeaders;
+exports.valModulesEntryFile = valModulesEntryFile;
+exports.valModulesEntryPath = valModulesEntryPath;
 exports.validateRoutePatterns = validateRoutePatterns;
+exports.versionHashCount = versionHashCount;
+exports.wholeEntryKey = wholeEntryKey;
 exports.withExtension = withExtension;