@valbuild/server 0.144.0 → 0.144.2

package/dist/valbuild-server.cjs.prod.js

@@ -3593,6 +3593,12 @@ function findNestedJsonValuesModuleErrors(schemas) {
   }
   return errors;
 }
+
+/**
+ * What a save told this instance a `.jsonValues()` entry holds: its content --
+ * JSON `null` included -- or that it was deleted. See `adoptedJsonEntries`.
+ */
+
 // #region ValOps
 class ValOps {
   /** Sources from val modules, immutable (without patches or anything)  */
@@ -3630,6 +3636,13 @@ class ValOps {
    * {@link siteSourcesUnderSnapshot}, and only where there is a snapshot.
    */
   siteSourcesBeforeSnapshot = null;
+  /**
+   * The same modules as the bundle evaluated them, imports and all: where a
+   * `.jsonValues()` entry the snapshot did not save is read from. Not
+   * {@link siteSourcesBeforeSnapshot}, whose markers may have come as JSON
+   * from a content version, with no import behind them.
+   */
+  bundleSourcesBeforeSnapshot = null;
   /**
    * What a save has told us each `.jsonValues()` entry now holds.
    *
@@ -3641,7 +3654,9 @@ class ValOps {
    * unlike a module source there is nothing to re-extract, because the memo was
    * never holding the content in the first place.
    *
-   * `null` for an entry the commit deleted.
+   * `deleted` for an entry the commit deleted: tagged, not `null`, because an
+   * entry's content may itself be JSON `null` (a nullable item), and a saved
+   * `null` read back as "deleted" would report the entry missing.
    *
    * Never cleared: it describes what is on disk. A host rebuild makes a new
    * instance, which is the right reset. Bounded by the project's entry count,
@@ -3660,6 +3675,16 @@ class ValOps {
     this.modulesErrors = null;
     this.shaEntries = null;
     this.shaModuleErrors = null;
+    for (const [moduleFilePath, entries] of (options === null || options === void 0 ? void 0 : options.snapshotJsonEntries) ?? []) {
+      const adopted = new Map();
+      for (const [entryKey, content] of entries) {
+        adopted.set(entryKey, {
+          kind: "content",
+          content
+        });
+      }
+      this.adoptedJsonEntries.set(moduleFilePath, adopted);
+    }
   }
 
   // #region stat
@@ -3676,7 +3701,7 @@ class ValOps {
   // #region initTree
   async initSources() {
     if (this.baseSha === null || this.sourcesSha === null || this.configSha === null || this.schemaSha === null || this.sources === null || this.schemas === null || this.modulesErrors === null) {
-      var _this$options;
+      var _this$options, _this$options2;
       const extracted = await core.extractValModules(this.valModules);
       const moduleErrors = extracted.moduleErrors.concat(findNestedJsonValuesModuleErrors(extracted.schemas));
       this.sources = extracted.sources;
@@ -3694,16 +3719,45 @@ class ValOps {
        * being served, and a base SHA that still described the bundle would
        * say the snapshot's content was the bundle's.
        */
-      if ((_this$options = this.options) !== null && _this$options !== void 0 && _this$options.snapshotSources) {
+      const siteLayer = (_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.siteSnapshotSources;
+      const snapshotLayer = (_this$options2 = this.options) === null || _this$options2 === void 0 ? void 0 : _this$options2.snapshotSources;
+      /*
+       * The bundle's own Source for every module either layer replaces: a
+       * replaced `.jsonValues()` module's markers came as JSON, and an entry
+       * neither layer saved is read through the bundle's marker, which still
+       * has its `import()`.
+       */
+      if (siteLayer || snapshotLayer) {
+        const bundle = {};
+        for (const moduleFilePath of Object.keys({
+          ...siteLayer,
+          ...snapshotLayer
+        })) {
+          const path = moduleFilePath;
+          const bundled = extracted.sources[path];
+          if (bundled !== undefined) {
+            bundle[path] = bundled;
+          }
+        }
+        this.bundleSourcesBeforeSnapshot = bundle;
+      }
+      // What a proposal is compared against: the site, only where there is a proposal.
+      if (snapshotLayer) {
         const site = {};
-        for (const moduleFilePath of Object.keys(this.options.snapshotSources)) {
-          const source = extracted.sources[moduleFilePath];
+        for (const moduleFilePath of Object.keys(snapshotLayer)) {
+          const path = moduleFilePath;
+          const source = (siteLayer === null || siteLayer === void 0 ? void 0 : siteLayer[path]) ?? extracted.sources[path];
           if (source !== undefined) {
-            site[moduleFilePath] = source;
+            site[path] = source;
           }
         }
         this.siteSourcesBeforeSnapshot = site;
-        this.promoteCommittedSources(this.options.snapshotSources);
+      }
+      if (siteLayer || snapshotLayer) {
+        this.promoteCommittedSources({
+          ...siteLayer,
+          ...snapshotLayer
+        });
       }
       return {
         baseSha: this.baseSha,
@@ -3733,8 +3787,8 @@ class ValOps {
    * both, so it is not sent. `null` anywhere that is not a proposal.
    */
   async siteSourcesUnderSnapshot() {
-    var _this$options2;
-    if (!((_this$options2 = this.options) !== null && _this$options2 !== void 0 && _this$options2.snapshotSources)) return null;
+    var _this$options3;
+    if (!((_this$options3 = this.options) !== null && _this$options3 !== void 0 && _this$options3.snapshotSources)) return null;
     await this.initSources();
     return this.siteSourcesBeforeSnapshot;
   }
@@ -3801,7 +3855,13 @@ class ValOps {
       }
       const adopted = this.adoptedJsonEntries.get(moduleFilePath) ?? new Map();
       for (const [entryKey, content] of Object.entries(entries)) {
-        adopted.set(entryKey, content);
+        // A commit's `null` is a deleted entry: see `patchedJsonEntries`.
+        adopted.set(entryKey, content === null ? {
+          kind: "deleted"
+        } : {
+          kind: "content",
+          content
+        });
       }
       this.adoptedJsonEntries.set(moduleFilePath, adopted);
     }
@@ -4035,6 +4095,7 @@ class ValOps {
       }
     }
     const loaded = await Promise.all([...requestedKeys, ...sourceKeys].map(async entryKey => {
+      var _this$adoptedJsonEntr, _this$bundleSourcesBe;
       const marker = record[entryKey];
       if (marker !== undefined && !core.Internal.isJson(marker)) {
         // Not a jsonValues entry — return the inlined value as-is (defensive).
@@ -4069,15 +4130,20 @@ class ValOps {
        * The BASELINE only. Pending patches replay over it below exactly as
        * they do over the thunk's answer.
        */
-      const adopted = this.adoptedJsonEntries.get(moduleFilePath);
-      if (adopted !== undefined && adopted.has(entryKey)) {
-        const content = adopted.get(entryKey);
+      const adopted = (_this$adoptedJsonEntr = this.adoptedJsonEntries.get(moduleFilePath)) === null || _this$adoptedJsonEntr === void 0 ? void 0 : _this$adoptedJsonEntr.get(entryKey);
+      if (adopted !== undefined) {
         return {
           entryKey,
-          baseContent: content === null ? undefined : content
+          baseContent: adopted.kind === "deleted" ? undefined : adopted.content
         };
       }
-      const thunk = core.Internal.getJsonImport(marker);
+      /*
+       * A snapshot's marker came as JSON, with no import behind it: the
+       * entry the proposal did not save is the build's, behind the marker
+       * the module evaluated to.
+       */
+      const siteMarker = (_this$bundleSourcesBe = this.bundleSourcesBeforeSnapshot) === null || _this$bundleSourcesBe === void 0 || (_this$bundleSourcesBe = _this$bundleSourcesBe[moduleFilePath]) === null || _this$bundleSourcesBe === void 0 ? void 0 : _this$bundleSourcesBe[entryKey];
+      const thunk = core.Internal.getJsonImport(marker) ?? (core.Internal.isJson(siteMarker) ? core.Internal.getJsonImport(siteMarker) : undefined);
       if (!thunk) {
         return {
           entryKey,
@@ -5335,9 +5401,9 @@ class ValOps {
         // https://github.com/microsoft/TypeScript/issues/36174
         let sourceFileText = null;
         if (tsChanged) {
-          var _this$options3;
+          var _this$options4;
           sourceFileText = unescape(tsSourceFile.getText(tsSourceFile).replace(/\\u/g, "%u"));
-          if ((_this$options3 = this.options) !== null && _this$options3 !== void 0 && _this$options3.formatter) {
+          if ((_this$options4 = this.options) !== null && _this$options4 !== void 0 && _this$options4.formatter) {
             try {
               sourceFileText = await this.options.formatter(sourceFileText, path);
             } catch (err) {
@@ -5349,13 +5415,13 @@ class ValOps {
         }
         const extraFiles = {};
         for (const [jsonPath, content] of Array.from(jsonEntryContents)) {
-          var _this$options4;
+          var _this$options5;
           if (content === null) {
             extraFiles[jsonPath] = null;
             continue;
           }
           let jsonText = JSON.stringify(content, null, 2);
-          if ((_this$options4 = this.options) !== null && _this$options4 !== void 0 && _this$options4.formatter) {
+          if ((_this$options5 = this.options) !== null && _this$options5 !== void 0 && _this$options5.formatter) {
             try {
               jsonText = await this.options.formatter(jsonText, jsonPath);
             } catch (err) {
@@ -8974,6 +9040,182 @@ function proposalFromEnv(env) {
   };
 }
 
+/**
+ * A content version: the site's content, served by a build that bundles an
+ * older one. valbuild/home `docs/hosted-publishing.md`, step 2.
+ *
+ * The platform hands over only what differs from the bundle -- the modules
+ * whose Source changed and the Val files whose text did -- the way it hands a
+ * proposal's address its saved content, and it is read the same way: the
+ * snapshot source provider, over the bundle. What differs is the position: a
+ * version names the publish that made it (`job`, or its `commit`), and that is
+ * where this server says it sits, never at the build it runs in.
+ */
+
+/**
+ * The content version a platform hands over in its runtime env
+ * (`VAL_CONTENT`), or `undefined` when it hands over none.
+ *
+ * Throws on one it cannot read rather than serving the bundle as though it
+ * were the version: the site would show content older than what was
+ * published, and nothing would say so.
+ *
+ * A version too large for one variable names others under `refs`: a module's
+ * Source (JSON) or a file's text, each in a variable of its own --
+ * `{ "refs": { "modules": { "/a.val.ts": "env://VAL_CONTENT_1" } } }`. Flat:
+ * a referenced variable holds the value itself and is never read for further
+ * references. Only `refs` is resolved, never a string inside Source, and only
+ * `VAL_CONTENT_<n>` is ever read: Source is text editors write, and a
+ * reference resolved in there would read any variable the isolate holds,
+ * `VAL_SECRET` included, into a page. The scheme leaves room for another
+ * place to read from; one this does not know is refused, not skipped.
+ */
+function contentFromEnv(env) {
+  if (!env.VAL_CONTENT) {
+    return undefined;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(env.VAL_CONTENT);
+  } catch (err) {
+    throw new Error(`Val: VAL_CONTENT is not JSON (${err instanceof Error ? err.message : String(err)})`, {
+      cause: err
+    });
+  }
+  if (!isObject$1(parsed) || Array.isArray(parsed)) {
+    throw new Error("Val: VAL_CONTENT is not an object");
+  }
+  const id = parsed["id"];
+  if (typeof id !== "string" || id === "") {
+    throw new Error("Val: VAL_CONTENT has no id");
+  }
+  const job = parsed["job"] ?? null;
+  const commit = parsed["commit"] ?? null;
+  if (job !== null && typeof job !== "string") {
+    throw new Error(`Val: content version ${id}: job must be a string or null`);
+  }
+  if (commit !== null && typeof commit !== "string") {
+    throw new Error(`Val: content version ${id}: commit must be a string or null`);
+  }
+  const modulesIn = parsed["modules"] ?? {};
+  const filesIn = parsed["files"] ?? {};
+  if (!isObject$1(modulesIn) || Array.isArray(modulesIn) || !isObject$1(filesIn) || Array.isArray(filesIn)) {
+    throw new Error(`Val: content version ${id}: modules and files must be objects`);
+  }
+  const files = {};
+  for (const [path, text] of Object.entries(filesIn)) {
+    if (typeof text === "string") {
+      files[path] = text;
+    }
+  }
+  const modules = {
+    ...modulesIn
+  };
+  const refs = parsed["refs"] ?? {};
+  if (!isObject$1(refs) || Array.isArray(refs)) {
+    throw new Error(`Val: content version ${id}: refs must be an object`);
+  }
+  const read = (kind, path, ref) => {
+    const where = `Val: content version ${id}: refs.${kind}["${path}"]`;
+    if (typeof ref !== "string") {
+      throw new Error(`${where} must be a string`);
+    }
+    if (!ref.startsWith(ENV_REF)) {
+      throw new Error(`${where} is ${ref}: only ${ENV_REF}VAL_CONTENT_<n> is read`);
+    }
+    const name = ref.slice(ENV_REF.length);
+    if (!CONTENT_VARIABLE.test(name)) {
+      throw new Error(`${where} names ${name}: only VAL_CONTENT_<n> is read`);
+    }
+    const value = env[name];
+    if (value === undefined) {
+      throw new Error(`${where} names ${name}, which is not set`);
+    }
+    return {
+      where,
+      name,
+      value
+    };
+  };
+  const refModules = refs["modules"] ?? {};
+  const refFiles = refs["files"] ?? {};
+  if (!isObject$1(refModules) || Array.isArray(refModules) || !isObject$1(refFiles) || Array.isArray(refFiles)) {
+    throw new Error(`Val: content version ${id}: refs.modules and refs.files must be objects`);
+  }
+  for (const [path, ref] of Object.entries(refModules)) {
+    const {
+      where,
+      name,
+      value
+    } = read("modules", path, ref);
+    if (Object.prototype.hasOwnProperty.call(modules, path)) {
+      throw new Error(`${where}: ${path} is also in modules`);
+    }
+    try {
+      modules[path] = JSON.parse(value);
+    } catch (err) {
+      throw new Error(`${where}: ${name} is not JSON (${err instanceof Error ? err.message : String(err)})`, {
+        cause: err
+      });
+    }
+  }
+  for (const [path, ref] of Object.entries(refFiles)) {
+    const {
+      where,
+      value
+    } = read("files", path, ref);
+    // The handed object, not `files`: an inline value that is not text was
+    // dropped from `files`, and is still a second naming of the path.
+    if (Object.prototype.hasOwnProperty.call(filesIn, path)) {
+      throw new Error(`${where}: ${path} is also in files`);
+    }
+    files[path] = value;
+  }
+  if (job === null && commit === null) {
+    // Placed nowhere, Val would place it at the build it runs in -- the one
+    // position a version must never take: its own changes would be replayed
+    // over a snapshot that already holds them.
+    throw new Error(`Val: content version ${id} must name a job or a commit, or it would be placed at the build it runs in`);
+  }
+  return {
+    id,
+    job,
+    commit,
+    modules,
+    files
+  };
+}
+
+/** The one scheme a content version's `refs` may use, for now. */
+const ENV_REF = "env://";
+/** The only variables a reference may name. */
+const CONTENT_VARIABLE = /^VAL_CONTENT_[0-9]+$/;
+
+/**
+ * What a server or reader renders over the bundle: a proposal's saves over the
+ * content version the site serves, either alone, or nothing.
+ *
+ * Layered rather than chosen. At a proposal's address the platform hands both
+ * when the base the proposal was opened from serves content its build does not
+ * bundle (a content-only publish), and the proposal saves only the modules it
+ * changed: choosing the proposal alone would show every other module as the
+ * build bundles it -- older than the site it was opened from.
+ */
+function layeredSnapshot(proposal, contentVersion) {
+  if (proposal === undefined) return contentVersion;
+  if (contentVersion === undefined) return proposal;
+  return {
+    modules: {
+      ...contentVersion.modules,
+      ...proposal.modules
+    },
+    files: {
+      ...contentVersion.files,
+      ...proposal.files
+    }
+  };
+}
+
 /**
  * The proposal's saved Source, as Source: every module whose value is JSON.
  * One place, so the server and the readers that render without it agree on
@@ -8988,6 +9230,116 @@ function proposalSnapshot(proposal) {
   }
   return snapshot;
 }
+
+/**
+ * The `.jsonValues()` entries the proposal saved, by module and key.
+ *
+ * An entry's content is not in its module's Source -- that holds a marker per
+ * entry -- but in the entry's own `*.val.json`, and a save writes that file:
+ * it reaches the proposal's address as saved TEXT ({@link ValProposal.files}),
+ * not as Source. So the snapshot alone shows the build's entries. This is the
+ * other half: each saved `*.val.json`, read as the entry its module names.
+ *
+ * Which entry a file is comes from the module's `.val.ts`, whose
+ * `c.json(() => import("..."))` thunks name the files -- the saved text if
+ * the save rewrote it, else the build's own (`projectSource`). An entry whose
+ * module cannot be read that way is left to the build, as before: this adds
+ * what it can find and never fails the address.
+ */
+function proposalJsonEntries(proposal, projectSource) {
+  const found = new Map();
+  const savedJson = Object.keys(proposal.files).filter(path => path.endsWith(".val.json"));
+  if (savedJson.length === 0) return found;
+  const savedJsonPaths = new Set(savedJson);
+  for (const [moduleFilePath, source] of Object.entries(proposal.modules)) {
+    if (!holdsJsonMarkers(source)) continue;
+    const relative = moduleFilePath.replace(/^\//, "");
+    const text = proposal.files[relative] ?? (projectSource === null || projectSource === void 0 ? void 0 : projectSource[relative]);
+    if (text === undefined) continue;
+    const entries = jsonEntryPaths(relative, text);
+    if (entries === null) continue;
+    const byKey = new Map();
+    for (const [key, importPath] of entries) {
+      const jsonPath = resolveExistingJsonPath(moduleFilePath, importPath).replace(/^\//, "");
+      if (!savedJsonPaths.has(jsonPath)) continue;
+      const content = parseJson(proposal.files[jsonPath]);
+      if (content !== undefined) byKey.set(key, content);
+    }
+    if (byKey.size > 0) found.set(moduleFilePath, byKey);
+  }
+  return found;
+}
+
+/**
+ * The snapshot as a page reads it: {@link proposalSnapshot}, with each saved
+ * `.jsonValues()` entry's content in place of its marker -- the shape a draft
+ * already has, where the entries it edits hold content and the rest are
+ * markers the readers resolve from the build. See {@link proposalJsonEntries}.
+ *
+ * For the readers only. Val's own server keeps the markers
+ * ({@link proposalSnapshot}): its patching works on them, and it takes the
+ * saved entries separately.
+ */
+function proposalSnapshotForReaders(proposal, projectSource) {
+  const snapshot = proposalSnapshot(proposal);
+  for (const [moduleFilePath, entries] of proposalJsonEntries(proposal, projectSource)) {
+    const source = snapshot[moduleFilePath];
+    if (!isObject$1(source)) continue;
+    const filled = {};
+    for (const [key, value] of Object.entries(source)) {
+      if (isJsonValue(value)) filled[key] = value;
+    }
+    for (const [key, content] of entries) {
+      // Own keys only: an entry may be named `toString`.
+      if (Object.prototype.hasOwnProperty.call(filled, key)) {
+        filled[key] = content;
+      }
+    }
+    snapshot[moduleFilePath] = filled;
+  }
+  return snapshot;
+}
+
+/** A record of `.jsonValues()` markers (`{ _type: "json" }`), at least one. */
+function holdsJsonMarkers(source) {
+  return isObject$1(source) && Object.values(source).some(value => isObject$1(value) && value["_type"] === "json");
+}
+
+/** Each entry key's import path, from a `.jsonValues()` module's text. */
+function jsonEntryPaths(fileName, text) {
+  try {
+    const analysis = analyzeValModule(ts__default["default"].createSourceFile(fileName, text, ts__default["default"].ScriptTarget.ES2015, true));
+    if (fp.result.isErr(analysis)) return null;
+    const paths = new Map();
+    for (const [key, entry] of analyzeJsonValuesEntries(analysis.value.source)) {
+      paths.set(key, entry.importPath);
+    }
+    return paths;
+  } catch {
+    // Not a module this can read: its entries stay the build's.
+    return null;
+  }
+}
+function parseJson(text) {
+  if (text === undefined) return undefined;
+  try {
+    const value = JSON.parse(text);
+    return isMutableJsonValue(value) ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** {@link isJsonValue}, for the mutable JSON a server patches. */
+function isMutableJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every(isMutableJsonValue);
+  }
+  return isObject$1(value) && Object.values(value).every(isMutableJsonValue);
+}
 function isObject$1(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -9358,6 +9710,8 @@ class ValOpsHttp extends ValOps {
   publishBuild;
   /** See `proposal` on {@link ValApiOptions}; `null` on the site. */
   proposal;
+  /** See `contentVersion` on {@link ValApiOptions}; `null` at a proposal's address. */
+  contentVersion;
 
   /** Did the host hand over the running build's source? See `projectSource`. */
   embedsSource() {
@@ -9430,9 +9784,22 @@ class ValOpsHttp extends ValOps {
    * getSettings / uploadRemoteFile / getPresignedAuthNonce.
    */
   auth, valModules, options) {
-    super(valModules, options !== null && options !== void 0 && options.proposal ? {
+    /*
+     * What replaces the bundle's Source: the content version the site serves,
+     * and a proposal's saves over it at its address. Two layers rather than
+     * one, because the version is the SITE -- what a proposal is compared
+     * against -- and the proposal is what is being proposed.
+     */
+    const snapshot = layeredSnapshot(options === null || options === void 0 ? void 0 : options.proposal, options === null || options === void 0 ? void 0 : options.contentVersion);
+    super(valModules, options && snapshot ? {
       ...options,
-      snapshotSources: proposalSnapshot(options.proposal)
+      ...(options.proposal !== undefined ? {
+        snapshotSources: proposalSnapshot(options.proposal)
+      } : {}),
+      ...(options.contentVersion !== undefined ? {
+        siteSnapshotSources: proposalSnapshot(options.contentVersion)
+      } : {}),
+      snapshotJsonEntries: proposalJsonEntries(snapshot, options.projectSource)
     } : options);
     this.contentUrl = contentUrl;
     this.project = project;
@@ -9444,16 +9811,25 @@ class ValOpsHttp extends ValOps {
     };
     this.root = (options === null || options === void 0 ? void 0 : options.root) ?? "";
     this.proposal = (options === null || options === void 0 ? void 0 : options.proposal) ?? null;
+    this.contentVersion = this.proposal === null ? (options === null || options === void 0 ? void 0 : options.contentVersion) ?? null : null;
     /*
      * In a proposal, the text its saves wrote over the text the build was made
      * from: the next save patches the last one's `.val.ts`, not the base's.
+     * The same for a content version: the next publish patches what the last
+     * one published, not what the build bundles.
      */
-    this.projectSource = this.proposal !== null ? {
+    this.projectSource = snapshot !== undefined ? {
       ...((options === null || options === void 0 ? void 0 : options.projectSource) ?? {}),
-      ...this.proposal.files
+      ...snapshot.files
     } : (options === null || options === void 0 ? void 0 : options.projectSource) ?? null;
     this.publishJob = (options === null || options === void 0 ? void 0 : options.publishJob) ?? null;
-    this.publishBuild = (options === null || options === void 0 ? void 0 : options.publishBuild) ?? null;
+    /*
+     * Not with a content version: the content service places a build by the
+     * build first (`getApplicablePatchesAndCommits`), and this build bundles an
+     * older version than it serves -- placed there, the version's own changes
+     * would be replayed over a snapshot that already holds them.
+     */
+    this.publishBuild = this.contentVersion === null ? (options === null || options === void 0 ? void 0 : options.publishBuild) ?? null : null;
     this.mirrorsSourceFiles = git !== null || this.projectSource !== null;
   }
   /**
@@ -10127,6 +10503,22 @@ class ValOpsHttp extends ValOps {
         } : {})
       };
     }
+    /*
+     * A content version sits where the publish that made it does: its job,
+     * which content places exactly, or its commit, once nothing else says.
+     */
+    if (this.contentVersion !== null) {
+      if (this.contentVersion.job !== null) {
+        return {
+          job: this.contentVersion.job
+        };
+      }
+      if (this.contentVersion.commit !== null) {
+        return {
+          commit: this.contentVersion.commit
+        };
+      }
+    }
     if (this.git) {
       return {
         branch: this.git.branch,
@@ -13387,6 +13779,9 @@ async function initHandlerOptions(route, opts, config) {
       ...(opts.proposal !== undefined ? {
         proposal: opts.proposal
       } : {}),
+      ...(opts.contentVersion !== undefined ? {
+        contentVersion: opts.contentVersion
+      } : {}),
       project: maybeValProject,
       valEnableRedirectUrl,
       valDisableRedirectUrl,
@@ -13465,6 +13860,9 @@ function createValOps(valModules, options) {
       } : {}),
       ...(options.proposal !== undefined ? {
         proposal: options.proposal
+      } : {}),
+      ...(options.contentVersion !== undefined ? {
+        contentVersion: options.contentVersion
       } : {})
     });
   }
@@ -23961,6 +24359,7 @@ exports.awaitValLoginConfirmation = awaitValLoginConfirmation;
 exports.checkRemoteRef = checkRemoteRef;
 exports.classifyJsonValuesOp = classifyJsonValuesOp;
 exports.compareWithCapturedReport = compareWithCapturedReport;
+exports.contentFromEnv = contentFromEnv;
 exports.createDefaultValFSHost = createDefaultValFSHost;
 exports.createFixPatch = createFixPatch;
 exports.createJsonEntryPathMap = createJsonEntryPathMap;
@@ -24016,6 +24415,7 @@ exports.handleVideosetMetadata = handleVideosetMetadata;
 exports.handleVideosetUploadRemote = handleVideosetUploadRemote;
 exports.initHandlerOptions = initHandlerOptions;
 exports.isExternalResult = isExternalResult;
+exports.layeredSnapshot = layeredSnapshot;
 exports.loadValModules = loadValModules;
 exports.ok = ok;
 exports.parsePersonalAccessTokenFile = parsePersonalAccessTokenFile;
@@ -24024,6 +24424,7 @@ exports.persistPersonalAccessToken = persistPersonalAccessToken;
 exports.planJsonValuesEntryExtraction = planJsonValuesEntryExtraction;
 exports.proposalFromEnv = proposalFromEnv;
 exports.proposalSnapshot = proposalSnapshot;
+exports.proposalSnapshotForReaders = proposalSnapshotForReaders;
 exports.readCapturedReport = readCapturedReport;
 exports.readPatchStore = readPatchStore;
 exports.rebaseContentOp = rebaseContentOp;