@valbuild/server 0.147.0 → 0.148.0

package/dist/{ValRouterCore-3fd3d444.cjs.dev.js → ValRouterCore-9bdaaf89.cjs.dev.js}

@@ -1,6 +1,5 @@
 'use strict';
 
-var buffer = require('buffer');
 var core = require('@valbuild/core');
 var internal = require('@valbuild/shared/internal');
 var z = require('zod');
@@ -928,6 +927,118 @@ async function validateJsonValuesEntries(schema, source, modulePath) {
   return res;
 }
 
+/**
+ * Bytes as text and back, without Node's `Buffer`.
+ *
+ * The request handlers run in a browser tab too (`@valbuild/server/browser`),
+ * and a browser has no `Buffer`. Importing npm's `buffer` instead is what broke
+ * the demo under `vite dev`: it is CommonJS, and a dependency the dev server
+ * did not see in its scan is served unconverted. So bytes are `Uint8Array`
+ * here, and these are the conversions `Buffer` used to do -- with the same
+ * answers, which `bytes.test.ts` checks against `Buffer` itself.
+ */
+
+/**
+ * The value of each character code, or -1 for one that is not base64. Both
+ * alphabets, because `Buffer.from(s, "base64")` takes either: `-` and `_` are
+ * the URL-safe spellings of `+` and `/`.
+ */
+const BASE64_VALUES = (() => {
+  const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const values = new Int16Array(128).fill(-1);
+  for (let i = 0; i < BASE64_ALPHABET.length; i++) {
+    values[BASE64_ALPHABET.charCodeAt(i)] = i;
+  }
+  values["-".charCodeAt(0)] = 62;
+  values["_".charCodeAt(0)] = 63;
+  return values;
+})();
+const PADDING = "=".charCodeAt(0);
+
+/**
+ * Decodes base64 the way `Buffer.from(base64, "base64")` does: either
+ * alphabet, padding optional, anything that is not base64 skipped, and
+ * decoding stops at the first `=`. A trailing partial group gives the whole
+ * bytes it holds.
+ *
+ * `atob` first, because it is native and this is called with whole uploads;
+ * it agrees with `Buffer` on everything it accepts, and refuses the rest (the
+ * URL-safe alphabet, stray characters, `=` in the middle), which then goes the
+ * slow way.
+ */
+function base64ToBytes(base64) {
+  let binary;
+  try {
+    binary = atob(base64);
+  } catch {
+    return lenientBase64ToBytes(base64);
+  }
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function lenientBase64ToBytes(base64) {
+  const bytes = new Uint8Array(Math.floor(base64.length * 3 / 4));
+  let length = 0;
+  let bits = 0;
+  let bitCount = 0;
+  for (let i = 0; i < base64.length; i++) {
+    const code = base64.charCodeAt(i);
+    if (code === PADDING) break;
+    const value = code < 128 ? BASE64_VALUES[code] : -1;
+    if (value < 0) continue;
+    bits = (bits << 6 | value) & 0xffffff;
+    bitCount += 6;
+    if (bitCount >= 8) {
+      bitCount -= 8;
+      bytes[length++] = bits >> bitCount & 0xff;
+    }
+  }
+  return bytes.subarray(0, length);
+}
+
+/**
+ * How many bytes go to `String.fromCharCode` at once: it takes them as
+ * arguments, and an engine has a limit on how many a call may have.
+ */
+const CHUNK = 0x8000;
+
+/**
+ * `Buffer.from(bytes).toString("base64")`: padded, standard alphabet.
+ *
+ * Through `btoa`, which is native, rather than building the string here: that
+ * was five times slower, and this is called with whole files. Node is still
+ * faster with `Buffer`, which is why `ValServerPlatform.bytesToBase64` exists
+ * for the paths that encode every file of a publish.
+ */
+function bytesToBase64(bytes) {
+  const binary = [];
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    // `Reflect.apply` rather than a spread, which copies the chunk into an
+    // argument list first and is four times slower.
+    const chunk = Reflect.apply(String.fromCharCode, null, bytes.subarray(i, i + CHUNK));
+    binary.push(chunk);
+  }
+  return btoa(binary.join(""));
+}
+
+/** `Buffer.from(text, "utf8")`. */
+function utf8ToBytes(text) {
+  return new TextEncoder().encode(text);
+}
+
+/**
+ * `Buffer.from(bytes).toString("utf8")`. `ignoreBOM` because `Buffer` keeps a
+ * leading byte order mark, where a `TextDecoder` drops it by default.
+ */
+function bytesToUtf8(bytes) {
+  return new TextDecoder("utf-8", {
+    ignoreBOM: true
+  }).decode(bytes);
+}
+
 /**
  * Does saving this commit upload a file to Val's remote host?
  *
@@ -1342,7 +1453,8 @@ function isHlsPlaylistPath(filePath) {
  * patch's to read. Generic over the patch id so it asks for exactly the one
  * method it uses, and a test can hand it a plain object.
  */
