@valbuild/shared 0.113.0 → 0.116.0

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

@@ -2018,31 +2018,6 @@ var Api = {
       })])
     }
   },
-  "/commit-summary": {
-    GET: {
-      req: {
-        query: {
-          patch_id: zod.z.array(PatchId)
-        },
-        cookies: {
-          val_session: zod.z.string().optional()
-        }
-      },
-      res: zod.z.union([unauthorizedResponse, zod.z.object({
-        status: zod.z.literal(400),
-        json: zod.z.object({
-          message: zod.z.string()
-        })
-      }), zod.z.object({
-        status: zod.z.literal(200),
-        json: zod.z.object({
-          patchIds: zod.z.array(PatchId),
-          baseSha: zod.z.string(),
-          commitSummary: zod.z.string().nullable()
-        })
-      })])
-    }
-  },
   "/save": {
     POST: {
       req: {
@@ -2214,7 +2189,21 @@ var Api = {
         status: zod.z.literal(200),
         json: zod.z.object({
           nonce: zod.z.string(),
-          wsUrl: zod.z.string()
+          wsUrl: zod.z.string(),
+          /**
+           * The AI providers this project can actually reach.
+           *
+           * AI runs on a key the org or the user brought, so an org with only
+           * an Anthropic key cannot use a GPT model — asking for one gets a
+           * refusal. The client owns the model catalog and picks a model whose
+           * provider is in here.
+           *
+           * `string[]` and not an enum on purpose: the content server may add
+           * a provider before the Studio knows of it, and a strict enum would
+           * reject the whole response over a name this version has not heard
+           * of. Unknown entries are simply ignored.
+           */
+          providers: zod.z.array(zod.z.string()).optional()
         })
       }), zod.z.object({
         status: zod.z.literal(500),
@@ -3460,6 +3449,753 @@ function withValCanvasParam(url) {
   return "".concat(url).concat(separator).concat(VAL_CANVAS_PARAM, "=1");
 }
 
+/**
+ * Local `yyyy-MM-dd`, which is the one thing this module used `date-fns` for.
+ *
+ * Inlined rather than carried along: `@valbuild/shared` depends on nothing but
+ * `@valbuild/core` and zod, and a whole date library is not worth adding to
+ * that for a single format string. Deliberately the *local* date, not
+ * `toISOString().slice(0, 10)` — the latter is UTC, so anyone west of
+ * Greenwich would get yesterday's date as their "today" default.
+ */
+function formatLocalDate(date) {
+  var year = String(date.getFullYear()).padStart(4, "0");
+  var month = String(date.getMonth() + 1).padStart(2, "0");
+  var day = String(date.getDate()).padStart(2, "0");
+  return "".concat(year, "-").concat(month, "-").concat(day);
+}
+function clampDateString(value, options) {
+  if (options !== null && options !== void 0 && options.to && value > options.to) return options.to;
+  if (options !== null && options !== void 0 && options.from && value < options.from) return options.from;
+  return value;
+}
+function clampDateTimeString(value, options) {
+  if (!options) return value;
+  var ms = Date.parse(value);
+  if (Number.isNaN(ms)) return value;
+  // Stored datetime values are always UTC ISO strings, so normalize the
+  // clamped bound (which may carry a timezone offset) via toISOString().
+  if (options.to) {
+    var toMs = Date.parse(options.to);
+    if (!Number.isNaN(toMs) && ms > toMs) return new Date(toMs).toISOString();
+  }
+  if (options.from) {
+    var fromMs = Date.parse(options.from);
+    if (!Number.isNaN(fromMs) && ms < fromMs) return new Date(fromMs).toISOString();
+  }
+  return value;
+}
+function emptyOf(schema) {
+  if (schema.type === "object") {
+    return Object.fromEntries(Object.keys(schema.items).map(function (key) {
+      return [key, emptyOf(schema.items[key])];
+    }));
+  } else if (schema.type === "array") {
+    return [];
+  } else if (schema.type === "record") {
+    return {};
+  } else if (schema.opt) {
+    return null;
+  } else if (schema.type === "richtext") {
+    return [];
+  } else if (schema.type === "string") {
+    return "";
+  } else if (schema.type === "boolean") {
+    return false;
+  } else if (schema.type === "number") {
+    return 0;
+  } else if (schema.type === "keyOf") {
+    if (schema.values === "string") {
+      return ""; // TODO: figure out this: user code might very well fail in this case
+    } else {
+      return schema.values[0];
+    }
+  } else if (schema.type === "route") {
+    return ""; // Empty string as default route value
+  } else if (schema.type === "file" || schema.type === "image") {
+    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]);
+    }
+    return schema.key.value;
+  } else if (schema.type === "date") {
+    return clampDateString(formatLocalDate(new Date()), schema.options);
+  } else if (schema.type === "dateTime") {
+    return clampDateTimeString(new Date().toISOString(), schema.options);
+  } else if (schema.type === "color") {
+    var _schema$options$forma, _schema$options;
+    // Mid grey: visible against both a light and a dark canvas
+    return core.Internal.color.formatColor({
+      r: 128,
+      g: 128,
+      b: 128,
+      a: 1
+    }, (_schema$options$forma = (_schema$options = schema.options) === null || _schema$options === void 0 ? void 0 : _schema$options.format) !== null && _schema$options$forma !== void 0 ? _schema$options$forma : core.DEFAULT_COLOR_FORMAT);
+  } else if (schema.type === "code") {
+    return ""; // An empty editor: no language has a sensible starting snippet
+  }
+  var _exhaustiveCheck = schema;
+  throw Error("Unexpected schema type: " + JSON.stringify(_exhaustiveCheck));
+}
+
+var toolNames = ["get_all_schema", "get_source", "search_content", "validate_content", "create_patch", "add_session_image_to_gallery", "remove_image_gallery_entry", "navigate_to", "get_current_context", "get_patches", "get_source_path_from_route", "set_session_name", "show_compare_view", "ask_user_question", "duplicate_source", "empty_at_path", "count_entries", "get_record_keys"];
+
+function buildFileRefValue(filePath, metadata) {
+  return _objectSpread2({
+    path: filePath
+  }, metadata);
+}
+function getSourceAt(source, path) {
+  var current = source;
+  var _iterator = _createForOfIteratorHelper(path),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var part = _step.value;
+      if (current === null || current === undefined) return undefined;
+      if (Array.isArray(current)) {
+        var idx = Number(part);
+        if (!Number.isInteger(idx)) return undefined;
+        current = current[idx];
+      } else if (_typeof(current) === "object") {
+        current = current[part];
+      } else {
+        return undefined;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return current;
+}
+/**
+ * Walks `schema` along `path`, returning a structured result:
+ * - `leaf`: walked the full path; resolved schema at the end.
+ * - `richtext`: hit a richtext mid-walk; richtext is the resolved schema.
+ * - `gallery-traversed`: hit an `s.images()` record and walked past it (i.e. the
+ *   path tries to address an entry inside the gallery — a clue the AI should
+ *   have used the gallery tool instead).
+ * - `unresolved`: the path could not be walked.
+ */
+function resolveSerializedSchemaAtPath(schema, path) {
+  var current = schema;
+  for (var i = 0; i < path.length; i++) {
+    var part = path[i];
+    if (current.type === "object") {
+      var next = current.items[part];
+      if (!next) return {
+        kind: "unresolved"
+      };
+      current = next;
+    } else if (current.type === "array") {
+      current = current.item;
+    } else if (current.type === "record") {
+      if (current.mediaType === "images") {
+        return {
+          kind: "gallery-traversed",
+          schema: current
+        };
+      }
+      current = current.item;
+    } else if (current.type === "richtext") {
+      return {
+        kind: "richtext",
+        schema: current,
+        remainingPath: path.slice(i)
+      };
+    } else if (current.type === "union") {
+      if (typeof current.key === "string") {
+        var _iterator2 = _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();
+        }
+        return {
+          kind: "unresolved"
+        };
+      }
+      return {
+        kind: "unresolved"
+      };
+    } else {
+      return {
+        kind: "unresolved"
+      };
+    }
+  }
+  return {
+    kind: "leaf",
+    schema: current
+  };
+}
+function getInlineImgInfo(richtextSchema) {
+  var _richtextSchema$optio;
+  if (richtextSchema.type !== "richtext") return {
+    kind: "not-allowed"
+  };
+  var img = (_richtextSchema$optio = richtextSchema.options) === null || _richtextSchema$optio === void 0 || (_richtextSchema$optio = _richtextSchema$optio.inline) === null || _richtextSchema$optio === void 0 ? void 0 : _richtextSchema$optio.img;
+  if (!img) return {
+    kind: "not-allowed"
+  };
+  if (img === true) return {
+    kind: "allowed",
+    remote: false
+  };
+  return {
+    kind: "allowed",
+    remote: img.remote === true
+  };
+}
+function isRemoteSchema(schema) {
+  if (schema.type === "image" || schema.type === "file") {
+    return schema.remote === true;
+  }
+  if (schema.type === "record") {
+    return schema.remote === true;
+  }
+  return false;
+}
+function safeParsePatch(patch) {
+  var parsed = Patch.safeParse(patch);
+  if (!parsed.success) {
+    return {
+      kind: "error",
+      message: "Built patch failed schema validation: ".concat(JSON.stringify(parsed.error))
+    };
+  }
+  return {
+    kind: "ok",
+    patch: parsed.data
+  };
+}
+function checkGallerySchema(moduleSchema) {
+  if (moduleSchema.type === "record" && moduleSchema.mediaType === "images") {
+    return null;
+  }
+  if (moduleSchema.type === "image") {
+    return {
+      kind: "wrong-tool",
+      suggestedTool: "create_patch",
+      reason: "Module is a plain image field, not an images gallery. Use create_patch with a SessionKey value."
+    };
+  }
+  if (moduleSchema.type === "richtext") {
+    return {
+      kind: "wrong-tool",
+      suggestedTool: "create_patch",
+      reason: "Module is a richtext, not an images gallery. Use create_patch with a SessionKey inside a {tag:'img', src: SessionKey} node."
+    };
+  }
+  return {
+    kind: "error",
+    message: "Module schema is not an images gallery (expected record with mediaType=\"images\", got '".concat(moduleSchema.type, "').")
+  };
+}
+function buildImageGalleryPatch(args, moduleSchema) {
+  var wrong = checkGallerySchema(moduleSchema);
+  if (wrong) return wrong;
+  var remote = isRemoteSchema(moduleSchema);
+  var patch = [{
+    op: "add",
+    path: [args.filePath],
+    value: _objectSpread2({}, args.metadata)
+  }, {
+    op: "file",
+    path: [args.filePath],
+    filePath: args.filePath,
+    value: args.imageKey,
+    remote: remote,
+    metadata: args.metadata
+  }];
+  return safeParsePatch(patch);
+}
+function buildRemoveImageGalleryEntryPatch(args, moduleSchema, moduleSource) {
+  var wrong = checkGallerySchema(moduleSchema);
+  if (wrong) return wrong;
+  if (!moduleSource || _typeof(moduleSource) !== "object" || Array.isArray(moduleSource)) {
+    return {
+      kind: "error",
+      message: "Cannot remove from gallery: module source is not an object."
+    };
+  }
+  var entries = moduleSource;
+  if (!Object.prototype.hasOwnProperty.call(entries, args.filePath)) {
+    var availableKeys = Object.keys(entries);
+    var hint = availableKeys.length > 0 ? " Available entries: ".concat(availableKeys.map(function (k) {
+      return "\"".concat(k, "\"");
+    }).join(", "), ".") : " The gallery is empty.";
+    return {
+      kind: "error",
+      message: "No gallery entry with file_path \"".concat(args.filePath, "\".").concat(hint)
+    };
+  }
+  var remote = core.Internal.remote.splitRemoteRef(args.filePath).status === "success";
+  var patch = [{
+    op: "remove",
+    path: [args.filePath]
+  }, {
+    op: "file",
+    path: [args.filePath],
+    filePath: args.filePath,
+    value: null,
+    remote: remote
+  }];
+  return safeParsePatch(patch);
+}
+
+/**
+ * Decides whether the duplicate/empty operation should produce an "add" or
+ * "replace" JSON patch op by inspecting the destination's *parent* schema.
+ *
+ * - array / record parent → "add" (creating a new slot)
+ * - object parent → "replace" (slot exists by schema definition)
+ * - empty path → "replace" (overwriting the whole module)
+ * - richtext / gallery parent → not supported; redirect to the right tool
+ */
+var GALLERY_REDIRECT = {
+  kind: "wrong-tool",
+  suggestedTool: "add_session_image_to_gallery",
+  reason: "Destination is a media gallery (s.images() / s.files()). Gallery entries are keyed by file path and carry a file on disk, so they cannot be created with a plain patch. Use add_session_image_to_gallery."
+};
+
+/** An `s.images()` / `s.files()` record: a gallery, not an ordinary record. */
+function isGallery(schema) {
+  return schema.type === "record" && schema.mediaType !== undefined;
+}
+function decideOp(moduleSchema, destinationPath) {
+  // The DESTINATION itself, checked before its parent: `["gallery"]` resolves
+  // its parent to the enclosing object and would otherwise look like an
+  // ordinary `replace` that overwrites a whole gallery.
+  var destination = resolveSerializedSchemaAtPath(moduleSchema, destinationPath);
+  if (destination.kind === "gallery-traversed") {
+    return GALLERY_REDIRECT;
+  }
+  if (destination.kind === "richtext") {
+    return {
+      kind: "wrong-tool",
+      suggestedTool: "create_patch",
+      reason: "Destination is a richtext value. duplicate_source and empty_at_path do not handle richtext edits."
+    };
+  }
+  if (destination.kind === "leaf") {
+    if (isGallery(destination.schema)) {
+      return GALLERY_REDIRECT;
+    }
+    // A richtext value the path lands exactly ON resolves as a leaf, not as
+    // `kind: "richtext"` (which only fires when the walk continues INTO it).
+    if (destination.schema.type === "richtext") {
+      return {
+        kind: "wrong-tool",
+        suggestedTool: "create_patch",
+        reason: "Destination is a richtext value. duplicate_source and empty_at_path do not handle richtext edits."
+      };
+    }
+  }
+  if (destinationPath.length === 0) {
+    return {
+      kind: "ok",
+      op: "replace",
+      parent: "module"
+    };
+  }
+  var parent = resolveSerializedSchemaAtPath(moduleSchema, destinationPath.slice(0, -1));
+  if (parent.kind === "unresolved") {
+    return {
+      kind: "error",
+      message: "Destination parent path ".concat(JSON.stringify(destinationPath.slice(0, -1)), " does not resolve in this module's schema.")
+    };
+  }
+  if (parent.kind === "richtext") {
+    return {
+      kind: "wrong-tool",
+      suggestedTool: "create_patch",
+      reason: "Destination is inside a richtext value. duplicate_source and empty_at_path do not handle richtext edits."
+    };
+  }
+  // `gallery-traversed` means the walk stepped INTO a gallery, so the
+  // destination is a gallery entry; `isGallery` catches the case where the
+  // parent IS the gallery and the destination is a new entry key in it.
+  if (parent.kind === "gallery-traversed" || isGallery(parent.schema)) {
+    return GALLERY_REDIRECT;
+  }
+  var schema = parent.schema;
+  if (schema.type === "array" || schema.type === "record") {
+    return {
+      kind: "ok",
+      op: "add",
+      parent: schema.type
+    };
+  }
+  if (schema.type === "object") {
+    return {
+      kind: "ok",
+      op: "replace",
+      parent: "object"
+    };
+  }
+  return {
+    kind: "error",
+    message: "Destination parent has schema type \"".concat(schema.type, "\" \u2014 cannot use duplicate_source/empty_at_path here. Use create_patch instead.")
+  };
+}
+function buildDuplicatePatch(args, moduleSchema, moduleSource) {
+  var value = getSourceAt(moduleSource, args.sourcePath);
+  if (value === undefined) {
+    return {
+      kind: "error",
+      message: "Source path ".concat(JSON.stringify(args.sourcePath), " does not exist in the module. Use get_source to inspect the current contents.")
+    };
+  }
+  var decision = decideOp(moduleSchema, args.destinationPath);
+  if (decision.kind === "wrong-tool") {
+    return {
+      kind: "wrong-tool",
+      suggestedTool: decision.suggestedTool,
+      reason: decision.reason
+    };
+  }
+  if (decision.kind === "error") {
+    return {
+      kind: "error",
+      message: decision.message
+    };
+  }
+  var occupied = refuseOccupiedRecordKey(decision.parent, moduleSource, args.destinationPath);
+  if (occupied) {
+    return occupied;
+  }
+  return safeParsePatch([{
+    op: decision.op,
+    path: args.destinationPath,
+    value: value
+  }]);
+}
+
+/**
+ * Refuse to write over an existing record entry.
+ *
+ * `add` into a record replaces whatever is at that key, so duplicating or
+ * scaffolding onto an occupied key silently destroys the entry that was there.
+ * A caller guessing at keys — an agent especially — hits this by accident, and
+ * nothing downstream reports it: the patch is valid, the content stays valid,
+ * and an entry is simply gone.
+ *
+ * Only records. An array `add` inserts before the index rather than replacing
+ * it, and an object's fields exist by definition, so `replace` on one is the
+ * whole point rather than a mistake.
+ */
+function refuseOccupiedRecordKey(parent, moduleSource, destinationPath) {
+  if (parent !== "record") {
+    return null;
+  }
+  if (getSourceAt(moduleSource, destinationPath) === undefined) {
+    return null;
+  }
+  var key = destinationPath[destinationPath.length - 1];
+  return {
+    kind: "error",
+    message: "Destination key ".concat(JSON.stringify(key), " already exists, and writing to it would replace the entry that is there. Pick a key that is free -- get_record_keys lists the ones in use -- or use create_patch if you meant to change the existing entry.")
+  };
+}
+function buildEmptyAtPathPatch(args, moduleSchema,
+// Required, not optional: the occupied-key check below is the only thing
+// standing between "scaffold an entry" and "delete the entry that was there",
+// and an optional argument is one a caller forgets.
+moduleSource) {
+  var destinationSchema;
+  if (args.destinationPath.length === 0) {
+    destinationSchema = moduleSchema;
+  } else {
+    var result = resolveSerializedSchemaAtPath(moduleSchema, args.destinationPath);
+    if (result.kind === "unresolved") {
+      return {
+        kind: "error",
+        message: "Destination path ".concat(JSON.stringify(args.destinationPath), " does not resolve in this module's schema.")
+      };
+    }
+    if (result.kind === "richtext") {
+      return {
+        kind: "wrong-tool",
+        suggestedTool: "create_patch",
+        reason: "Destination is a richtext value. Use create_patch to build richtext content."
+      };
+    }
+    if (result.kind === "gallery-traversed") {
+      return {
+        kind: "wrong-tool",
+        suggestedTool: "add_session_image_to_gallery",
+        reason: "Destination is inside an images gallery. Use add_session_image_to_gallery to add entries."
+      };
+    }
+    destinationSchema = result.schema;
+  }
+  var decision = decideOp(moduleSchema, args.destinationPath);
+  if (decision.kind === "wrong-tool") {
+    return {
+      kind: "wrong-tool",
+      suggestedTool: decision.suggestedTool,
+      reason: decision.reason
+    };
+  }
+  if (decision.kind === "error") {
+    return {
+      kind: "error",
+      message: decision.message
+    };
+  }
+  var occupied = refuseOccupiedRecordKey(decision.parent, moduleSource, args.destinationPath);
+  if (occupied) {
+    return occupied;
+  }
+  var value = emptyOf(destinationSchema);
+  return safeParsePatch([{
+    op: decision.op,
+    path: args.destinationPath,
+    value: value
+  }]);
+}
+
+/**
+ * What kind of container a path points at.
+ *
+ * `gallery` and `richtext` are called out separately from `record`/`array`
+ * because the two callers disagree about them: `count_entries` can count either,
+ * `get_record_keys` documents that it refuses both.
+ */
+
+/**
+ * Classifies the value at `path` using the SCHEMA, not just its runtime shape.
+ *
+ * The runtime shape is not enough: an `s.image()`/`s.file()` source, a richtext
+ * node and a union variant are all plain objects at runtime, so classifying by
+ * `typeof` alone let `get_record_keys` list a file ref's `_ref`/`_type` internals
+ * or a richtext node's `tag`/`children` as if they were record keys.
+ */
+function describeContainerAtPath(moduleSchema, moduleSource, path) {
+  var value = getSourceAt(moduleSource, path);
+  if (value === undefined) {
+    return {
+      kind: "error",
+      reason: "missing",
+      message: "Path ".concat(JSON.stringify(path), " does not exist in the module source. Use get_source to inspect the current contents.")
+    };
+  }
+  var resolved = resolveSerializedSchemaAtPath(moduleSchema, path);
+  if (resolved.kind === "unresolved") {
+    return {
+      kind: "error",
+      reason: "missing",
+      message: "Path ".concat(JSON.stringify(path), " does not resolve in this module's schema.")
+    };
+  }
+  if (resolved.kind === "richtext") {
+    // Mid-richtext: the path addresses a node inside the richtext value, whose
+    // internals (tag, children, ...) are not entries.
+    return {
+      kind: "error",
+      reason: "not-a-container",
+      message: "Path ".concat(JSON.stringify(path), " points inside a richtext value, which has no entries to count or list.")
+    };
+  }
+  if (resolved.kind === "gallery-traversed") {
+    return {
+      kind: "error",
+      reason: "not-a-container",
+      message: "Path ".concat(JSON.stringify(path), " points inside a gallery entry, which has no entries to count or list.")
+    };
+  }
+  var schema = resolved.schema;
+  if (schema.type === "richtext") {
+    if (!Array.isArray(value)) {
+      return {
+        kind: "error",
+        reason: "not-a-container",
+        message: "Path ".concat(JSON.stringify(path), " is a richtext value but its source is not a block array.")
+      };
+    }
+    return {
+      kind: "ok",
+      container: "richtext",
+      value: value
+    };
+  }
+  if (schema.type === "array") {
+    if (!Array.isArray(value)) {
+      return {
+        kind: "error",
+        reason: "not-a-container",
+        message: "Path ".concat(JSON.stringify(path), " is an array in the schema but its source is not an array.")
+      };
+    }
+    return {
+      kind: "ok",
+      container: "array",
+      value: value
+    };
+  }
+  if (schema.type === "record" || schema.type === "object") {
+    if (value === null || _typeof(value) !== "object" || Array.isArray(value)) {
+      return {
+        kind: "error",
+        reason: "not-a-container",
+        message: "Path ".concat(JSON.stringify(path), " points to a ").concat(value === null ? "null" : Array.isArray(value) ? "array" : _typeof(value), " value, which has no entries to count or list.")
+      };
+    }
+    return {
+      kind: "ok",
+      container: schema.type === "record" ? isGallery(schema) ? "gallery" : "record" : "object",
+      value: value
+    };
+  }
+  // image / file / union / string / number / boolean / date / literal / keyOf /
+  // route: not containers, whatever their runtime shape looks like.
+  return {
+    kind: "error",
+    reason: "not-a-container",
+    message: "Path ".concat(JSON.stringify(path), " points to a \"").concat(schema.type, "\" value, which has no entries to count or list.")
+  };
+}
+
+/**
+ * Partition validation errors by whether the UI should surface them.
+ *
+ * `skipped` errors carry only fix codes the user can't (or shouldn't) act on
+ * in the browser:
+ *   - image/file metadata checks (need to read bytes from disk)
+ *   - remote upload/download/check (need a personal access token + network)
+ *   - gallery directory uniqueness + untracked-files checks (need fs traversal)
+ *
+ * The server (ValOps + createFixPatch) resolves all of these automatically on
+ * save, and the CLI's `runValidation` does the same. So the user never needs
+ * to see them in the studio — but we keep them in the `skipped` partition,
+ * not dropped, so we can later surface a "N fixes pending — saving will
+ * repair them" badge or wire up an explicit "fix all" affordance without
+ * having to plumb the data back in.
+ *
+ * `keyof:check-keys` and `router:check-route` are surfaced if they reach
+ * this function — they're meant to be resolved upfront by the shared
+ * `resolveSchemaSourceFixes`. A remnant here means resolution didn't run
+ * for some reason; the user-facing "Invalid key/route" message is more
+ * useful than silent hiding.
+ */
+function partitionValidationErrors(validationErrors) {
+  var surfaced = {};
+  var skipped = {};
+  for (var sourcePathS in validationErrors) {
+    var sourcePath = sourcePathS;
+    var _iterator = _createForOfIteratorHelper(validationErrors[sourcePath]),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var error = _step.value;
+        if (isSkippedFix(error)) {
+          var _skipped$sourcePath;
+          ((_skipped$sourcePath = skipped[sourcePath]) !== null && _skipped$sourcePath !== void 0 ? _skipped$sourcePath : skipped[sourcePath] = []).push(error);
+        } else {
+          var _surfaced$sourcePath;
+          ((_surfaced$sourcePath = surfaced[sourcePath]) !== null && _surfaced$sourcePath !== void 0 ? _surfaced$sourcePath : surfaced[sourcePath] = []).push(error);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return {
+    surfaced: surfaced,
+    skipped: skipped
+  };
+}
+function isSkippedFix(error) {
+  var _error$fixes;
+  var fixes = (_error$fixes = error.fixes) !== null && _error$fixes !== void 0 ? _error$fixes : [];
+  if (fixes.length === 0) return false;
+  // Skip iff EVERY fix on the error is in the skip set — an error tagged
+  // with both a surfaceable and a skippable fix must still be shown.
+  return fixes.every(isSkippableFixCode);
+}
+function isSkippableFixCode(fix) {
+  switch (fix) {
+    case "image:add-metadata":
+    case "image:check-metadata":
+    case "image:upload-remote":
+    case "image:download-remote":
+    case "image:check-remote":
+    case "images:check-remote":
+    case "images:upload-remote":
+    case "file:add-metadata":
+    case "file:check-metadata":
+    case "file:upload-remote":
+    case "file:download-remote":
+    case "file:check-remote":
+    case "files:check-remote":
+    case "files:upload-remote":
+    case "images:check-unique-folder":
+    case "files:check-unique-folder":
+    case "images:check-all-files":
+    case "files:check-all-files":
+      return true;
+    case "keyof:check-keys":
+    case "router:check-route":
+    case "jsonValues:extract-entry":
+      // `jsonValues:extract-entry` is an entry inlined in the `.val.ts`. The
+      // browser cannot fix it (that means writing a new `*.val.json` and
+      // 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;
+    default:
+      {
+        return false;
+      }
+  }
+}
+
+/**
+ * The errors a user must actually act on.
+ *
+ * Two passes stand between a schema's complaint and something worth blocking a
+ * publish for:
+ *
+ * - `resolveSchemaSourceFixes` resolves the CROSS-MODULE fixes —
+ *   `keyof:check-keys` and `router:check-route` — against the live schema and
+ *   source. Unresolved, those arrive as "This error should typically be
+ *   processed by Val internally. Seeing this error most likely means you have a
+ *   Val version mismatch", which is not something a user can do anything with.
+ * - `partitionValidationErrors` drops the fixes the SERVER applies on save:
+ *   image and file metadata, remote files, gallery directory checks. Blocking on
+ *   those would refuse a publish for something the publish itself repairs.
+ *
+ * ## Everything that gates on validation must use this
+ *
+ * That is the whole reason it lives in `validation/` rather than beside one of
+ * its callers. There are three: the errors a field shows, the AI flow's check on
+ * a proposed patch, and — the one that bites — `system.publish`. A publish gate
+ * reading raw errors refuses on `router:check-route` for every route module in
+ * the project, which is a Save button that does nothing and says
+ * "validation-errors" with no error visible anywhere on screen.
+ */
+function filterBlockingValidationErrors(validationErrors, schemas, sources) {
+  var resolved = resolveSchemaSourceFixes(validationErrors, {
+    schemas: schemas !== null && schemas !== void 0 ? schemas : {},
+    sources: sources !== null && sources !== void 0 ? sources : {}
+  });
+  return partitionValidationErrors(resolved).surfaced;
+}
+
 exports.Api = Api;
 exports.CodeOptions = CodeOptions;
 exports.ColorOptions = ColorOptions;
@@ -3515,25 +4251,40 @@ exports.VAL_STATE_COOKIE = VAL_STATE_COOKIE;
 exports.VAL_THEME_SESSION_STORAGE_KEY = VAL_THEME_SESSION_STORAGE_KEY;
 exports.ValCommit = ValCommit;
 exports.ValDeployment = ValDeployment;
+exports.buildDuplicatePatch = buildDuplicatePatch;
+exports.buildEmptyAtPathPatch = buildEmptyAtPathPatch;
+exports.buildFileRefValue = buildFileRefValue;
+exports.buildImageGalleryPatch = buildImageGalleryPatch;
+exports.buildRemoveImageGalleryEntryPatch = buildRemoveImageGalleryEntryPatch;
 exports.createRegExpFromPattern = createRegExpFromPattern;
 exports.createValClient = createValClient;
+exports.describeContainerAtPath = describeContainerAtPath;
+exports.emptyOf = emptyOf;
+exports.filterBlockingValidationErrors = filterBlockingValidationErrors;
 exports.filterRoutesByPatterns = filterRoutesByPatterns;
 exports.findSimilar = findSimilar;
 exports.getErrorMessageFromUnknownJson = getErrorMessageFromUnknownJson;
+exports.getInlineImgInfo = getInlineImgInfo;
 exports.getNextAppRouterSitemapTree = getNextAppRouterSitemapTree;
 exports.getNextAppRouterSourceFolder = getNextAppRouterSourceFolder;
 exports.getPatternFromModuleFilePath = getPatternFromModuleFilePath;
 exports.getRoutesOf = getRoutesOf;
 exports.getRoutesWithModulePaths = getRoutesWithModulePaths;
+exports.getSourceAt = getSourceAt;
+exports.isRemoteSchema = isRemoteSchema;
 exports.isValCanvasFrame = isValCanvasFrame;
 exports.isValCanvasPageMessage = isValCanvasPageMessage;
 exports.isValCanvasStudioMessage = isValCanvasStudioMessage;
 exports.levenshtein = levenshtein;
 exports.parseRoutePattern = parseRoutePattern;
+exports.partitionValidationErrors = partitionValidationErrors;
 exports.remirrorToRichTextSource = remirrorToRichTextSource;
 exports.resolveSchemaSourceFixForError = resolveSchemaSourceFixForError;
 exports.resolveSchemaSourceFixes = resolveSchemaSourceFixes;
+exports.resolveSerializedSchemaAtPath = resolveSerializedSchemaAtPath;
 exports.richTextToRemirror = richTextToRemirror;
+exports.safeParsePatch = safeParsePatch;
+exports.toolNames = toolNames;
 exports.urlOf = urlOf;
 exports.validateRoutePatterns = validateRoutePatterns;
 exports.withValCanvasParam = withValCanvasParam;