@valbuild/shared 0.121.0 → 0.122.0

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

@@ -901,6 +901,12 @@ function _asyncToGenerator(n) {
   };
 }
 
+/**
+ * JSON, recursively — the shape of a Source over the wire.
+ *
+ * Exported because history reads stored Sources back and needs the same
+ * definition; a second copy is a second thing to keep in step.
+ */
 var JSONValue = zod.z.lazy(function () {
   return zod.z.union([zod.z.string(), zod.z.number(), zod.z["boolean"](), zod.z["null"](), zod.z.array(JSONValue), zod.z.record(zod.z.string(), JSONValue)]);
 });
@@ -1279,7 +1285,26 @@ var SerializedRouteSchema = zod.z.object({
   readonly: zod.z["boolean"]().optional(),
   hidden: zod.z["boolean"]().optional()
 });
-var SerializedSchema = zod.z.union([SerializedStringSchema, SerializedLiteralSchema, SerializedBooleanSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedArraySchema, SerializedUnionSchema, SerializedRichTextSchema, SerializedRecordSchema, SerializedKeyOfSchema, SerializedRouteSchema, SerializedFileSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedColorSchema, SerializedCodeSchema, SerializedImageSchema]);
+
+// A settings module, and each section inside one, serialize as this - the
+// shape is recursive because `items` holds sections which are themselves
+// settings schemas. `s.settings()` never writes render/preview/customValidate
+// (see core/src/schema/settings.ts), but they are accepted here because they
+// are part of the declared type.
+var SerializedSettingsSchema = zod.z.lazy(function () {
+  return zod.z.object({
+    type: zod.z.literal("settings"),
+    render: FieldRender,
+    preview: zod.z.literal(true).optional(),
+    items: zod.z.record(zod.z.string(), SerializedSchema),
+    opt: zod.z["boolean"](),
+    customValidate: zod.z["boolean"]().optional(),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional(),
+    description: zod.z.string().optional()
+  });
+});
+var SerializedSchema = zod.z.union([SerializedStringSchema, SerializedLiteralSchema, SerializedBooleanSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedArraySchema, SerializedUnionSchema, SerializedRichTextSchema, SerializedRecordSchema, SerializedKeyOfSchema, SerializedRouteSchema, SerializedFileSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedColorSchema, SerializedCodeSchema, SerializedSettingsSchema, SerializedImageSchema]);
 
 var ValCommit = zod.z.object({
   commitSha: zod.z.string(),
@@ -1291,6 +1316,125 @@ var ValCommit = zod.z.object({
   commitMessage: zod.z.string().nullable()
 });
 
+/**
+ * The wire shapes for reading history.
+ *
+ * Here rather than in `@valbuild/server` because both sides of `/api/val` need
+ * them: the server builds these and the Studio parses them, and a second
+ * hand-written copy in the client is how the two drift.
+ *
+ * `HistoryError` is a closed union of everything that can go wrong
+ * reconstructing a commit - see `packages/server/src/history/HistoryError.ts`
+ * for what each one means. It travels as data rather than as a message because
+ * the Studio decides what to OFFER from it: a schema mismatch means "cannot
+ * restore this field", a missing source means "cannot restore this module at
+ * all", and a rendered string cannot be told apart.
+ */
+var HistoryError = zod.z.discriminatedUnion("kind", [zod.z.object({
+  kind: zod.z.literal("commit-not-found"),
+  commitSha: zod.z.string()
+}), zod.z.object({
+  kind: zod.z.literal("archive-unreadable"),
+  commitSha: zod.z.string(),
+  message: zod.z.string()
+}), zod.z.object({
+  kind: zod.z.literal("source-unavailable"),
+  moduleFilePath: zod.z.string()
+}), zod.z.object({
+  kind: zod.z.literal("schema-unreadable"),
+  moduleFilePath: zod.z.string(),
+  message: zod.z.string()
+}), zod.z.object({
+  kind: zod.z.literal("file-unavailable"),
+  gitPath: zod.z.string(),
+  message: zod.z.string()
+}), zod.z.object({
+  kind: zod.z.literal("not-supported-in-fs-mode")
+}), zod.z.object({
+  kind: zod.z.literal("transport"),
+  message: zod.z.string()
+})]);
+var HistoricalCommit = zod.z.object({
+  commitSha: zod.z.string(),
+  parentCommitSha: zod.z.string(),
+  clientCommitSha: zod.z.string(),
+  branch: zod.z.string(),
+  createdBranch: zod.z.string().nullable(),
+  creator: zod.z.string().nullable(),
+  message: zod.z.string().nullable(),
+  createdAt: zod.z.string(),
+  seqNum: zod.z.string(),
+  patchCount: zod.z.number(),
+  /** False for commits made before history was recorded. */
+  hasArchive: zod.z["boolean"]()
+});
+var FileChange = zod.z.union([zod.z.literal("added"), zod.z.literal("modified"), zod.z.literal("deleted")]);
+
+/**
+ * A binary file the commit touched - named, with a URL, and nothing fetched.
+ * Only an `<img src>` that mounts pays for the bytes.
+ */
+var BinaryFileRef = zod.z.object({
+  gitPath: zod.z.string(),
+  change: FileChange,
+  remote: zod.z["boolean"](),
+  url: zod.z.string()
+});
+var HistoricalModule = zod.z.object({
+  /** The module's data at this commit. Null if deleted, or unreadable. */
+  source: JSONValue.nullable(),
+  /**
+   * The schema at this commit, already validated against THIS Val.
+   *
+   * Null with a `schema-unreadable` failure means the stored schema came from a
+   * Val whose schema format this one does not know — expected, not damage.
+   */
+  schema: SerializedSchema.nullable(),
+  patchIds: zod.z.array(PatchId),
+  changedPaths: zod.z.array(zod.z.string()),
+  failures: zod.z.array(HistoryError)
+});
+var HistoricalPatchSet = zod.z.object({
+  commit: HistoricalCommit,
+  modules: zod.z.record(zod.z.string(), HistoricalModule),
+  patches: zod.z.array(zod.z.object({
+    patchId: PatchId,
+    moduleFilePath: zod.z.string(),
+    patch: zod.z.unknown(),
+    authorId: zod.z.string().nullable(),
+    createdAt: zod.z.string(),
+    baseSha: zod.z.string(),
+    coreVersion: zod.z.string()
+  })),
+  jsonEntries: zod.z.record(zod.z.string(), zod.z.unknown()),
+  binaryFiles: zod.z.array(BinaryFileRef),
+  warnings: zod.z.array(HistoryError)
+});
+/**
+ * Whether the historical value can be written back as the project stands.
+ *
+ * Computed in the Studio, not on the server: the verdict depends on the current
+ * source and the current schema, both of which the client already holds, and it
+ * runs against the same worker-thread validator that validates ordinary edits.
+ * The types stay here because they are what a restore preview hands to the UI.
+ *
+ * `blocked` carries its reasons so a refusal can name the field and say why,
+ * rather than being an unexplained disabled button.
+ */
+var RestoreVerdict = zod.z.union([zod.z.object({
+  status: zod.z.literal("restorable")
+}), zod.z.object({
+  status: zod.z.literal("blocked"),
+  reasons: zod.z.array(HistoryError)
+})]);
+var ModuleComparison = zod.z.object({
+  current: zod.z.unknown().nullable(),
+  /** Paths where the commit's result and the current source differ: what a
+   * restore would undo. */
+  changedVsCurrent: zod.z.array(zod.z.string()),
+  verdict: RestoreVerdict
+});
+
 var ModuleFilePath = zod.z.string().refine(function (_path) {
   return true;
 } // TODO: validation
@@ -1560,48 +1704,6 @@ var Api = {
       })
     }
   },