-async function readCommittedBinaryFiles(ops, descriptors) {
+async function readCommittedBinaryFiles(ops, descriptors, /** `ValServerPlatform.bytesToBase64`, which is faster in Node. */
+encode = bytesToBase64) {
   const files = {};
   const unread = [];
   await Promise.all(Object.entries(descriptors).map(async ([filePath, {
@@ -1354,7 +1466,7 @@ async function readCommittedBinaryFiles(ops, descriptors) {
       console.error("Could not read a committed file", filePath, error);
       return null;
     });
-    if (bytes === null) unread.push(filePath);else files[filePath] = bytes.toString("base64");
+    if (bytes === null) unread.push(filePath);else files[filePath] = encode(bytes);
   }));
   return {
     files,
@@ -1521,10 +1633,537 @@ function computePatchesToDrop(prepared) {
   return dropped;
 }
 
-/*
- * Imported rather than global: under Node this is the built-in, and in a
- * browser (the demo, `@valbuild/server/browser`) the `buffer` package.
+function getFileExt(filePath) {
+  // NOTE: We do not import the path module. This code is copied in different projects. We want the same implementation and which means that this might running in browser where path is not available).
+  return filePath.split(".").pop() || "";
+}
+
+/**
+ * Does the host a platform ref names still serve the project the ref names?
+ *
+ * A ref served by the platform loader names the project's host at the time
+ * the file was added: `https://www.acme.no/_val/file/p/3f9a2c1/…`. When the
+ * project drops `www.acme.no`, the bytes are still there, at
+ * `3f9a2c1.valstart.dev`, but every ref that names the old domain points at a
+ * host that no longer serves them. This is the question that finds those refs,
+ * and `rewriteRefHost` is what the fix (`remote:rewrite-host`) does about it.
+ * See valbuild/home `docs/remote-files-on-platform.md`, "Rewriting refs after a
+ * domain is removed", and `docs/plans/studio-validate.md`, step 6.
+ *
+ * Asked of the host itself (`GET <host>/_val/project`), not of content: the
+ * host's answer covers DNS, the certificate and the loader's mapping in one,
+ * it needs no credential, and it works for a ref that names a project other
+ * than this one -- a project seeded from a template has refs naming the
+ * template's.
+ */
+
+/** The domain every platform project is always served at, by its public id. */
+const PLATFORM_SITES_DOMAIN = "valstart.dev";
+
+/** What a platform ref's host part ends with. */
+const PLATFORM_PREFIX = "/_val";
+
+/**
+ * The host every platform ref of `publicProjectId` can always be pointed at:
+ * `<public id>.valstart.dev` is permanent (decision 4 of the remote-files
+ * plan), and the loader serves a project's files there whatever else it has.
+ */
+function fallbackRemoteHost(publicProjectId) {
+  return `https://${publicProjectId}.${PLATFORM_SITES_DOMAIN}${PLATFORM_PREFIX}`;
+}
+
+/**
+ * Only a platform ref is asked about. `remote.val.build` is not a platform
+ * host and is not going away, and a ref already on the project's own
+ * `valstart.dev` address is on the fallback, which always serves it.
+ */
+function needsHostCheck(remoteHost, projectId) {
+  return remoteHost.endsWith(PLATFORM_PREFIX) && remoteHost !== fallbackRemoteHost(projectId);
+}
+
+/** `ref` with its host part replaced, and everything else as it was. */
+function rewriteRefHost(ref, remoteHost) {
+  const parsed = core.Internal.remote.splitRemoteRef(ref);
+  if (parsed.status === "error") {
+    return null;
+  }
+  return core.Internal.remote.createRemoteRef(remoteHost, {
+    publicProjectId: parsed.projectId,
+    coreVersion: parsed.version,
+    bucket: parsed.bucket,
+    validationHash: parsed.validationHash,
+    fileHash: parsed.fileHash,
+    filePath: parsed.filePath
+  });
+}
+
+/**
+ * - `serves`: the host answered for the project the ref names.
+ * - `other-project`: it answered, for another one -- the domain was moved to
+ *   a different project, and decision 5 means it will not serve these files.
+ * - `no-site`: it answered, but serves no project at all (the loader's 404 for
+ *   a domain nobody has mapped any more).
+ * - `unreachable`: no answer. A domain whose DNS was removed looks like this,
+ *   and so does a host that is down for a minute, which is why the row says
+ *   which it saw.
+ */
+
+const ASK_TIMEOUT_MS = 8_000;
+
+/** `GET <host>/_val/project`, answered by the platform loader. */
+const askHostProject = async remoteHost => {
+  try {
+    const res = await fetch(`${remoteHost}/project`, {
+      signal: AbortSignal.timeout(ASK_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      return {
+        status: "no-site",
+        httpStatus: res.status
+      };
+    }
+    const body = await res.json();
+    if (typeof body === "object" && body !== null && "publicProjectId" in body && typeof body.publicProjectId === "string") {
+      return {
+        status: "answered",
+        publicProjectId: body.publicProjectId
+      };
+    }
+    return {
+      status: "no-site",
+      httpStatus: res.status
+    };
+  } catch (err) {
+    return {
+      status: "unreachable",
+      reason: err instanceof Error && err.name === "TimeoutError" ? `No answer within ${ASK_TIMEOUT_MS / 1000} s` : err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+};
+
+/**
+ * Hosts that answered for a project, and when: one question per host, not per
+ * ref, and not again for a few minutes. Only a "serves" is kept, for the same
+ * reason `remoteFileCheck` keeps only "found": a host that stopped serving has
+ * to be noticed, and one that did not answer has to be asked again.
+ */
+const SERVES_FOR_MS = 5 * 60_000;
+const servesAt = new Map();
+async function hostServes(remoteHost, projectId, ask = askHostProject) {
+  const key = `${remoteHost} ${projectId}`;
+  const at = servesAt.get(key);
+  if (at !== undefined && Date.now() - at < SERVES_FOR_MS) {
+    return {
+      status: "serves"
+    };
+  }
+  const answer = await ask(remoteHost);
+  if (answer.status !== "answered") {
+    return answer;
+  }
+  if (answer.publicProjectId !== projectId) {
+    return {
+      status: "other-project",
+      publicProjectId: answer.publicProjectId
+    };
+  }
+  servesAt.set(key, Date.now());
+  return {
+    status: "serves"
+  };
+}
+
+/**
+ * `ask`, asking each host once for as long as the returned function is kept:
+ * one check, not the life of the server. A check walks its refs in order, so
+ * without it every ref on a host that does not answer waits out its own
+ * timeout -- 150 images on a dead domain is 20 minutes. Kept per check rather
+ * than in {@link hostServes}'s cache because a host that did not answer has
+ * to be asked again by the next one.
+ */
+function askOncePerHost(ask = askHostProject) {
+  const answers = new Map();
+  return remoteHost => {
+    let answer = answers.get(remoteHost);
+    if (answer === undefined) {
+      answer = ask(remoteHost);
+      answers.set(remoteHost, answer);
+    }
+    return answer;
+  };
+}
+
+/** `www.acme.no`, from `https://www.acme.no/_val`: how a person names a host. */
+function hostNameOfRemoteHost(remoteHost) {
+  try {
+    return new URL(remoteHost).host;
+  } catch {
+    return remoteHost;
+  }
+}
+
+/**
+ * Where a platform ref has to move to, when its host no longer serves the
+ * project it names; `undefined` when it does not have to (or is not a
+ * platform ref). `why` and `to` are for the caller's sentence: what can be
+ * done about it differs by caller (a Studio **Fix**, `val validate --fix`, or
+ * nothing yet).
+ */
+async function movedRemoteHost(ref, ask) {
+  const parsed = core.Internal.remote.splitRemoteRef(ref);
+  if (parsed.status === "error" || !needsHostCheck(parsed.remoteHost, parsed.projectId)) {
+    return undefined;
+  }
+  const serves = await hostServes(parsed.remoteHost, parsed.projectId, ask);
+  // Only an answer that says so moves a ref: the host serves another
+  // project, or the loader says it serves none (its 404 for a domain nobody
+  // maps). A host that did not answer, or answered 5xx, may be down for a
+  // minute -- and a moved ref does not move back, so rewriting on that would
+  // take a site's images off its own domain for good over one blip. Those are
+  // left to the existence check, which reports the host once with Try again.
+  if (serves.status === "serves" || serves.status === "unreachable" || serves.status === "no-site" && serves.httpStatus !== 404) {
+    return undefined;
+  }
+  const target = fallbackRemoteHost(parsed.projectId);
+  const moved = rewriteRefHost(ref, target);
+  if (moved === null) {
+    return undefined;
+  }
+  const from = hostNameOfRemoteHost(parsed.remoteHost);
+  return {
+    ref: moved,
+    why: serves.status === "other-project" ? `${from} now serves another project, so this file is not shown from there` : `${from} no longer serves this project, so this file is not shown from there`,
+    to: hostNameOfRemoteHost(target)
+  };
+}
+
+/**
+ * Where else a ref's file can be downloaded from: the same file on the
+ * project's own `valstart.dev` address, for a platform ref on any other host.
+ * `null` when there is nowhere else -- a `remote.val.build` ref, or one already
+ * on the fallback. See valbuild/home `docs/remote-files-on-platform.md`,
+ * "Tooling: the fallback".
  */
+function fallbackRefOf(ref) {
+  const parsed = core.Internal.remote.splitRemoteRef(ref);
+  if (parsed.status === "error" || !needsHostCheck(parsed.remoteHost, parsed.projectId)) {
+    return null;
+  }
+  return rewriteRefHost(ref, fallbackRemoteHost(parsed.projectId));
+}
+
+/**
+ * Does the host a remote ref names still serve it?
+ *
+ * `found` and `missing` are the host's answer. `unreachable` is no answer at
+ * all — a timeout, a refused connection, a 5xx — and says nothing about the
+ * file, only about the host.
+ */
+
+/**
+ * How the remote check reaches the network: what it asks a host about a file,
+ * and which project a platform host serves. Both default to the real thing;
+ * tests replace them.
+ */
+
+const HEAD_TIMEOUT_MS = 8_000;
+
+/**
+ * A HEAD, falling back to the first byte of a GET for a host that does not
+ * answer HEAD (405, 501): either way no file is downloaded to learn that it is
+ * there.
+ */
+const headRemoteFile = async url => {
+  const ask = async init => fetch(url, {
+    ...init,
+    redirect: "follow",
+    signal: AbortSignal.timeout(HEAD_TIMEOUT_MS)
+  });
+  try {
+    let res = await ask({
+      method: "HEAD"
+    });
+    if (res.status === 405 || res.status === 501) {
+      var _res$body;
+      res = await ask({
+        method: "GET",
+        headers: {
+          Range: "bytes=0-0"
+        }
+      });
+      await ((_res$body = res.body) === null || _res$body === void 0 ? void 0 : _res$body.cancel());
+    }
+    if (res.ok) {
+      return {
+        status: "found"
+      };
+    }
+    if (res.status === 404 || res.status === 410) {
+      return {
+        status: "missing",
+        httpStatus: res.status
+      };
+    }
+    return {
+      status: "unreachable",
+      reason: `HTTP ${res.status}`
+    };
+  } catch (err) {
+    return {
+      status: "unreachable",
+      reason: describeFetchError(err)
+    };
+  }
+};
+function describeFetchError(err) {
+  if (!(err instanceof Error)) {
+    return "Unknown error";
+  }
+  if (err.name === "TimeoutError") {
+    return `No answer within ${HEAD_TIMEOUT_MS / 1000} s`;
+  }
+  // undici puts what actually went wrong (ENOTFOUND, ECONNREFUSED) on `cause`.
+  const cause = err.cause;
+  if (cause instanceof Error) {
+    return `${err.message}: ${cause.message}`;
+  }
+  return err.message;
+}
+
+/**
+ * Refs a host has served, and when.
+ *
+ * So that pressing **Check again**, or opening a second module that uses the
+ * same images, does not ask about every file again. Kept for minutes, not for
+ * the life of the process: a ref is content-addressed, so its answer only
+ * changes when its host stops serving it -- which is exactly what this check
+ * is for, and a server that remembered "found" forever would never report a
+ * host that went down after it was first asked. Only `found` is kept. A host
+ * that did not answer is asked again on the next check, which is what makes
+ * **Try again** mean something.
+ */
+const FOUND_FOR_MS = 5 * 60_000;
+const foundAt = new Map();
+function wasFound(ref) {
+  const at = foundAt.get(ref);
+  return at !== undefined && Date.now() - at < FOUND_FOR_MS;
+}
+function markFound(ref) {
+  foundAt.set(ref, Date.now());
+}
+
+/** A host that did not serve the refs of a module it was asked about. */
+
+const textEncoder = new TextEncoder();
+
+/**
+ * The remote half of the Studio's full check, for one module's remote values.
+ *
+ * Four questions, cheapest first, and a ref stops at the first one it fails:
+ *
+ * 1. **Is it a ref at all?** `splitRemoteRef` parses it.
+ * 2. **Does the ref agree with what is recorded about it?** A ref carries a
+ *    hash of the schema's options, the file's extension and its width, height
+ *    and mime type. When the value or the schema changed and the ref did not,
+ *    the ref is stale, and **Fix** (`image:check-remote`) re-reads the file and
+ *    writes the ref it should have. Computed with the ref's OWN core version:
+ *    the CLI also re-derives every ref after a Val upgrade, and listing every
+ *    remote image in the project after each upgrade would bury the rows that
+ *    matter. Nothing here downloads.
+ * 3. **Does its host still serve its project?** Only for a platform ref
+ *    (`…/_val/file/…`) that is not on the project's own `valstart.dev`
+ *    address: one `GET <host>/_val/project` per host. A host that dropped the
+ *    project gets a **Fix** (`remote:rewrite-host`) that points the ref at
+ *    `<public id>.valstart.dev`. See `remoteHostCheck.ts`.
+ * 4. **Does the host have it?** A HEAD.
+ *
+ * Neither host question is asked of a ref whose bytes are in a pending patch,
+ * which the host will not have until publish: there the question is whether
+ * the patch still has them.
+ */
+async function checkRemoteFiles(input) {
+  const head = input.head ?? headRemoteFile;
+  const askHostProject = askOncePerHost(input.askHostProject);
+  const errors = {};
+  const addError = (sourcePath, error) => {
+    errors[sourcePath] = (errors[sourcePath] ?? []).concat(error);
+  };
+
+  /** Refs still to ask a host about, by host. */
+  const toAsk = new Map();
+  const sorted = Object.entries(input.remoteFiles).sort(([a], [b]) => a.localeCompare(b));
+  for (const [sourcePathS, value] of sorted) {
+    const sourcePath = sourcePathS;
+    const ref = value.path;
+    const parsed = core.Internal.remote.splitRemoteRef(ref);
+    if (parsed.status === "error") {
+      addError(sourcePath, {
+        message: `This is not an address Val can check: ${parsed.error}`,
+        value
+      });
+      continue;
+    }
+    let noun = "file";
+    if (!input.existenceOnly) {
+      const schema = input.schemaAt(sourcePath);
+      if ((schema === null || schema === void 0 ? void 0 : schema.type) !== "image" && (schema === null || schema === void 0 ? void 0 : schema.type) !== "file") {
+        continue;
+      }
+      noun = schema.type;
+      if (isStale(parsed, schema, value)) {
+        addError(sourcePath, {
+          message: `The address of this ${schema.type} does not match what is recorded about it, so it may be served with the wrong size or type.`,
+          value,
+          fixes: [schema.type === "image" ? "image:check-remote" : "file:check-remote"]
+        });
+        continue;
+      }
+    }
+    const pending = await input.pendingBytes(ref);
+    if (pending === "present") {
+      continue;
+    }
+    if (pending === "missing") {
+      addError(sourcePath, {
+        message: `This ${noun} is in your unpublished changes, but its file is not. Choose the ${noun} again.`,
+        value
+      });
+      continue;
+    }
+    // Asked after the pending check: a ref whose bytes are still in a patch
+    // is the key those bytes are stored under, and repointing it would cut
+    // it off from them.
+    const moved = await movedRemoteHost(ref, askHostProject);
+    if (moved) {
+      addError(sourcePath, input.existenceOnly ? {
+        // A directory's key: the fields picking from it hold the same
+        // ref, and would have to follow. Not built yet.
+        message: `${moved.why}. Pointing a file in a media directory at ${moved.to} is not something the Studio can do yet.`,
+        value
+      } : {
+        message: `${moved.why}. Fix points it at ${moved.to}, which always serves it.`,
+        value,
+        fixes: ["remote:rewrite-host"]
+      });
+      continue;
+    }
+    if (wasFound(ref)) {
+      continue;
+    }
+    const refs = toAsk.get(parsed.remoteHost) ?? [];
+    refs.push({
+      sourcePath,
+      ref,
+      published: input.isPublished(sourcePath, ref)
+    });
+    toAsk.set(parsed.remoteHost, refs);
+  }
+  const hosts = [];
+  await Promise.all([...toAsk.entries()].map(async ([host, refs]) => {
+    const problem = await askHost(host, refs, input.sampleByHost, head);
+    if (problem.host) {
+      hosts.push(problem.host);
+    }
+    for (const {
+      sourcePath,
+      error
+    } of problem.refErrors) {
+      addError(sourcePath, error);
+    }
+  }));
+  hosts.sort((a, b) => a.host.localeCompare(b.host));
+  return {
+    errors,
+    hosts
+  };
+}
+
+/**
+ * One host's refs, asked one at a time.
+ *
+ * In order rather than all at once: a host that does not answer is reported
+ * after the FIRST timeout, not after one timeout per image. A host that
+ * answers "missing" for one ref is still asked about the next, since a file
+ * that is gone is a fact about that file.
+ */
+async function askHost(host, refs, sampleByHost, head) {
+  const vouchable = sampleByHost ? refs.filter(r => r.published) : [];
+  const individually = sampleByHost ? refs.filter(r => !r.published) : refs;
+  const allPaths = refs.map(r => r.sourcePath);
+  const refErrors = [];
+  if (vouchable.length > 0) {
+    const sample = vouchable[0];
+    const answer = await head(sample.ref);
+    if (answer.status === "found") {
+      for (const r of vouchable) {
+        markFound(r.ref);
+      }
+    } else {
+      // In a managed project a published ref cannot break on its own, so the
+      // sample's answer is the host's: one row, every ref on it.
+      return {
+        host: {
+          host,
+          status: answer.status,
+          details: detailsOf(sample.ref, answer),
+          sourcePaths: allPaths
+        },
+        refErrors
+      };
+    }
+  }
+  for (const r of individually) {
+    const answer = await head(r.ref);
+    if (answer.status === "found") {
+      markFound(r.ref);
+    } else if (answer.status === "missing") {
+      refErrors.push({
+        sourcePath: r.sourcePath,
+        error: {
+          message: `The file is not at its address: ${hostName(host)} answered ${answer.httpStatus}.`
+        }
+      });
+    } else {
+      return {
+        host: {
+          host,
+          status: "unreachable",
+          details: detailsOf(r.ref, answer),
+          sourcePaths: allPaths
+        },
+        refErrors
+      };
+    }
+  }
+  return {
+    refErrors
+  };
+}
+function detailsOf(ref, answer) {
+  return `HEAD ${ref}\n→ ${answer.status === "missing" ? `${answer.httpStatus}` : answer.status === "unreachable" ? answer.reason : "200"}`;
+}
+
+/** `www.acme.no`, from `https://www.acme.no`: how a person names a host. */
+function hostName(host) {
+  try {
+    return new URL(host).host;
+  } catch {
+    return host;
+  }
+}
+function isStale(parsed, schema, value) {
+  // The hash covers only these of what was recorded (`getValidationBasis`):
+  // `alt` and `hotspot` are the editor's, and change no byte.
+  const metadata = {
+    width: value.width,
+    height: value.height,
+    mimeType: value.mimeType
+  };
+  const expected = core.Internal.remote.getValidationHash(parsed.version, schema, getFileExt(parsed.filePath), metadata, parsed.fileHash, textEncoder);
+  return expected !== parsed.validationHash;
+}
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
 const jsonOps = new patch.JSONOps();
 /**
  * How many `.jsonValues()` entry files a whole-record write reads at a time.
@@ -2565,7 +3204,14 @@ class ValOps {
   }
 
   // #region validateSources
-  async validateSources(schemas, sources, patchesByModule) {
+  async validateSources(schemas, sources, patchesByModule,
+  /**
+   * Validate only these modules. The snapshot the cross-module checks read
+   * (a keyOf's keys, a route, a set's directory) is still built from every
+   * module, which is what makes checking one module at a time give the same
+   * answer for it as checking them all. Wins over `patchesByModule`.
+   */
+  onlyModules) {
     const errors = {};
     const files = {};
     const remoteFiles = {};
@@ -2598,7 +3244,18 @@ class ValOps {
         }
       }
     }
-    const modulePathsToValidate = patchesByModule && Object.keys(patchesByModule);
+    const addModuleError = (path, sourcePath, validationError) => {
+      if (!errors[path]) {
+        errors[path] = {
+          validations: {}
+        };
+      }
+      if (!errors[path].validations[sourcePath]) {
+        errors[path].validations[sourcePath] = [];
+      }
+      errors[path].validations[sourcePath].push(validationError);
+    };
+    const modulePathsToValidate = onlyModules ?? (patchesByModule && Object.keys(patchesByModule));
     for (const [pathS, schema] of entries) {
       if (modulePathsToValidate && !modulePathsToValidate.includes(pathS)) {
         continue;
@@ -2627,15 +3284,35 @@ class ValOps {
       } = await validateJsonValuesEntries(schema, source, path);
       for (const [sourcePathS, entryErrors] of Object.entries(jsonValuesErrors)) {
         const sourcePath = sourcePathS;
-        if (!errors[path]) {
-          errors[path] = {
-            validations: {}
-          };
-        }
-        if (!errors[path].validations[sourcePath]) {
-          errors[path].validations[sourcePath] = [];
+        for (const entryError of entryErrors) {
+          // An entry's errors get the same project-wide resolution as every
+          // other module's. Added raw, every keyOf and route in a
+          // `.jsonValues()` record was reported as unresolved -- 240 of them in
+          // `examples/next`'s kb.val.ts, none real.
+          if (internal.isSchemaSourceFixError(entryError)) {
+            const resolved = internal.resolveSchemaSourceFixForError(entryError, snapshot);
+            if (!resolved || resolved.status !== "remaining") {
+              continue;
+            }
+            addModuleError(path, sourcePath, resolved.error);
+            continue;
+          }
+          // "Not yet compared with its bytes" is a request, not an error, and
+          // for an entry it cannot be answered here: `validateFiles` resolves a
+          // file's schema through the module's source, which for a
+          // `.jsonValues()` record holds markers rather than the entry. The
+          // publish gate ignores it anyway (`partitionValidationErrors`).
+          //
+          // A remote file's "not yet checked against its host" is the same
+          // request, for the same reason: `validateRemoteFiles` and its fix
+          // resolve the path through the module's source too. Added as an
+          // error, every remote image in an entry was a row on the Validate
+          // page whose Fix could not find it.
+          if (isOnlyFileCheckValidationError(entryError) || isOnlyRemoteCheckValidationError(entryError)) {
+            continue;
+          }
+          addModuleError(path, sourcePath, entryError);
         }
-        errors[path].validations[sourcePath].push(...entryErrors);
       }
       if (res === false) {
         continue;
@@ -2713,9 +3390,64 @@ class ValOps {
       remoteFiles
     };
   }
-  async validateRemoteFiles(schemas, sources, remoteFiles) {
-    // TODO: Implement
-    return {};
+
+  /**
+   * The remote values `validateSources` set aside, checked: is each ref
+   * sound, and does its host serve it. See `checkRemoteFiles`.
+   *
+   * `fileLastUpdatedByPatchId` names the refs whose bytes are still in a
+   * pending patch, which the host will not have until publish.
+   */
+  async validateRemoteFiles(schemas, sources, remoteFiles, fileLastUpdatedByPatchId = {}, network = {}) {
+    const sampleByHost = this.sourceMode() === "managed";
+    // Only a managed project vouches for one published ref with another, so
+    // only it needs to know which refs are published.
+    const baseSources = sampleByHost ? (await this.getSources()).sources : undefined;
+    const valueAt = (sourcePath, from) => {
+      const [moduleFilePath, modulePath] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
+      const schema = schemas[moduleFilePath];
+      if (!schema || from[moduleFilePath] === undefined) {
+        return undefined;
+      }
+      try {
+        return core.Internal.resolvePath(modulePath, from[moduleFilePath], schema["executeSerialize"]());
+      } catch {
+        return undefined;
+      }
+    };
+    return checkRemoteFiles({
+      remoteFiles,
+      sampleByHost,
+      ...network,
+      schemaAt: sourcePath => {
+        var _valueAt;
+        return (_valueAt = valueAt(sourcePath, sources)) === null || _valueAt === void 0 ? void 0 : _valueAt.schema;
+      },
+      isPublished: (sourcePath, ref) => {
+        var _valueAt2;
+        if (!baseSources) {
+          return false;
+        }
+        const published = (_valueAt2 = valueAt(sourcePath, baseSources)) === null || _valueAt2 === void 0 ? void 0 : _valueAt2.source;
+        return typeof published === "object" && published !== null && "path" in published && published.path === ref;
+      },
+      pendingBytes: this.pendingBytesOf(fileLastUpdatedByPatchId)
+    });
+  }
+
+  /**
+   * Is a remote file's bytes in a pending patch? `not-pending` when no patch
+   * wrote it; `missing` when one did and its bytes are not there.
+   */
+  pendingBytesOf(fileLastUpdatedByPatchId) {
+    return async ref => {
+      const fromPatch = fileLastUpdatedByPatchId[ref];
+      if (!fromPatch) {
+        return "not-pending";
+      }
+      const bytes = await this.getBase64EncodedBinaryFileFromPatch(ref, fromPatch.patchId, fromPatch.remote);
+      return bytes === null ? "missing" : "present";
+    };
   }
 
   // #region validateFiles
@@ -2787,7 +3519,9 @@ class ValOps {
       if (metadataErrors && metadataErrors.length > 0) {
         return {
           [sourcePath]: metadataErrors.map(e => ({
-            message: e.message,
+            // Which file: "File not found" on its own names nothing, and the
+            // row it is shown on is the field, not the file.
+            message: `${e.message}: ${filePath}`,
             value: {
               filePath,
               patchId: (fileData === null || fileData === void 0 ? void 0 : fileData.patchId) ?? null
@@ -3836,7 +4570,7 @@ class ValOps {
    * override it.
    */
   async saveBinaryFileFromPatch(filePath, parentRef, patchId, bytes, mimeType, type, metadata) {
-    return this.saveBase64EncodedBinaryFileFromPatch(filePath, parentRef, patchId, `data:${mimeType};base64,${bytes.toString("base64")}`, type, metadata);
+    return this.saveBase64EncodedBinaryFileFromPatch(filePath, parentRef, patchId, `data:${mimeType};base64,${bytesToBase64(bytes)}`, type, metadata);
   }
   /**
    * A file's bytes as something a `Range` request can be answered from
@@ -3900,6 +4634,10 @@ class ValOps {
 
   // #endregion history
 }
+function isOnlyRemoteCheckValidationError(validationError) {
+  const fixes = validationError.fixes ?? [];
+  return fixes.length > 0 && fixes.every(f => f === "image:check-remote" || f === "file:check-remote");
+}
 function isOnlyFileCheckValidationError(validationError) {
   var _validationError$fixe9;
   if ((_validationError$fixe9 = validationError.fixes) !== null && _validationError$fixe9 !== void 0 && _validationError$fixe9.every(f => f === "file:check-metadata" || f === "image:check-metadata")) {
@@ -4058,15 +4796,16 @@ function createMetadataFromBuffer(type, mimeType, buffer) {
     metadata
   };
 }
-function bufferFromDataUrl(dataUrl) {
+function bufferFromDataUrl(dataUrl, /** Node passes `Buffer`'s, which is faster: this is a whole upload. */
+decodeBase64 = base64ToBytes) {
   let base64Data;
   const base64Index = dataUrl.indexOf(";base64,");
   if (base64Index > -1) {
     base64Data = dataUrl.slice(base64Index + ";base64,".length);
   }
   if (base64Data) {
-    return buffer.Buffer.from(base64Data, "base64" // TODO: why does it not work with base64url?
-    );
+    // TODO: why does it not work with base64url?
+    return decodeBase64(base64Data);
   }
 }
 
@@ -4217,7 +4956,7 @@ async function resolveJsonEntriesAtCommit(ops, commitSha, affectedFiles) {
       continue;
     }
     try {
-      entries[gitPath] = JSON.parse(res.value.toString("utf-8"));
+      entries[gitPath] = JSON.parse(bytesToUtf8(res.value));
     } catch (err) {
       failures.push({
         kind: "file-unavailable",
@@ -4539,7 +5278,14 @@ const SettingsSchema = z.z.object({
   publicProjectId: z.z.string(),
   remoteFileBuckets: z.z.array(z.z.object({
     bucket: z.z.string()
-  }))
+  })),
+  /**
+   * The host a new remote file's ref names: the project's own address with
+   * `/_val` for a Hosted project whose files are in R2, `remote.val.build`
+   * otherwise. Absent from a content service that predates it, where every
+   * project's files are on `remote.val.build`.
+   */
+  remoteHost: z.z.string().optional()
 });
 async function getSettings(projectName, auth, /** Overrides {@link defaultHost}. See the note there for why this exists. */
 contentUrl) {
@@ -4715,11 +5461,6 @@ function mapStatus(status) {
   return 500;
 }
 
-/*
- * Imported rather than global: under Node this is the built-in, and in a
- * browser (the demo, `@valbuild/server/browser`) the `buffer` package.
- */
-
 /** What {@link ValServerOptions.publishOverride} is given. */
 
 /** What a publish reports back, in either shape. */
@@ -4730,6 +5471,18 @@ function mapStatus(status) {
  * have their own `dir` for any collection that wants somewhere else.
  */
 const FILES_DIRECTORY = "/public/val";
+
+/**
+ * `/validate` and `/validate/fix` on a platform without the full check (a
+ * server in a browser tab). 501: nothing the caller does makes it available,
+ * so the Studio offers no Try again.
+ */
+const studioValidationUnavailable = {
+  status: 501,
+  json: {
+    message: "Checking everything needs the project's files and Val's file hosts, and this Studio runs without them."
+  }
+};
 const ValServer = (valModules, options, callbacks, platform) => {
   var _options$git;
   const {
@@ -5133,6 +5886,82 @@ const ValServer = (valModules, options, callbacks, platform) => {
       };
     }
   };
+
+  /**
+   * What the Studio's full check reads: base plus the patches the caller is
+   * showing, as `/sources/~` resolves an explicit `patch_id` list -- including
+   * `draftOverlay`, so a module changed by a publish after this build is
+   * checked as the caller sees it, not as this build has it.
+   */
+  const studioCheckInput = async (cookies, moduleFilePath, patchIds) => {
+    const auth = getAuth(cookies);
+    if (auth.error) {
+      return {
+        status: 401,
+        json: {
+          message: auth.error
+        }
+      };
+    }
+    if (isHttpOps(serverOps) && !("id" in auth)) {
+      return {
+        status: 401,
+        json: {
+          message: "Unauthorized"
+        }
+      };
+    }
+    const moduleErrors = await serverOps.getModuleErrors();
+    if ((moduleErrors === null || moduleErrors === void 0 ? void 0 : moduleErrors.length) > 0) {
+      return {
+        status: 500,
+        json: {
+          message: "Val could not load this project's modules, so nothing can be checked. Check val.modules."
+        }
+      };
+    }
+    // An EXPLICITLY empty list is base, never "everything": `fetchPatches`
+    // reads an empty filter as no filter (see `/sources/~`).
+    let patchOps = patchIds !== undefined && patchIds.length === 0 ? {
+      patches: []
+    } : await serverOps.fetchPatches({
+      patchIds,
+      excludePatchOps: false
+    });
+    if ("error" in patchOps && patchOps.error) {
+      return "unauthorized" in patchOps && patchOps.unauthorized ? {
+        status: 401,
+        json: {
+          message: "Unauthorized"
+        }
+      } : {
+        status: 500,
+        json: {
+          message: "The unpublished changes could not be read, so nothing was checked."
+        }
+      };
+    }
+    patchOps = {
+      ...patchOps,
+      patches: draftOverlay(patchOps.patches, patchOps.commits)
+    };
+    const analysis = serverOps.analyzePatches(patchOps.patches);
+    const {
+      sources
+    } = await serverOps.getSourcesWithPatchesApplied({
+      ...analysis,
+      ...patchOps
+    });
+    return {
+      status: "ok",
+      input: {
+        moduleFilePath,
+        schemas: await serverOps.getSchemas(),
+        sources,
+        fileLastUpdatedByPatchId: analysis.fileLastUpdatedByPatchId
+      }
+    };
+  };
   return {
     "/draft/enable": {
       GET: async req => {
@@ -5483,7 +6312,10 @@ const ValServer = (valModules, options, callbacks, platform) => {
           json: {
             publicProjectId: settingsRes.data.publicProjectId,
             remoteFileBuckets: settingsRes.data.remoteFileBuckets,
-            coreVersion: core.Internal.VERSION.core || "unknown"
+            coreVersion: core.Internal.VERSION.core || "unknown",
+            ...(settingsRes.data.remoteHost !== undefined ? {
+              remoteHost: settingsRes.data.remoteHost
+            } : {})
           }
         };
       }
@@ -5764,6 +6596,92 @@ const ValServer = (valModules, options, callbacks, platform) => {
         };
       }
     },
+    "/validate": {
+      POST: async req => {
+        const checked = await studioCheckInput(req.cookies, req.body.moduleFilePath, req.body.patchIds);
+        if (checked.status !== "ok") {
+          return checked;
+        }
+        if (!platform.studioValidation) {
+          return studioValidationUnavailable;
+        }
+        const res = await platform.studioValidation.checkModuleForStudio(serverOps, checked.input);
+        switch (res.status) {
+          case "unknown-module":
+            return {
+              status: 404,
+              json: {
+                message: `There is no module '${req.body.moduleFilePath}' in this project.`
+              }
+            };
+          case "invalid-source":
+            return {
+              status: 200,
+              json: {
+                moduleFilePath: req.body.moduleFilePath,
+                errors: {},
+                invalidSource: res.message
+              }
+            };
+          case "ok":
+            return {
+              status: 200,
+              json: {
+                moduleFilePath: req.body.moduleFilePath,
+                errors: res.errors,
+                remoteHosts: res.remoteHosts
+              }
+            };
+        }
+      }
+    },
+    "/validate/fix": {
+      POST: async req => {
+        const checked = await studioCheckInput(req.cookies, req.body.moduleFilePath, req.body.patchIds);
+        if (checked.status !== "ok") {
+          return checked;
+        }
+        if (!platform.studioValidation) {
+          return studioValidationUnavailable;
+        }
+        const res = await platform.studioValidation.fixForStudio(serverOps, {
+          ...checked.input,
+          sourcePath: req.body.sourcePath,
+          fix: req.body.fix
+        });
+        switch (res.status) {
+          case "unknown-module":
+            return {
+              status: 404,
+              json: {
+                message: `There is no module '${req.body.moduleFilePath}' in this project.`
+              }
+            };
+          case "not-found":
+            return {
+              status: 404,
+              json: {
+                message: "This error is no longer there. Check the module again to see what is left."
+              }
+            };
+          case "not-in-studio":
+            return {
+              status: 400,
+              json: {
+                message: "This fix cannot be made from the Studio yet. Run `val validate --fix` in the project."
+              }
+            };
+          case "ok":
+            return {
+              status: 200,
+              json: {
+                patch: res.patch,
+                remainingErrors: res.remainingErrors
+              }
+            };
+        }
+      }
+    },
     "/external-urls/check": {
       POST: async req => {
         /*
@@ -6437,8 +7355,9 @@ const ValServer = (valModules, options, callbacks, platform) => {
           // TODO: send binary files validation errors
           if (query.validate_binary_files) {
             await serverOps.validateFiles(schemas, sourcesRes.sources, sourcesValidation.files);
-            // TODO : actually do something with this
-            await serverOps.validateRemoteFiles(schemas, sourcesRes.sources, sourcesValidation.remoteFiles);
+            // Remote files are not checked here: their check asks each host
+            // over the network, so it is the Studio's full check that runs it,
+            // one module at a time (`/validate`).
           }
         }
         const schemaSha = await serverOps.getSchemaSha();
@@ -6586,7 +7505,7 @@ const ValServer = (valModules, options, callbacks, platform) => {
             withJob: prepared,
             jobPatchIds: patchIds
           });
-          const build = serverOps.embedsSource() ? await buildSourcesOf(serverOps, patchIds, commit) : null;
+          const build = serverOps.embedsSource() ? await buildSourcesOf(platform, serverOps, patchIds, commit) : null;
           if (build !== null && "status" in build) return build;
           /*
            * A build of no commit says what Val source it holds instead, so
@@ -6618,7 +7537,7 @@ const ValServer = (valModules, options, callbacks, platform) => {
             buildable: build !== null
           });
         }
-        const built = await buildSourcesOf(serverOps, patchIds, commit);
+        const built = await buildSourcesOf(platform, serverOps, patchIds, commit);
         if ("status" in built) return built;
         const {
           split
@@ -6688,7 +7607,7 @@ const ValServer = (valModules, options, callbacks, platform) => {
          * and the selection on top. Only what the selection touched is saved,
          * so the proposal's save is the selection and nothing else.
          */
-        const built = await buildSourcesOf(serverOps, patchIds, commit, {
+        const built = await buildSourcesOf(platform, serverOps, patchIds, commit, {
           binaries: false
         });
         if ("status" in built) return built;
@@ -7233,7 +8152,7 @@ const ValServer = (valModules, options, callbacks, platform) => {
              * patch's to read. See `binaryFiles` on the route.
              */
             const managedBranch = serverOps.sourceMode() === "managed" ? serverOps.projectBranch() : null;
-            const committedBinaries = serverOps.sourceMode() === "managed" ? await readCommittedBinaryFiles(serverOps, preparedCommit.patchedBinaryFilesDescriptors) : null;
+            const committedBinaries = serverOps.sourceMode() === "managed" ? await readCommittedBinaryFiles(serverOps, preparedCommit.patchedBinaryFilesDescriptors, platform.bytesToBase64) : null;
             const commitToGit = () => serverOps.commit(preparedCommit, message, auth.id, FILES_DIRECTORY, undefined);
             /*
              * A host may publish somewhere other than the repository.
@@ -7893,7 +8812,7 @@ const ValServer = (valModules, options, callbacks, platform) => {
                 // wrap it in a data: URL, and hand that to a method whose first
                 // act was to unwrap it again - ceremony to satisfy a convention
                 // that no longer exists.
-                const bytes = buffer.Buffer.from(await binaryRes.arrayBuffer());
+                const bytes = new Uint8Array(await binaryRes.arrayBuffer());
                 const type = file.metadata.mimeType.startsWith("image/") ? "image" : "file";
                 const saveRes = await serverOps.saveBinaryFileFromPatch(file.filePath, req.body.parentRef, req.body.patchId, bytes, file.metadata.mimeType, type, file.metadata);
                 if (saveRes.error) {
@@ -8139,7 +9058,7 @@ const ValServer = (valModules, options, callbacks, platform) => {
         // TypeScript compiler. See `patch/ts/publishKit.ts`.
         const {
           getJsonEntryAtCommit
-        } = await Promise.resolve().then(function () { return require('./getJsonEntryAtCommit-e96beb9e.cjs.dev.js'); });
+        } = await Promise.resolve().then(function () { return require('./getJsonEntryAtCommit-64f67a50.cjs.dev.js'); });
         const res = await getJsonEntryAtCommit(serverOps, req.query.commit_sha, req.query.path, req.query.key);
         if (fp.result.isErr(res)) {
           return historyErrorResponse(res.error);
@@ -8247,11 +9166,11 @@ const ValServer = (valModules, options, callbacks, platform) => {
         // A DRAFT playlist names files that are drafts too, at URLs that only
         // resolve once published. See `rewriteDraftPlaylist`. Playlists are
         // small, so one is read whole to be rewritten.
-        const file = patchId && isHlsPlaylistPath(filePath) ? bufferReader(buffer.Buffer.from(rewriteDraftPlaylist((await opened.read(0, opened.size - 1)).toString("utf-8"), {
+        const file = patchId && isHlsPlaylistPath(filePath) ? bufferReader(utf8ToBytes(rewriteDraftPlaylist(bytesToUtf8(await opened.read(0, opened.size - 1)), {
           playlistPath: filePath,
           patchId,
           remote
-        }), "utf-8")) : opened;
+        }))) : opened;
         const headers = {
           // TODO: we could use ETag and return 304 instead
           // From the extension, published or draft: a `<video>` and an HLS
@@ -8291,7 +9210,7 @@ const ValServer = (valModules, options, callbacks, platform) => {
             body: bufferToReadableStream(slice)
           };
         }
-        const body = file.size === 0 ? buffer.Buffer.alloc(0) : await file.read(0, file.size - 1);
+        const body = file.size === 0 ? new Uint8Array(0) : await file.read(0, file.size - 1);
         return {
           status: 200,
           headers: {
@@ -8353,7 +9272,7 @@ function verifyCallbackReq(stateCookie, queryParams) {
 }
 function getStateFromCookie(stateCookie) {
   try {
-    const decoded = buffer.Buffer.from(stateCookie, "base64").toString("utf8");
+    const decoded = bytesToUtf8(base64ToBytes(stateCookie));
     const parsed = JSON.parse(decoded);
     if (!parsed) {
       return {
@@ -8405,7 +9324,7 @@ function getStateFromCookie(stateCookie) {
   }
 }
 function createStateCookie(state) {
-  return buffer.Buffer.from(JSON.stringify(state), "utf8").toString("base64");
+  return bytesToBase64(utf8ToBytes(JSON.stringify(state)));
 }
 const ValAppJwtPayload = z.z.object({
   sub: z.z.string(),
@@ -8688,7 +9607,7 @@ function getIsRemoteRequired(schemas) {
  * `split.archive` is the managed job's archive; a connected job's archive is
  * the push's, made from its own changes alone, by the caller.
  */
-async function buildSourcesOf(serverOps, patchIds, commit,
+async function buildSourcesOf(platform, serverOps, patchIds, commit,
 /**
  * Read the job's binary files back for a build. Off for a caller that only
  * commits what was prepared, which names the files rather than carrying them.
@@ -8754,7 +9673,7 @@ options = {
     jobPatchIds: patchIds
   });
   // Read now, while the job's changes still hold their files.
-  const binaries = options.binaries ? await readCommittedBinaryFiles(serverOps, split.archive.patchedBinaryFilesDescriptors) : {
+  const binaries = options.binaries ? await readCommittedBinaryFiles(serverOps, split.archive.patchedBinaryFilesDescriptors, platform.bytesToBase64) : {
     files: {},
     unread: []
   };
@@ -8869,11 +9788,6 @@ async function uploadRemoteFile(contentHost, project, bucket, fileHash, fileExt,
   };
 }
 
-function getFileExt(filePath) {
-  // NOTE: We do not import the path module. This code is copied in different projects. We want the same implementation and which means that this might running in browser where path is not available).
-  return filePath.split(".").pop() || "";
-}
-
 /**
  * One stored patch. Everything the ordered chain needs and nothing else.
  */
@@ -9574,7 +10488,11 @@ function createValRequestHandler(route, valServerPromise, convert, serveStatic)
       const method = (_req$method = req.method) === null || _req$method === void 0 ? void 0 : _req$method.toUpperCase();
       let route = null;
       let path = undefined;
-      for (const routeDef of Object.keys(internal.Api)) {
+      // An exact match wins over every prefix match, wherever it sits in
+      // `Api`: checked per key, in order, `/validate` took `/validate/fix`
+      // because it was declared first.
+      const exactRouteDef = Object.keys(internal.Api).find(routeDef => routeDef === reqApiRoutePath);
+      for (const routeDef of exactRouteDef ? [exactRouteDef] : Object.keys(internal.Api)) {
         if (routeDef === reqApiRoutePath) {
           route = routeDef;
           break;
@@ -9873,10 +10791,16 @@ exports.InMemoryPatchStore = InMemoryPatchStore;
 exports.ValOps = ValOps;
 exports.ValOpsMemory = ValOpsMemory;
 exports.ValServer = ValServer;
+exports.askOncePerHost = askOncePerHost;
 exports.bufferFromDataUrl = bufferFromDataUrl;
+exports.bytesToBase64 = bytesToBase64;
+exports.bytesToUtf8 = bytesToUtf8;
+exports.checkRemoteFiles = checkRemoteFiles;
 exports.classifyJsonValuesOp = classifyJsonValuesOp;
 exports.createMetadataFromBuffer = createMetadataFromBuffer;
 exports.createValRequestHandler = createValRequestHandler;
+exports.fallbackRefOf = fallbackRefOf;
+exports.fallbackRemoteHost = fallbackRemoteHost;
 exports.findNestedJsonValuesRecords = findNestedJsonValuesRecords;
 exports.formatPatchSourceError = formatPatchSourceError;
 exports.getFieldsForType = getFieldsForType;
@@ -9888,10 +10812,13 @@ exports.isHlsMasterPlaylist = isHlsMasterPlaylist;
 exports.isJsonValuesRootOp = isJsonValuesRootOp;
 exports.largestHlsVariant = largestHlsVariant;
 exports.mapHlsUris = mapHlsUris;
+exports.movedRemoteHost = movedRemoteHost;
+exports.needsHostCheck = needsHostCheck;
 exports.parseHlsMasterVariants = parseHlsMasterVariants;
 exports.posixPath = posixPath;
 exports.rebaseContentOp = rebaseContentOp;
 exports.resolveExistingJsonPath = resolveExistingJsonPath;
+exports.rewriteRefHost = rewriteRefHost;
 exports.sumHlsSegmentDurations = sumHlsSegmentDurations;
 exports.uploadRemoteFile = uploadRemoteFile;
 exports.validateJsonValuesEntries = validateJsonValuesEntries;