@valbuild/shared 0.125.0 → 0.126.0

package/CHANGELOG.md

@@ -1,5 +1,129 @@
 # @valbuild/shared
 
+## 0.126.0
+
+### Minor Changes
+
+- [#652](https://github.com/valbuild/val/pull/652) [`f2fe70d`](https://github.com/valbuild/val/commit/f2fe70dab2b65000dfaf289f09c70b4a8291467a) Thanks [@freekh](https://github.com/freekh)! - `s.union` is now `s.discriminatedUnion` and `s.enum`.
+
+  `s.union` did two unrelated jobs and worked out which one you meant from its
+  first argument: a string key meant a tagged union of objects, literal schemas
+  meant a set of allowed strings. Those are now two schemas with two names.
+
+  ```ts
+  // A fixed set of strings — presents as a dropdown
+  s.enum("primary", "secondary", "ghost"); // Schema<"primary" | "secondary" | "ghost">
+
+  // One of several object shapes, told apart by a tag field
+  s.discriminatedUnion(
+    "type",
+    s.object({ type: s.literal("hero"), heading: s.string() }),
+    s.object({ type: s.literal("quote"), text: s.string() }),
+  );
+  ```
+
+  `s.enum` takes the strings directly, so the `s.literal(...)` wrapper is gone.
+
+  **`s.union` still works** — it is deprecated, and it builds exactly the schema
+  above, so nothing has to change today:
+
+  ```ts
+  s.union(s.literal("one"), s.literal("two")); // → s.enum("one", "two")
+  s.union("type", pageA, pageB); // → s.discriminatedUnion("type", pageA, pageB)
+  ```
+
+  The two are different kinds of node, and that is the reason for the split. A
+  discriminated union is a container: the selected variant's fields are the fields
+  being edited, and everything that walks a schema descends through it. An enum is
+  a leaf — a string with a closed domain — so nothing recurses into it. Told apart
+  only by the shape of `key`, every consumer had to re-derive which one it was
+  holding; each now has its own serialized type (`"discriminated-union"` and
+  `"enum"`) and Val Studio has a field per kind rather than one field that
+  branches.
+
+  Two behaviour changes fall out of the split, both of them fixes:
+
+  - A value that is not a string at all now fails an enum's validation with a
+    type error. `s.union` of literals only ever checked the value against its
+    literals when the value WAS a string, so a number or an object where an enum
+    was declared validated clean.
+  - An enum field now shows its validation errors in Val Studio where the field
+    is opened on its own — the module editor and the canvas's fields column — and
+    gets the compact error layout inside an inline list row. It is a leaf now, so
+    it goes through the same error rendering as every other leaf field; the string
+    union bypassed it and showed nothing in those places.
+
+  Several latent crashes in the old `s.union` are fixed on the way past, all of
+  them cases where it threw a `TypeError` instead of reporting:
+
+  - A required discriminated union holding `null` now reports a type error rather
+    than throwing, and resolving a path underneath a nullable one that is `null`
+    gives the error the API promises instead of a crash.
+  - `s.literal("")` is a legal discriminator tag, and `s.enum("")` a legal value.
+    Both used to be treated as absent by a truthiness check — in path resolution,
+    in stega encoding, and in the message that lists a union's valid tags. The
+    editor's dropdowns handle them too: an empty value is reserved by the select
+    component and had to be mapped around.
+  - A variant that omits the discriminator entirely is now reported as the schema
+    error it is, instead of throwing while the check looked for it.
+  - An enum's value is now indexed for search, like every other string leaf. The
+    old string union was never indexed at all, so searching for one of its values
+    could not find the field.
+  - A nullable discriminated union set to `null` no longer renders a spinner that
+    never resolves.
+
+  `s.discriminatedUnion` also requires at least one variant, as `s.enum` requires
+  at least one value: a union with nothing to select is not a thing to write, and
+  everything downstream reads the first variant where it needs any.
+
+  If you read serialized schemas yourself, that is the breaking part: `type` is no
+  longer `"union"`, an enum carries `values: string[]` instead of a `key` plus
+  `items` of literal schemas, and `UnionSchema` is no longer a class.
+  `SerializedUnionSchema`, `SerializedStringUnionSchema`,
+  `SerializedObjectUnionSchema` and `UnionSchema` remain as deprecated type
+  aliases.
+
+### Patch Changes
+
+- [#664](https://github.com/valbuild/val/pull/664) [`5bfd630`](https://github.com/valbuild/val/commit/5bfd630b63dee2189e238f20fe72ecc5537160f7) Thanks [@freekh](https://github.com/freekh)! - Show the git message on deployments Val did not publish
+
+  The deploy feed could only name a publish when Val itself had made the commit:
+  the message came off Val's own `ValCommit`, and every other deployment — a
+  developer's push, a merged pull request, a revert — showed a seven-character
+  sha. On most projects those are the majority, so "what went out at 14:02?" had
+  no answer in the Studio.
+
+  A deployment can now carry its own `commitMessage`, which the Studio uses
+  wherever there is no Val commit to prefer. It is optional and nullable, so a
+  content service that does not report messages is unaffected — those publishes
+  keep showing the short sha, exactly as before.
+
+  Deployment rows also show only the subject line of a message now. A git message
+  is a subject, a blank line and a body, and the rows are one truncated line — so
+  a real push arrived as "Subject The body went on like this…". The classic
+  Draft changes view still has the whole message in its tooltip.
+
+- [#659](https://github.com/valbuild/val/pull/659) [`ccbcda6`](https://github.com/valbuild/val/commit/ccbcda60b3e3c465071229ae1ba28ac735483e63) Thanks [@freekh](https://github.com/freekh)! - Discarding changes now clears the validation errors, previews and search results
+  that were computed from them.
+
+  A discard that removed a module's last pending change announced itself only as
+  a "drop", and the stores that keep validation results, previews and the search
+  index listened only for changes being applied. So after discarding, the Studio
+  kept showing the errors and previews of the discarded edit until something else
+  touched the module.
+
+  Fields that reference another module's keys (`s.keyOf(...)` and `s.route()`)
+  also follow that module now. Renaming a page and then discarding the rename left
+  every `keyOf` field pointing at it reporting that the key does not exist — about
+  a key that was back — because the module holding the reference had not changed
+  and was never re-checked. The validation store now tracks which records a
+  module's errors resolve against and re-checks it when their keys change, and only
+  then: editing content inside a referenced page does not re-validate its
+  referrers.
+
+- Updated dependencies [[`f2fe70d`](https://github.com/valbuild/val/commit/f2fe70dab2b65000dfaf289f09c70b4a8291467a), [`171208a`](https://github.com/valbuild/val/commit/171208a20177e68ed5a8b1a6fdaabfe893a6aa5f)]:
+  - @valbuild/core@0.126.0
+
 ## 0.125.0
 
 ### Minor Changes

package/dist/declarations/src/internal/ApiRoutes.d.ts

@@ -443,6 +443,14 @@ export declare const Api: {
                         createdAt: z.ZodString;
                         commitMessage: z.ZodNullable<z.ZodString>;
                     }, z.core.$strip>>;
+                    deployments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        deploymentId: z.ZodString;
+                        deploymentState: z.ZodString;
+                        commitSha: z.ZodString;
+                        updatedAt: z.ZodString;
+                        createdAt: z.ZodString;
+                        commitMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>>>;
                     config: z.ZodObject<{
                         project: z.ZodOptional<z.ZodString>;
                         root: z.ZodOptional<z.ZodString>;

package/dist/declarations/src/internal/resolveSchemaSourceFixes.d.ts

@@ -14,12 +14,37 @@ export declare function findSimilar(key: string, targets: string[]): {
     target: string;
     distance: number;
 }[];
+/**
+ * The record a `keyof:check-keys` error resolves against — the value and the
+ * schema at the error's `sourcePath`.
+ *
+ * Exported for the one consumer that has to know what a resolution DEPENDED
+ * on rather than what it concluded: `ValidationStore` re-reads the keys here
+ * to decide whether a change to the referenced module can have moved the
+ * answer. Keep this and {@link checkKeyIsValid} reading the same record, or the
+ * store will invalidate on one record and the resolution answer from another.
+ */
+export declare function getKeyOfRecordAt(sourcePath: SourcePath, snapshot: SchemaSourceSnapshot): {
+    source: unknown;
+    schema: SerializedSchema | undefined;
+};
 export type ResolvedFix = {
     status: "resolved";
 } | {
     status: "remaining";
     error: ValidationError;
 };
+/**
+ * The record a `keyof:check-keys` error resolves against, or null for any other
+ * error — including a malformed marker, which
+ * {@link resolveSchemaSourceFixForError} reports and this has nothing to say
+ * about.
+ *
+ * For a consumer that needs to know what the resolution READS, not what it
+ * concludes: `ValidationStore` keeps this per validated module, so that a change
+ * to the referenced record can invalidate the module holding the reference.
+ */
+export declare function keyOfRecordPath(error: ValidationError): SourcePath | null;
 /**
  * Resolves a single `keyof:check-keys` or `router:check-route` error against
  * the given schema/source snapshot. Returns:

package/dist/declarations/src/internal/zod/SerializedSchema.d.ts

@@ -1,12 +1,13 @@
 import { z } from "zod";
-import { type SerializedSchema as SerializedSchemaT, type SerializedStringSchema as SerializedStringSchemaT, type SerializedLiteralSchema as SerializedLiteralSchemaT, type SerializedBooleanSchema as SerializedBooleanSchemaT, type SerializedNumberSchema as SerializedNumberSchemaT, type SerializedObjectSchema as SerializedObjectSchemaT, type SerializedArraySchema as SerializedArraySchemaT, type SerializedUnionSchema as SerializedUnionSchemaT, type SerializedRichTextSchema as SerializedRichTextSchemaT, type SerializedRichTextOptions as SerializedRichTextOptionsT, type SerializedRecordSchema as SerializedRecordSchemaT, type SerializedKeyOfSchema as SerializedKeyOfSchemaT, type SerializedRouteSchema as SerializedRouteSchemaT, type SerializedFileSchema as SerializedFileSchemaT, type SerializedDateSchema as SerializedDateSchemaT, type SerializedDateTimeSchema as SerializedDateTimeSchemaT, type SerializedColorSchema as SerializedColorSchemaT, type SerializedCodeSchema as SerializedCodeSchemaT, type SerializedImageSchema as SerializedImageSchemaT, type SerializedSettingsSchema as SerializedSettingsSchemaT } from "@valbuild/core";
+import { type SerializedSchema as SerializedSchemaT, type SerializedStringSchema as SerializedStringSchemaT, type SerializedLiteralSchema as SerializedLiteralSchemaT, type SerializedBooleanSchema as SerializedBooleanSchemaT, type SerializedNumberSchema as SerializedNumberSchemaT, type SerializedObjectSchema as SerializedObjectSchemaT, type SerializedArraySchema as SerializedArraySchemaT, type SerializedDiscriminatedUnionSchema as SerializedDiscriminatedUnionSchemaT, type SerializedEnumSchema as SerializedEnumSchemaT, type SerializedRichTextSchema as SerializedRichTextSchemaT, type SerializedRichTextOptions as SerializedRichTextOptionsT, type SerializedRecordSchema as SerializedRecordSchemaT, type SerializedKeyOfSchema as SerializedKeyOfSchemaT, type SerializedRouteSchema as SerializedRouteSchemaT, type SerializedFileSchema as SerializedFileSchemaT, type SerializedDateSchema as SerializedDateSchemaT, type SerializedDateTimeSchema as SerializedDateTimeSchemaT, type SerializedColorSchema as SerializedColorSchemaT, type SerializedCodeSchema as SerializedCodeSchemaT, type SerializedImageSchema as SerializedImageSchemaT, type SerializedSettingsSchema as SerializedSettingsSchemaT } from "@valbuild/core";
 export declare const SerializedStringSchema: z.ZodType<SerializedStringSchemaT>;
 export declare const SerializedLiteralSchema: z.ZodType<SerializedLiteralSchemaT>;
 export declare const SerializedBooleanSchema: z.ZodType<SerializedBooleanSchemaT>;
 export declare const SerializedNumberSchema: z.ZodType<SerializedNumberSchemaT>;
 export declare const SerializedObjectSchema: z.ZodType<SerializedObjectSchemaT>;
 export declare const SerializedArraySchema: z.ZodType<SerializedArraySchemaT>;
-export declare const SerializedUnionSchema: z.ZodType<SerializedUnionSchemaT>;
+export declare const SerializedDiscriminatedUnionSchema: z.ZodType<SerializedDiscriminatedUnionSchemaT>;
+export declare const SerializedEnumSchema: z.ZodType<SerializedEnumSchemaT>;
 export declare const ImageEncodeOption: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
     type: z.ZodLiteral<"webp">;
     quality: z.ZodOptional<z.ZodNumber>;

package/dist/declarations/src/internal/zod/ValDeployment.d.ts

@@ -5,5 +5,6 @@ export declare const ValDeployment: z.ZodObject<{
     commitSha: z.ZodString;
     updatedAt: z.ZodString;
     createdAt: z.ZodString;
+    commitMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 export type ValDeployment = z.infer<typeof ValDeployment>;

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

@@ -989,19 +989,19 @@ var SerializedArraySchema = zod.z.lazy(function () {
     opt: zod.z["boolean"]()
   }));
 });
-var SerializedUnionSchema = zod.z.lazy(function () {
-  return zod.z.union([zod.z.object(getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, commonSchemaFields), {}, {
-    type: zod.z.literal("union"),
-    key: SerializedLiteralSchema,
-    items: zod.z.array(SerializedLiteralSchema),
-    opt: zod.z["boolean"]()
-  })), zod.z.object(getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, commonSchemaFields), {}, {
-    type: zod.z.literal("union"),
+var SerializedDiscriminatedUnionSchema = zod.z.lazy(function () {
+  return zod.z.object(getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, commonSchemaFields), {}, {
+    type: zod.z.literal("discriminated-union"),
     key: zod.z.string(),
     items: zod.z.array(SerializedObjectSchema),
     opt: zod.z["boolean"]()
-  }))]);
+  }));
 });
+var SerializedEnumSchema = zod.z.object(getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, commonSchemaFields), {}, {
+  type: zod.z.literal("enum"),
+  values: zod.z.array(zod.z.string()),
+  opt: zod.z["boolean"]()
+}));
 var ImageEncodeOption = zod.z.union([zod.z.literal(false), zod.z.object({
   type: zod.z.literal("webp"),
   quality: zod.z.number().optional(),
@@ -1153,7 +1153,7 @@ var SerializedSettingsSchema = zod.z.lazy(function () {
     opt: zod.z["boolean"]()
   }));
 });
-var SerializedSchema = zod.z.union([SerializedStringSchema, SerializedLiteralSchema, SerializedBooleanSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedArraySchema, SerializedUnionSchema, SerializedRichTextSchema, SerializedRecordSchema, SerializedKeyOfSchema, SerializedRouteSchema, SerializedFileSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedColorSchema, SerializedCodeSchema, SerializedSettingsSchema, SerializedImageSchema]);
+var SerializedSchema = zod.z.union([SerializedStringSchema, SerializedLiteralSchema, SerializedBooleanSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedArraySchema, SerializedDiscriminatedUnionSchema, SerializedEnumSchema, SerializedRichTextSchema, SerializedRecordSchema, SerializedKeyOfSchema, SerializedRouteSchema, SerializedFileSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedColorSchema, SerializedCodeSchema, SerializedSettingsSchema, SerializedImageSchema]);
 
 var ValCommit = zod.z.object({
   commitSha: zod.z.string(),
@@ -1165,6 +1165,31 @@ var ValCommit = zod.z.object({
   commitMessage: zod.z.string().nullable()
 });
 
+var ValDeployment = zod.z.object({
+  deploymentId: zod.z.string(),
+  deploymentState: zod.z.string(),
+  commitSha: zod.z.string(),
+  updatedAt: zod.z.string(),
+  createdAt: zod.z.string(),
+  /**
+   * The commit message, as the deployment's host reported it.
+   *
+   * Val's OWN publishes carry their message on the commit (`ValCommit`), and
+   * that is the one the Studio prefers — it is the message Val wrote. This is
+   * for every OTHER deployment: a developer's push, a merged pull request, a
+   * revert. Those have no Val commit at all, so without this the deploy feed
+   * could only name them by their short sha, and "what went out at 14:02?" had
+   * no answer inside the Studio.
+   *
+   * Optional AND nullable, and the two mean different things: absent is a
+   * content service that does not report messages (or an older one), null is
+   * one that reports having none. Both render as the short sha, so nothing
+   * depends on telling them apart — but a schema that demanded the field would
+   * reject the whole deployment feed of a service that does not send it.
+   */
+  commitMessage: zod.z.string().nullable().optional()
+});
+
 /**
  * The wire shapes for reading history.
  *
@@ -1757,6 +1782,21 @@ var Api = {
            */
           headCommitSha: zod.z.string().optional(),
           commits: zod.z.array(ValCommit),
+          /**
+           * The publishes the content service knows about.
+           *
+           * Declared, at last. `getStat` has always returned these in
+           * `http` mode and the Studio has always read them - the response
+           * validator strips unknown keys rather than rejecting them, and
+           * the raw json is what the client hands back, so they arrived
+           * while the contract said they could not. That was survivable
+           * until a deployment started carrying a commit MESSAGE: a field
+           * nobody has declared is a field the next person deletes.
+           *
+           * Optional, because a content service that reports no
+           * deployments sends none.
+           */
+          deployments: zod.z.array(ValDeployment).optional(),
           config: ValConfig,
           profileId: zod.z.string().nullable(),
           mode: zod.z.union([zod.z.literal("http"), zod.z.literal("fs")])
@@ -3249,19 +3289,9 @@ function explainIncompatible(reason) {
  * not a failure: it is what makes the caller return `unknown` rather than guess.
  */
 function variantOf(schema, value) {
-  if (schema.type !== "union") {
+  if (schema.type !== "discriminated-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;
@@ -3279,9 +3309,6 @@ function variantOf(schema, value) {
   });
 }
 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") {
@@ -3299,11 +3326,24 @@ function checkCompatibility(from, to) {
     });
   }
 
+  // An enum's domain IS its schema, so the value decides: whatever the old
+  // schema was — an enum, a literal, a plain string — the only question is
+  // whether this string is still offered here.
+  if (to.schema.type === "enum") {
+    if (typeof from.value === "string" && to.schema.values.includes(from.value)) {
+      return compatible;
+    }
+    return incompatible({
+      kind: "no-matching-variant",
+      variants: to.schema.values
+    });
+  }
+
   // 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 : "";
+  if (to.schema.type === "discriminated-union") {
+    var key = to.schema.key;
     var _iterator = getSitemapTree._createForOfIteratorHelper(to.schema.items),
       _step;
     try {
@@ -3328,9 +3368,9 @@ function checkCompatibility(from, to) {
     });
   }
 
-  // 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") {
+  // Coming FROM a discriminated union into something that is not one: only the
+  // variant this value actually is matters, so narrow before comparing.
+  if (from.schema.type === "discriminated-union") {
     var _variant = variantOf(from.schema, from.value);
     if (_variant === undefined) {
       return {
@@ -3343,6 +3383,25 @@ function checkCompatibility(from, to) {
       value: from.value
     }, to);
   }
+
+  // Coming FROM an enum into something that is not one: the value it holds is
+  // all the old schema contributes, so compare as that one value.
+  if (from.schema.type === "enum") {
+    if (typeof from.value !== "string") {
+      return {
+        status: "unknown",
+        message: "The old value is not one of the options it was stored as, so we cannot tell whether it fits here."
+      };
+    }
+    return checkCompatibility({
+      schema: {
+        type: "literal",
+        value: from.value,
+        opt: from.schema.opt
+      },
+      value: from.value
+    }, to);
+  }
   if (from.schema.type !== to.schema.type) {
     return incompatible({
       kind: "type-changed",
@@ -3576,14 +3635,6 @@ var SharedValConfig = zod.z.object({
  * Config that is shared between the client and server.
  */
 
-var ValDeployment = zod.z.object({
-  deploymentId: zod.z.string(),
-  deploymentState: zod.z.string(),
-  commitSha: zod.z.string(),
-  updatedAt: zod.z.string(),
-  createdAt: zod.z.string()
-});
-
 /**
  * Shared route validation utilities
  */
@@ -3756,6 +3807,16 @@ function findSimilar(key, targets) {
     return a.distance - b.distance;
   });
 }
+/**
+ * The record a `keyof:check-keys` error resolves against — the value and the
+ * schema at the error's `sourcePath`.
+ *
+ * Exported for the one consumer that has to know what a resolution DEPENDED
+ * on rather than what it concluded: `ValidationStore` re-reads the keys here
+ * to decide whether a change to the referenced module can have moved the
+ * answer. Keep this and {@link checkKeyIsValid} reading the same record, or the
+ * store will invalidate on one record and the resolution answer from another.
+ */
 function getKeyOfRecordAt(sourcePath, snapshot) {
   var _Internal$splitModule = core.Internal.splitModuleFilePathAndModulePath(sourcePath),
     _Internal$splitModule2 = _slicedToArray(_Internal$splitModule, 2),
@@ -3899,6 +3960,29 @@ function checkRouteIsValid(route, includePattern, excludePattern, snapshot) {
     error: false
   };
 }
+/**
+ * The record a `keyof:check-keys` error resolves against, or null for any other
+ * error — including a malformed marker, which
+ * {@link resolveSchemaSourceFixForError} reports and this has nothing to say
+ * about.
+ *
+ * For a consumer that needs to know what the resolution READS, not what it
+ * concludes: `ValidationStore` keeps this per validated module, so that a change
+ * to the referenced record can invalidate the module holding the reference.
+ */
+function keyOfRecordPath(error) {
+  var _error$fixes;
+  if (!((_error$fixes = error.fixes) !== null && _error$fixes !== void 0 ? _error$fixes : []).includes("keyof:check-keys")) {
+    return null;
+  }
+  var value = error.value;
+  if (!value || getSitemapTree._typeof(value) !== "object") {
+    return null;
+  }
+  var sourcePath = value.sourcePath;
+  return typeof sourcePath === "string" ? sourcePath : null;
+}
+
 /**
  * Resolves a single `keyof:check-keys` or `router:check-route` error against
  * the given schema/source snapshot. Returns:
@@ -3907,8 +3991,8 @@ function checkRouteIsValid(route, includePattern, excludePattern, snapshot) {
  *   - { status: "remaining"; error } if invalid (rewritten error to surface)
  */
 function resolveSchemaSourceFixForError(error, snapshot) {
-  var _error$fixes;
-  var fixes = (_error$fixes = error.fixes) !== null && _error$fixes !== void 0 ? _error$fixes : [];
+  var _error$fixes2;
+  var fixes = (_error$fixes2 = error.fixes) !== null && _error$fixes2 !== void 0 ? _error$fixes2 : [];
   if (fixes.includes("keyof:check-keys")) {
     if (!error.value) {
       return {
@@ -4137,11 +4221,20 @@ function emptyOf(schema) {
     return null; // returning null is the only thing we can do, however, it means that the patches cannot be applied yet since that might fail
   } else if (schema.type === "literal") {
     return schema.value;
-  } else if (schema.type === "union") {
-    if (typeof schema.key === "string") {
-      return emptyOf(schema.items[0]);
+  } else if (schema.type === "discriminated-union") {
+    // The first variant is what a new value starts as. `s.discriminatedUnion`
+    // requires one, so an empty `items` means a serialized schema that was not
+    // built by it — say so rather than returning `undefined`, which is not
+    // JSON and would be written into a patch as a missing key.
+    if (schema.items.length === 0) {
+      throw Error("Cannot create an empty value for a discriminated union with no variants");
     }
-    return schema.key.value;
+    return emptyOf(schema.items[0]);
+  } else if (schema.type === "enum") {
+    if (schema.values.length === 0) {
+      throw Error("Cannot create an empty value for an enum with no values");
+    }
+    return schema.values[0];
   } else if (schema.type === "date") {
     return clampDateString(formatLocalDate(new Date()), schema.options);
   } else if (schema.type === "dateTime") {
@@ -4229,24 +4322,19 @@ function resolveSerializedSchemaAtPath(schema, path) {
         schema: current,
         remainingPath: path.slice(i)
       };
-    } else if (current.type === "union") {
-      if (typeof current.key === "string") {
-        var _iterator2 = getSitemapTree._createForOfIteratorHelper(current.items),
-          _step2;
-        try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var variant = _step2.value;
-            var resolved = resolveSerializedSchemaAtPath(variant, path.slice(i));
-            if (resolved.kind !== "unresolved") return resolved;
-          }
-        } catch (err) {
-          _iterator2.e(err);
-        } finally {
-          _iterator2.f();
+    } else if (current.type === "discriminated-union") {
+      var _iterator2 = getSitemapTree._createForOfIteratorHelper(current.items),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var variant = _step2.value;
+          var resolved = resolveSerializedSchemaAtPath(variant, path.slice(i));
+          if (resolved.kind !== "unresolved") return resolved;
         }
-        return {
-          kind: "unresolved"
-        };
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
       }
       return {
         kind: "unresolved"
@@ -5175,6 +5263,18 @@ function traverseSchemaSource(source, schema, path, callback) {
     return;
   }
 
+  // Handle enum: a leaf, like a literal with more than one allowed value
+  if (schema.type === "enum") {
+    if (typeof source === "string") {
+      callback({
+        source: source,
+        schema: schema,
+        path: path
+      });
+    }
+    return;
+  }
+
   // Handle route
   if (schema.type === "route") {
     if (typeof source === "string") {
@@ -5222,36 +5322,24 @@ function traverseSchemaSource(source, schema, path, callback) {
     return;
   }
 
-  // Handle union
-  if (schema.type === "union") {
+  // Handle discriminated union: descend through the variant the value takes
+  if (schema.type === "discriminated-union") {
     var schemaKey = schema.key;
-    if (typeof schemaKey === "string") {
-      // Tagged union - find matching sub-schema
-      if (source && getSitemapTree._typeof(source) === "object" && !Array.isArray(source) && schemaKey in source) {
-        var itemKey = source[schemaKey];
-        if (typeof itemKey === "string") {
-          var schemaOfItem = schema.items.filter(function (item) {
-            return item.type === "object";
-          }).find(function (item) {
-            var itemKeySchema = item.items[schemaKey];
-            if ((itemKeySchema === null || itemKeySchema === void 0 ? void 0 : itemKeySchema.type) === "literal") {
-              return itemKeySchema.value === itemKey;
-            }
-            return false;
-          });
-          if (schemaOfItem) {
-            traverseSchemaSource(source, schemaOfItem, path, callback);
+    if (source && getSitemapTree._typeof(source) === "object" && !Array.isArray(source) && schemaKey in source) {
+      var itemKey = source[schemaKey];
+      if (typeof itemKey === "string") {
+        var schemaOfItem = schema.items.filter(function (item) {
+          return item.type === "object";
+        }).find(function (item) {
+          var itemKeySchema = item.items[schemaKey];
+          if ((itemKeySchema === null || itemKeySchema === void 0 ? void 0 : itemKeySchema.type) === "literal") {
+            return itemKeySchema.value === itemKey;
           }
-        }
-      }
-    } else {
-      // Literal union - treat as primitive
-      if (typeof source === "string") {
-        callback({
-          source: source,
-          schema: schema,
-          path: path
+          return false;
         });
+        if (schemaOfItem) {
+          traverseSchemaSource(source, schemaOfItem, path, callback);
+        }
       }
     }
     return;
@@ -5411,7 +5499,11 @@ function indexModule(searchIndex, moduleFilePath, source, schema) {
     var label = "";
 
     // Handle primitives
-    if (schema.type === "string" || schema.type === "number" || schema.type === "boolean" || schema.type === "date" || schema.type === "dateTime" || schema.type === "color" || schema.type === "code" || schema.type === "keyOf" || schema.type === "route") {
+    if (schema.type === "string" || schema.type === "number" || schema.type === "boolean" || schema.type === "date" || schema.type === "dateTime" || schema.type === "color" || schema.type === "code" || schema.type === "keyOf" || schema.type === "route" ||
+    // An enum's value is a string the editor chose; it is as searchable as
+    // any other string leaf. The old string union was never indexed at all,
+    // which is the gap this closes.
+    schema.type === "enum") {
       var _source$toString, _source$toString2;
       searchText = (_source$toString = source === null || source === void 0 ? void 0 : source.toString()) !== null && _source$toString !== void 0 ? _source$toString : "";
       label = (_source$toString2 = source === null || source === void 0 ? void 0 : source.toString()) !== null && _source$toString2 !== void 0 ? _source$toString2 : "";
@@ -5612,6 +5704,8 @@ exports.SerializedCodeSchema = SerializedCodeSchema;
 exports.SerializedColorSchema = SerializedColorSchema;
 exports.SerializedDateSchema = SerializedDateSchema;
 exports.SerializedDateTimeSchema = SerializedDateTimeSchema;
+exports.SerializedDiscriminatedUnionSchema = SerializedDiscriminatedUnionSchema;
+exports.SerializedEnumSchema = SerializedEnumSchema;
 exports.SerializedFileSchema = SerializedFileSchema;
 exports.SerializedImageSchema = SerializedImageSchema;
 exports.SerializedKeyOfSchema = SerializedKeyOfSchema;
@@ -5624,7 +5718,6 @@ exports.SerializedRouteSchema = SerializedRouteSchema;
 exports.SerializedSchema = SerializedSchema;
 exports.SerializedSettingsSchema = SerializedSettingsSchema;
 exports.SerializedStringSchema = SerializedStringSchema;
-exports.SerializedUnionSchema = SerializedUnionSchema;
 exports.SharedValConfig = SharedValConfig;
 exports.VAL_ENABLE_COOKIE_NAME = VAL_ENABLE_COOKIE_NAME;
 exports.VAL_SESSION_COOKIE = VAL_SESSION_COOKIE;
@@ -5654,6 +5747,7 @@ exports.flattenRichText = flattenRichText;
 exports.getErrorMessageFromUnknownJson = getErrorMessageFromUnknownJson;
 exports.getFilenameFromRef = getFilenameFromRef;
 exports.getInlineImgInfo = getInlineImgInfo;
+exports.getKeyOfRecordAt = getKeyOfRecordAt;
 exports.getRefParts = getRefParts;
 exports.getRoutesOf = getRoutesOf;
 exports.getRoutesWithModulePaths = getRoutesWithModulePaths;
@@ -5662,6 +5756,7 @@ exports.indexModule = indexModule;
 exports.isMimeTypeAccepted = isMimeTypeAccepted;
 exports.isRemoteSchema = isRemoteSchema;
 exports.isSkippedSource = isSkippedSource;
+exports.keyOfRecordPath = keyOfRecordPath;
 exports.levenshtein = levenshtein;
 exports.newestCommitSha = newestCommitSha;
 exports.partitionValidationErrors = partitionValidationErrors;