-  "/session": {
-    GET: {
-      req: {
-        cookies: {
-          val_session: zod.z.string().optional()
-        }
-      },
-      res: zod.z.union([zod.z.object({
-        status: zod.z.literal(200),
-        json: zod.z.object({
-          mode: zod.z.union([zod.z.literal("local"), zod.z.literal("proxy")]),
-          enabled: zod.z["boolean"]()
-        })
-      }), zod.z.object({
-        status: zod.z.union([
-        // TODO: Remove the ones we don't need.
-        zod.z.literal(400), zod.z.literal(401), zod.z.literal(403), zod.z.literal(404), zod.z.literal(500), zod.z.literal(501)]),
-        json: zod.z.object({
-          message: zod.z.string()
-        })
-      }), zod.z.object({
-        status: zod.z.literal(401),
-        json: zod.z.object({
-          message: zod.z.string(),
-          details: zod.z.union([zod.z.string(), zod.z.object({
-            reason: zod.z.string()
-          }), zod.z.object({
-            sub: zod.z.string(),
-            exp: zod.z.number(),
-            token: zod.z.string(),
-            org: zod.z.string(),
-            project: zod.z.string()
-          })])
-        })
-      }), zod.z.object({
-        status: zod.z.literal(500),
-        json: zod.z.object({
-          message: zod.z.string()
-        })
-      })])
-    }
-  },
   "/logout": {
     GET: {
       req: {
@@ -2393,6 +2495,144 @@ var Api = {
       })])
     }
   },
+  // #region history
+  //
+  // Reading the past. Split across three routes on purpose, because they cache
+  // differently: a reconstructed commit cannot change and is immutable
+  // forever, the comparison against current source changes with every edit, and
+  // a file at a fixed commit is immutable too. Folding them together would mean
+  // the cheapest thing dragging the most expensive one's cache headers down to
+  // no-store.
+  "/history/commits": {
+    GET: {
+      req: {
+        query: {
+          branch: onlyOneStringQueryParam,
+          limit: onlyOneIntQueryParam.optional(),
+          /** The previous page's `nextCursor`. */
+          cursor: onlyOneStringQueryParam.optional()
+        },
+        cookies: {
+          val_session: zod.z.string().optional()
+        }
+      },
+      res: zod.z.union([unauthorizedResponse, notFoundResponse, zod.z.object({
+        status: zod.z.literal(400),
+        json: GenericError.and(zod.z.object({
+          kind: zod.z.string().optional()
+        }))
+      }), zod.z.object({
+        status: zod.z.literal(500),
+        json: GenericError.and(zod.z.object({
+          kind: zod.z.string().optional()
+        }))
+      }), zod.z.object({
+        status: zod.z.literal(200),
+        json: zod.z.object({
+          commits: zod.z.array(HistoricalCommit),
+          nextCursor: zod.z.string().nullable()
+        })
+      })])
+    }
+  },
+  /**
+   * One commit, reconstructed. IMMUTABLE for a given sha - it says nothing
+   * about the current source or schema, which is what lets it be cached
+   * forever and what makes comparing many commits cheap.
+   */
+  "/history/commit": {
+    GET: {
+      req: {
+        query: {
+          commit_sha: onlyOneStringQueryParam
+        },
+        cookies: {
+          val_session: zod.z.string().optional()
+        }
+      },
+      res: zod.z.union([unauthorizedResponse, notFoundResponse, zod.z.object({
+        status: zod.z.literal(400),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(500),
+        json: GenericError.and(zod.z.object({
+          kind: zod.z.string().optional()
+        }))
+      }), zod.z.object({
+        status: zod.z.literal(200),
+        json: HistoricalPatchSet
+      })])
+    }
+  },
+  /**
+   * ONE module, as of a commit — including a commit that did not change it.
+   *
+   * `/history/commit` covers what a commit changed, which is the narrow case:
+   * navigate the history pane to anything else and there would be nothing to
+   * show. This answers "how did this module look at that point", which is the
+   * question someone comparing two panes is actually asking. Immutable for the
+   * same reason: what a commit left behind cannot change.
+   */
+  "/history/module": {
+    GET: {
+      req: {
+        query: {
+          commit_sha: onlyOneStringQueryParam,
+          module_file_path: onlyOneStringQueryParam
+        },
+        cookies: {
+          val_session: zod.z.string().optional()
+        }
+      },
+      res: zod.z.union([unauthorizedResponse, notFoundResponse, zod.z.object({
+        status: zod.z.literal(400),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(500),
+        json: GenericError.and(zod.z.object({
+          kind: zod.z.string().optional()
+        }))
+      }), zod.z.object({
+        status: zod.z.literal(200),
+        json: zod.z.object({
+          moduleFilePath: zod.z.string(),
+          /**
+           * Null when history has no record of this module at or before the
+           * commit — it was last edited before recording started, or never.
+           * Distinct from a module the commit deleted.
+           */
+          module: HistoricalModule.nullable()
+        })
+      })])
+    }
+  },
+  /**
+   * One file as it was at one commit.
+   *
+   * The lazy half: `/history/commit` NAMES a commit's binary files and this is
+   * where their bytes come from, so nothing is fetched until an `<img>`
+   * actually mounts. A file at a fixed commit cannot change, so the response is
+   * immutable and the browser's own cache handles flipping between commits.
+   */
+  "/history/files": {
+    GET: {
+      req: {
+        query: {
+          commit_sha: onlyOneStringQueryParam,
+          path: onlyOneStringQueryParam,
+          remote: onlyOneStringQueryParam.optional()
+        }
+      },
+      res: zod.z.union([unauthorizedResponse, notFoundResponse, zod.z.object({
+        status: zod.z.literal(400),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(200),
+        body: zod.z["instanceof"](ReadableStream)
+      })])
+    }
+  },
+  // #endregion history
   "/files": {
     GET: {
       req: {
@@ -3029,6 +3269,354 @@ var urlOf = function urlOf() {
   return "".concat(route);
 };
 
+/**
+ * Can this value, taken from one schema, be written into another?
+ *
+ * The question restore asks, and it is NOT the question validation asks.
+ * Validation checks a value against the schema it belongs to. This compares two
+ * schemas — the one a value was stored under and the one it is being written
+ * into — because a restore moves a value across a schema change, and possibly
+ * across paths.
+ *
+ * Three answers, not two. `unknown` is where the comparison genuinely cannot
+ * decide, and it exists so that an editor is told "we are not sure" rather than
+ * being given a confident answer we made up. Treating unknown as compatible
+ * writes values that break; treating it as incompatible blocks restores that
+ * would have been fine.
+ */
+
+var compatible = {
+  status: "compatible"
+};
+
+/**
+ * `Array.isArray` cannot narrow `JsonArray` out of `Json`, because it is
+ * `readonly Json[]` — so the check that reads naturally does not type. This
+ * predicate is that check, said once.
+ */
+function isJsonObject(value) {
+  return _typeof(value) === "object" && value !== null && !Array.isArray(value);
+}
+function incompatible(reason) {
+  return {
+    status: "incompatible",
+    reason: reason
+  };
+}
+
+/**
+ * "an object", "a string".
+ *
+ * Schema type names are data — `object`, `array`, `image` — so an interpolated
+ * "a" is wrong for three of them, in a sentence shown to editors the moment a
+ * restore is refused.
+ */
+function withArticle(type) {
+  return /^[aeiou]/i.test(type) ? "an ".concat(type) : "a ".concat(type);
+}
+
+/**
+ * A sentence an editor can act on, for the popup that explains a refusal.
+ *
+ * Kept beside the reasons rather than in the UI so that adding a reason without
+ * wording for it is a type error rather than a blank dialog.
+ */
+function explainIncompatible(reason) {
+  switch (reason.kind) {
+    case "type-changed":
+      return "This was ".concat(withArticle(reason.from), " and the field here is ").concat(withArticle(reason.to), ".");
+    case "no-matching-variant":
+      return "This does not match any of the shapes allowed here: ".concat(reason.variants.join(", "), ".");
+    case "unknown-field":
+      return "The old value has ".concat(reason.keys.length === 1 ? "a field" : "fields", " that no longer exist here: ").concat(reason.keys.join(", "), ".");
+    case "missing-required":
+      return "The field here needs ".concat(reason.keys.join(", "), ", which the old value does not have.");
+    case "not-optional":
+      return "The old value was empty, and this field cannot be empty.";
+    case "literal-changed":
+      return "This has to be exactly \"".concat(reason.to, "\", and the old value was \"").concat(reason.from, "\".");
+    case "different-module":
+      return "This points into ".concat(reason.to, ", and the old value pointed into ").concat(reason.from, ".");
+  }
+}
+
+/**
+ * The variant of a union that a value actually is.
+ *
+ * `undefined` when the value does not identify itself — which is a real answer,
+ * not a failure: it is what makes the caller return `unknown` rather than guess.
+ */
+function variantOf(schema, value) {
+  if (schema.type !== "union") {
+    return undefined;
+  }
+  // String union: the value IS the discriminator.
+  if (typeof schema.key !== "string") {
+    if (typeof value !== "string") {
+      return undefined;
+    }
+    return schema.items.find(function (item) {
+      return item.type === "literal" && item.value === value;
+    });
+  }
+  // Object union: the discriminator is a literal at `key`.
+  var discriminator = schema.key;
+  if (!isJsonObject(value)) {
+    return undefined;
+  }
+  var tag = value[discriminator];
+  if (typeof tag !== "string") {
+    return undefined;
+  }
+  return schema.items.find(function (item) {
+    if (item.type !== "object") {
+      return false;
+    }
+    var keySchema = item.items[discriminator];
+    return (keySchema === null || keySchema === void 0 ? void 0 : keySchema.type) === "literal" && keySchema.value === tag;
+  });
+}
+function describeVariant(schema, key) {
+  if (schema.type === "literal") {
+    return schema.value;
+  }
+  if (schema.type === "object") {
+    var tag = schema.items[key];
+    if ((tag === null || tag === void 0 ? void 0 : tag.type) === "literal") {
+      return tag.value;
+    }
+  }
+  return schema.type;
+}
+function checkCompatibility(from, to) {
+  // Emptiness first: a null that lands in a field which cannot be empty is a
+  // break regardless of what the two schemas otherwise say.
+  if (from.value === null) {
+    return to.schema.opt ? compatible : incompatible({
+      kind: "not-optional"
+    });
+  }
+
+  // A changed union is not itself disqualifying. What matters is whether the
+  // variant being restored still has somewhere to go — comparing the unions
+  // wholesale would refuse a restore that is perfectly safe.
+  if (to.schema.type === "union") {
+    var key = typeof to.schema.key === "string" ? to.schema.key : "";
+    var _iterator = _createForOfIteratorHelper(to.schema.items),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var variant = _step.value;
+        if (checkCompatibility(from, {
+          schema: variant
+        }).status === "compatible") {
+          return compatible;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return incompatible({
+      kind: "no-matching-variant",
+      variants: to.schema.items.map(function (item) {
+        return describeVariant(item, key);
+      })
+    });
+  }
+
+  // Coming FROM a union into something that is not one: only the variant this
+  // value actually is matters, so narrow before comparing.
+  if (from.schema.type === "union") {
+    var _variant = variantOf(from.schema, from.value);
+    if (_variant === undefined) {
+      return {
+        status: "unknown",
+        message: "The old value does not say which shape it is, so we cannot tell whether it fits here."
+      };
+    }
+    return checkCompatibility({
+      schema: _variant,
+      value: from.value
+    }, to);
+  }
+  if (from.schema.type !== to.schema.type) {
+    return incompatible({
+      kind: "type-changed",
+      from: from.schema.type,
+      to: to.schema.type
+    });
+  }
+  switch (to.schema.type) {
+    case "literal":
+      {
+        var fromValue = from.schema.type === "literal" ? from.schema.value : String(from.value);
+        return fromValue === to.schema.value ? compatible : incompatible({
+          kind: "literal-changed",
+          from: fromValue,
+          to: to.schema.value
+        });
+      }
+    case "object":
+      {
+        if (from.schema.type !== "object" || !isJsonObject(from.value)) {
+          return {
+            status: "unknown",
+            message: "The old value is not shaped like an object."
+          };
+        }
+        var _fromValue = from.value;
+        var target = to.schema.items;
+        var source = from.schema.items;
+
+        // Keys the old value carries that the field no longer has. Writing them
+        // would put data into a schema with nowhere to hold it.
+        var extra = Object.keys(source).filter(function (key) {
+          return !(key in target);
+        });
+        if (extra.length > 0) {
+          return incompatible({
+            kind: "unknown-field",
+            keys: extra
+          });
+        }
+
+        // Keys the field requires that the old value cannot supply.
+        var missing = Object.keys(target).filter(function (key) {
+          return !target[key].opt && !(key in source);
+        });
+        if (missing.length > 0) {
+          return incompatible({
+            kind: "missing-required",
+            keys: missing
+          });
+        }
+        var unknown = null;
+        for (var _i = 0, _Object$entries = Object.entries(target); _i < _Object$entries.length; _i++) {
+          var _fromValue$_key;
+          var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+            _key = _Object$entries$_i[0],
+            targetItem = _Object$entries$_i[1];
+          var sourceItem = source[_key];
+          if (sourceItem === undefined) {
+            continue; // optional and absent — already allowed above
+          }
+          var res = checkCompatibility({
+            schema: sourceItem,
+            value: (_fromValue$_key = _fromValue[_key]) !== null && _fromValue$_key !== void 0 ? _fromValue$_key : null
+          }, {
+            schema: targetItem
+          });
+          if (res.status === "incompatible") {
+            return res;
+          }
+          if (res.status === "unknown" && unknown === null) {
+            unknown = res;
+          }
+        }
+        return unknown !== null && unknown !== void 0 ? unknown : compatible;
+      }
+    case "array":
+      {
+        if (from.schema.type !== "array" || !Array.isArray(from.value)) {
+          return {
+            status: "unknown",
+            message: "The old value is not a list."
+          };
+        }
+        // An empty list has nothing to probe the item schema with. The item
+        // TYPES still have to agree, and that much can be decided without a
+        // value - so decide it rather than passing an empty list as proof.
+        if (from.value.length === 0) {
+          return from.schema.item.type === to.schema.item.type ? compatible : incompatible({
+            kind: "type-changed",
+            from: from.schema.item.type,
+            to: to.schema.item.type
+          });
+        }
+        var _unknown = null;
+        var _iterator2 = _createForOfIteratorHelper(from.value),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var item = _step2.value;
+            var _res = checkCompatibility({
+              schema: from.schema.item,
+              value: item
+            }, {
+              schema: to.schema.item
+            });
+            if (_res.status === "incompatible") {
+              return _res;
+            }
+            if (_res.status === "unknown" && _unknown === null) {
+              _unknown = _res;
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        return _unknown !== null && _unknown !== void 0 ? _unknown : compatible;
+      }
+    case "record":
+      {
+        if (from.schema.type !== "record" || !isJsonObject(from.value)) {
+          return {
+            status: "unknown",
+            message: "The old value is not a record."
+          };
+        }
+        var _unknown2 = null;
+        for (var _i2 = 0, _Object$values = Object.values(from.value); _i2 < _Object$values.length; _i2++) {
+          var entry = _Object$values[_i2];
+          var _res2 = checkCompatibility({
+            schema: from.schema.item,
+            value: entry !== null && entry !== void 0 ? entry : null
+          }, {
+            schema: to.schema.item
+          });
+          if (_res2.status === "incompatible") {
+            return _res2;
+          }
+          if (_res2.status === "unknown" && _unknown2 === null) {
+            _unknown2 = _res2;
+          }
+        }
+        return _unknown2 !== null && _unknown2 !== void 0 ? _unknown2 : compatible;
+      }
+    case "keyOf":
+      {
+        // A key is only meaningful against the module it indexes.
+        if (from.schema.type !== "keyOf") {
+          return compatible;
+        }
+        return from.schema.path === to.schema.path ? compatible : incompatible({
+          kind: "different-module",
+          from: from.schema.path,
+          to: to.schema.path
+        });
+      }
+    case "richtext":
+      {
+        // The options decide which nodes are legal, and comparing them properly
+        // means comparing node trees against them. Not yet done, and saying so is
+        // better than a confident answer we cannot back.
+        return {
+          status: "unknown",
+          message: "Rich text can be restored, but we cannot yet confirm every mark and block is still allowed here."
+        };
+      }
+    default:
+      // Primitives and media: same type is the whole test. Constraints
+      // (maxLength, accept, …) are validated on write, which reports them
+      // better than a schema comparison could.
+      return compatible;
+  }
+}
+
 /**
  * The newest commit the client has been told about, or `null` if none.
  *
@@ -4534,6 +5122,13 @@ function isSkippableFixCode(fix) {
       // rewriting the module) and saving does not repair it either, so surface
       // it: the message names the command (`val validate --fix`) that does.
       return false;
+    case "external:upload":
+      // Same shape as `jsonValues:extract-entry` — an entry inlined in a
+      // `.val.ts` that belongs elsewhere — and more emphatically not skippable.
+      // Fixing it writes to a live store, which is why even the CLI does it only
+      // under `val external upload` and never under a blanket `--fix`. Surfacing
+      // it is the whole point: someone has to decide.
+      return false;
     default:
       {
         return false;
@@ -4574,14 +5169,21 @@ function filterBlockingValidationErrors(validationErrors, schemas, sources) {
 }
 
 exports.Api = Api;
+exports.BinaryFileRef = BinaryFileRef;
 exports.CodeOptions = CodeOptions;
 exports.ColorOptions = ColorOptions;
 exports.DEFAULT_ERROR_MESSAGE = DEFAULT_ERROR_MESSAGE;
 exports.DateOptions = DateOptions;
 exports.FileOptions = FileOptions;
+exports.HistoricalCommit = HistoricalCommit;
+exports.HistoricalModule = HistoricalModule;
+exports.HistoricalPatchSet = HistoricalPatchSet;
+exports.HistoryError = HistoryError;
 exports.ImageEncodeOption = ImageEncodeOption;
 exports.ImageOptions = ImageOptions;
+exports.JSONValue = JSONValue;
 exports.JSON_ENTRIES_BATCH_MAX = JSON_ENTRIES_BATCH_MAX;
+exports.ModuleComparison = ModuleComparison;
 exports.ParentRef = ParentRef$1;
 exports.Patch = Patch;
 exports.PatchBlock = PatchBlock;
@@ -4599,6 +5201,7 @@ exports.RemirrorOrderedList = RemirrorOrderedList;
 exports.RemirrorParagraph = RemirrorParagraph;
 exports.RemirrorText = RemirrorText;
 exports.RemirrorTextMark = RemirrorTextMark;
+exports.RestoreVerdict = RestoreVerdict;
 exports.RichTextOptions = RichTextOptions;
 exports.SerializedArraySchema = SerializedArraySchema;
 exports.SerializedBooleanSchema = SerializedBooleanSchema;
@@ -4616,6 +5219,7 @@ exports.SerializedRecordSchema = SerializedRecordSchema;
 exports.SerializedRichTextSchema = SerializedRichTextSchema;
 exports.SerializedRouteSchema = SerializedRouteSchema;
 exports.SerializedSchema = SerializedSchema;
+exports.SerializedSettingsSchema = SerializedSettingsSchema;
 exports.SerializedStringSchema = SerializedStringSchema;
 exports.SerializedUnionSchema = SerializedUnionSchema;
 exports.SharedValConfig = SharedValConfig;
@@ -4634,10 +5238,12 @@ exports.buildEmptyAtPathPatch = buildEmptyAtPathPatch;
 exports.buildFileRefValue = buildFileRefValue;
 exports.buildImageGalleryPatch = buildImageGalleryPatch;
 exports.buildRemoveImageGalleryEntryPatch = buildRemoveImageGalleryEntryPatch;
+exports.checkCompatibility = checkCompatibility;
 exports.createRegExpFromPattern = createRegExpFromPattern;
 exports.createValClient = createValClient;
 exports.describeContainerAtPath = describeContainerAtPath;
 exports.emptyOf = emptyOf;
+exports.explainIncompatible = explainIncompatible;
 exports.filterBlockingValidationErrors = filterBlockingValidationErrors;
 exports.filterRoutesByPatterns = filterRoutesByPatterns;
 exports.findSimilar = findSimilar;