@valbuild/core 0.78.3 → 0.79.1

package/dist/declarations/src/index.d.ts

@@ -20,7 +20,7 @@ export { FILE_REF_PROP, FILE_REF_SUBTYPE_TAG } from "./source/file.js";
 export { VAL_EXTENSION, type SourceArray } from "./source/index.js";
 export { derefPatch } from "./patch/deref.js";
 export { type SelectorSource, type SelectorOf, GenericSelector, } from "./selector/index.js";
-import { getSource, splitModulePath, splitModuleFilePath, resolvePath, splitModuleFilePathAndModulePath, joinModuleFilePathAndModulePath, parentOfSourcePath, patchPathToModulePath, splitJoinedSourcePaths } from "./module.js";
+import { getSource, splitModulePath, splitModuleFilePath, resolvePath, safeResolvePath, splitModuleFilePathAndModulePath, joinModuleFilePathAndModulePath, parentOfSourcePath, patchPathToModulePath, splitJoinedSourcePaths } from "./module.js";
 declare const ModuleFilePathSep = "?p=";
 export { ModuleFilePathSep };
 import { getSchema } from "./selector/index.js";
@@ -67,6 +67,7 @@ declare const Internal: {
     getValPath: typeof getValPath;
     getSource: typeof getSource;
     resolvePath: typeof resolvePath;
+    safeResolvePath: typeof safeResolvePath;
     splitModuleFilePathAndModulePath: typeof splitModuleFilePathAndModulePath;
     joinModuleFilePathAndModulePath: typeof joinModuleFilePathAndModulePath;
     remote: {

package/dist/declarations/src/module.d.ts

@@ -28,6 +28,18 @@ export declare function resolvePath<Src extends ValModule<SelectorSource> | Sour
     schema: Sch;
     source: Src;
 };
+export declare function safeResolvePath<Src extends ValModule<SelectorSource> | Source, Sch extends Schema<SelectorSource> | SerializedSchema>(path: ModulePath, valModule: Src, schema: Sch): {
+    status: "ok";
+    path: SourcePath;
+    schema: Sch;
+    source: Src;
+} | {
+    status: "source-undefined";
+    path: SourcePath;
+} | {
+    status: "error";
+    message: string;
+};
 export declare function splitModuleFilePath(input: ModuleFilePath): string[];
 export declare function splitModulePath(input: ModulePath): string[];
 export declare function splitJoinedSourcePaths(input: string): SourcePath[];

package/dist/declarations/src/preview.d.ts

@@ -1,6 +1,8 @@
 import { Schema } from "./schema/index.js";
+import { ImageMetadata } from "./schema/image.js";
 import { SelectorSource } from "./selector/index.js";
 import { ImageSource } from "./source/image.js";
+import { RemoteSource } from "./source/remote.js";
 import { ModuleFilePath, SourcePath } from "./val/index.js";
 export type ListRecordPreview = {
     layout: "list";
@@ -10,7 +12,7 @@ export type ListRecordPreview = {
         value: {
             title: string;
             subtitle?: string | null;
-            image?: ImageSource | null;
+            image?: ImageSource | RemoteSource<ImageMetadata> | null;
         }
     ][];
 };
@@ -20,7 +22,7 @@ export type ListArrayPreview = {
     items: {
         title: string;
         subtitle?: string | null;
-        image?: ImageSource | null;
+        image?: ImageSource | RemoteSource<ImageMetadata> | null;
     }[];
 };
 type PreviewTypes = ListRecordPreview | ListArrayPreview;

package/dist/declarations/src/schema/record.d.ts

@@ -2,7 +2,9 @@ import { Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "
 import { PreviewSelector, ReifiedPreview } from "../preview.js";
 import { SelectorSource } from "../selector/index.js";
 import { ImageSource } from "../source/image.js";
+import { RemoteSource } from "../source/remote.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
+import { ImageMetadata } from "./image.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedRecordSchema = {
     type: "record";
@@ -27,7 +29,7 @@ export declare class RecordSchema<T extends Schema<SelectorSource>, Src extends
         }) => {
             title: string;
             subtitle?: string | null;
-            image?: ImageSource | null;
+            image?: ImageSource | RemoteSource<ImageMetadata> | null;
         };
     }): this;
 }

package/dist/{index-2e346d06.cjs.dev.js → index-041f7675.cjs.dev.js}

@@ -1589,7 +1589,7 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new ImageSchema(this.options, true);
+      return new ImageSchema(this.options, true, this.isRemote);
     }
   }, {
     key: "serialize",
@@ -2438,6 +2438,233 @@ function resolvePath(path, valModule, schema) {
     source: resolvedSource
   };
 }
+
+// TODO: replace all usages of resolvePath with safeResolvePath
+function safeResolvePath(path, valModule, schema) {
+  var parts = splitModulePath(path);
+  var origParts = _toConsumableArray(parts);
+  var resolvedSchema = schema;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var resolvedSource = valModule;
+  var _loop2 = function _loop2() {
+      var part = parts.shift();
+      if (part === undefined) {
+        return {
+          v: {
+            status: "error",
+            message: "Unexpected undefined part"
+          }
+        };
+      }
+      if (isArraySchema(resolvedSchema)) {
+        if (Number.isNaN(Number(part))) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: array schema ".concat(JSON.stringify(resolvedSchema), " must have a number as path, but got ").concat(part, ". Path: ").concat(path)
+            }
+          };
+        }
+        if (resolvedSource === undefined) {
+          return {
+            v: {
+              status: "source-undefined",
+              path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+                return JSON.stringify(p);
+              }).join(".") // TODO: create a function generate path from parts (not sure if this always works)
+            }
+          };
+        }
+        if (_typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
+          return {
+            v: {
+              status: "error",
+              message: "Schema type error: expected source to be type of array, but got ".concat(_typeof(resolvedSource))
+            }
+          };
+        }
+        resolvedSource = resolvedSource[part];
+        resolvedSchema = resolvedSchema.item;
+      } else if (isRecordSchema(resolvedSchema)) {
+        if (typeof part !== "string") {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: record schema ".concat(resolvedSchema, " must have path: ").concat(part, " as string")
+            }
+          };
+        }
+        if (resolvedSource === undefined) {
+          return {
+            v: {
+              status: "source-undefined",
+              path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+                return JSON.stringify(p);
+              }).join(".") // TODO: create a function generate path from parts (not sure if this always works)
+            }
+          };
+        }
+        if (_typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
+          return {
+            v: {
+              status: "error",
+              message: "Schema type error: expected source to be type of record, but got ".concat(_typeof(resolvedSource))
+            }
+          };
+        }
+        if (!resolvedSource[part]) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: record source did not have key ".concat(part, " from path: ").concat(path)
+            }
+          };
+        }
+        resolvedSource = resolvedSource[part];
+        resolvedSchema = resolvedSchema.item;
+      } else if (isObjectSchema(resolvedSchema)) {
+        if (resolvedSource === undefined) {
+          return {
+            v: {
+              status: "source-undefined",
+              path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+                return JSON.stringify(p);
+              }).join(".") // TODO: create a function generate path from parts (not sure if this always works)
+            }
+          };
+        }
+        if (_typeof(resolvedSource) !== "object") {
+          return {
+            v: {
+              status: "error",
+              message: "Schema type error: expected source to be type of object, but got ".concat(_typeof(resolvedSource))
+            }
+          };
+        }
+        if (resolvedSource !== null && resolvedSource[part] === undefined) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: object source did not have key ".concat(part, " from path: ").concat(path)
+            }
+          };
+        }
+        resolvedSource = resolvedSource === null ? resolvedSource : resolvedSource[part];
+        resolvedSchema = resolvedSchema.items[part];
+        // } else if (isI18nSchema(resolvedSchema)) {
+        //   if (!resolvedSchema.locales.includes(part)) {
+        //     throw Error(
+        //       `Invalid path: i18n schema ${resolvedSchema} supports locales ${resolvedSchema.locales.join(
+        //         ", "
+        //       )}, but found: ${part}`
+        //     );
+        //   }
+        //   if (!Object.keys(resolvedSource).includes(part)) {
+        //     throw Error(
+        //       `Schema type error: expected source to be type of i18n with locale ${part}, but got ${JSON.stringify(
+        //         Object.keys(resolvedSource)
+        //       )}`
+        //     );
+        //   }
+        //   resolvedSource = resolvedSource[part];
+        //   resolvedSchema = resolvedSchema.item;
+      } else if (isImageSchema(resolvedSchema)) {
+        return {
+          v: {
+            status: "ok",
+            path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+              return JSON.stringify(p);
+            }).join("."),
+            // TODO: create a function generate path from parts (not sure if this always works)
+            schema: resolvedSchema,
+            source: resolvedSource
+          }
+        };
+      } else if (isUnionSchema(resolvedSchema)) {
+        var _key2 = resolvedSchema.key;
+        if (typeof _key2 !== "string") {
+          return {
+            v: {
+              status: "ok",
+              path: origParts.map(function (p) {
+                if (!Number.isNaN(Number(p))) {
+                  return p;
+                } else {
+                  return JSON.stringify(p);
+                }
+              }).join("."),
+              // TODO: create a function generate path from parts (not sure if this always works)
+              schema: resolvedSchema,
+              source: resolvedSource
+            }
+          };
+        }
+        var keyValue = resolvedSource[_key2];
+        if (!keyValue) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: union source ".concat(resolvedSchema, " did not have required key ").concat(_key2, " in path: ").concat(path)
+            }
+          };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var schemaOfUnionKey = resolvedSchema.items.find(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function (child) {
+          var _child$items2;
+          return (child === null || child === void 0 || (_child$items2 = child.items) === null || _child$items2 === void 0 || (_child$items2 = _child$items2[_key2]) === null || _child$items2 === void 0 ? void 0 : _child$items2.value) === keyValue;
+        });
+        if (!schemaOfUnionKey) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: union schema ".concat(resolvedSchema, " did not have a child object with ").concat(_key2, " of value ").concat(keyValue, " in path: ").concat(path)
+            }
+          };
+        }
+        resolvedSchema = schemaOfUnionKey.items[part];
+        resolvedSource = resolvedSource[part];
+      } else if (isRichTextSchema(resolvedSchema)) {
+        if ("src" in resolvedSource && "tag" in resolvedSource && resolvedSource.tag === "img" && parts.length === 0) {
+          var _resolvedSchema$optio3, _resolvedSchema$optio4;
+          resolvedSchema = (_resolvedSchema$optio3 = resolvedSchema.options) !== null && _resolvedSchema$optio3 !== void 0 && (_resolvedSchema$optio3 = _resolvedSchema$optio3.inline) !== null && _resolvedSchema$optio3 !== void 0 && _resolvedSchema$optio3.img && typeof ((_resolvedSchema$optio4 = resolvedSchema.options) === null || _resolvedSchema$optio4 === void 0 || (_resolvedSchema$optio4 = _resolvedSchema$optio4.inline) === null || _resolvedSchema$optio4 === void 0 ? void 0 : _resolvedSchema$optio4.img) !== "boolean" ? resolvedSchema.options.inline.img : resolvedSchema;
+        }
+        resolvedSource = resolvedSource[part];
+      } else {
+        return {
+          v: {
+            status: "error",
+            message: "Invalid path: ".concat(part, " resolved to an unexpected schema ").concat(JSON.stringify(resolvedSchema))
+          }
+        };
+      }
+    },
+    _ret2;
+  while (parts.length > 0) {
+    _ret2 = _loop2();
+    if (_ret2) return _ret2.v;
+  }
+  if (parts.length > 0) {
+    return {
+      status: "error",
+      message: "Invalid path: ".concat(parts.join("."), " is not a valid path")
+    };
+  }
+  return {
+    status: "ok",
+    path: origParts.map(function (p) {
+      if (!Number.isNaN(Number(p))) {
+        return p;
+      } else {
+        return JSON.stringify(p);
+      }
+    }).join("."),
+    // TODO: create a function generate path from parts (not sure if this always works)
+    schema: resolvedSchema,
+    source: resolvedSource
+  };
+}
 function splitModuleFilePath(input) {
   var parts = input.split("/").slice(1);
   return parts;
@@ -4639,6 +4866,7 @@ var Internal = {
   getValPath: getValPath,
   getSource: getSource,
   resolvePath: resolvePath,
+  safeResolvePath: safeResolvePath,
   splitModuleFilePathAndModulePath: splitModuleFilePathAndModulePath,
   joinModuleFilePathAndModulePath: joinModuleFilePathAndModulePath,
   remote: {

package/dist/{index-b59ab889.esm.js → index-1d5e4912.esm.js}

@@ -1587,7 +1587,7 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new ImageSchema(this.options, true);
+      return new ImageSchema(this.options, true, this.isRemote);
     }
   }, {
     key: "serialize",
@@ -2436,6 +2436,233 @@ function resolvePath(path, valModule, schema) {
     source: resolvedSource
   };
 }
+
+// TODO: replace all usages of resolvePath with safeResolvePath
+function safeResolvePath(path, valModule, schema) {
+  var parts = splitModulePath(path);
+  var origParts = _toConsumableArray(parts);
+  var resolvedSchema = schema;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var resolvedSource = valModule;
+  var _loop2 = function _loop2() {
+      var part = parts.shift();
+      if (part === undefined) {
+        return {
+          v: {
+            status: "error",
+            message: "Unexpected undefined part"
+          }
+        };
+      }
+      if (isArraySchema(resolvedSchema)) {
+        if (Number.isNaN(Number(part))) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: array schema ".concat(JSON.stringify(resolvedSchema), " must have a number as path, but got ").concat(part, ". Path: ").concat(path)
+            }
+          };
+        }
+        if (resolvedSource === undefined) {
+          return {
+            v: {
+              status: "source-undefined",
+              path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+                return JSON.stringify(p);
+              }).join(".") // TODO: create a function generate path from parts (not sure if this always works)
+            }
+          };
+        }
+        if (_typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
+          return {
+            v: {
+              status: "error",
+              message: "Schema type error: expected source to be type of array, but got ".concat(_typeof(resolvedSource))
+            }
+          };
+        }
+        resolvedSource = resolvedSource[part];
+        resolvedSchema = resolvedSchema.item;
+      } else if (isRecordSchema(resolvedSchema)) {
+        if (typeof part !== "string") {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: record schema ".concat(resolvedSchema, " must have path: ").concat(part, " as string")
+            }
+          };
+        }
+        if (resolvedSource === undefined) {
+          return {
+            v: {
+              status: "source-undefined",
+              path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+                return JSON.stringify(p);
+              }).join(".") // TODO: create a function generate path from parts (not sure if this always works)
+            }
+          };
+        }
+        if (_typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
+          return {
+            v: {
+              status: "error",
+              message: "Schema type error: expected source to be type of record, but got ".concat(_typeof(resolvedSource))
+            }
+          };
+        }
+        if (!resolvedSource[part]) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: record source did not have key ".concat(part, " from path: ").concat(path)
+            }
+          };
+        }
+        resolvedSource = resolvedSource[part];
+        resolvedSchema = resolvedSchema.item;
+      } else if (isObjectSchema(resolvedSchema)) {
+        if (resolvedSource === undefined) {
+          return {
+            v: {
+              status: "source-undefined",
+              path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+                return JSON.stringify(p);
+              }).join(".") // TODO: create a function generate path from parts (not sure if this always works)
+            }
+          };
+        }
+        if (_typeof(resolvedSource) !== "object") {
+          return {
+            v: {
+              status: "error",
+              message: "Schema type error: expected source to be type of object, but got ".concat(_typeof(resolvedSource))
+            }
+          };
+        }
+        if (resolvedSource !== null && resolvedSource[part] === undefined) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: object source did not have key ".concat(part, " from path: ").concat(path)
+            }
+          };
+        }
+        resolvedSource = resolvedSource === null ? resolvedSource : resolvedSource[part];
+        resolvedSchema = resolvedSchema.items[part];
+        // } else if (isI18nSchema(resolvedSchema)) {
+        //   if (!resolvedSchema.locales.includes(part)) {
+        //     throw Error(
+        //       `Invalid path: i18n schema ${resolvedSchema} supports locales ${resolvedSchema.locales.join(
+        //         ", "
+        //       )}, but found: ${part}`
+        //     );
+        //   }
+        //   if (!Object.keys(resolvedSource).includes(part)) {
+        //     throw Error(
+        //       `Schema type error: expected source to be type of i18n with locale ${part}, but got ${JSON.stringify(
+        //         Object.keys(resolvedSource)
+        //       )}`
+        //     );
+        //   }
+        //   resolvedSource = resolvedSource[part];
+        //   resolvedSchema = resolvedSchema.item;
+      } else if (isImageSchema(resolvedSchema)) {
+        return {
+          v: {
+            status: "ok",
+            path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+              return JSON.stringify(p);
+            }).join("."),
+            // TODO: create a function generate path from parts (not sure if this always works)
+            schema: resolvedSchema,
+            source: resolvedSource
+          }
+        };
+      } else if (isUnionSchema(resolvedSchema)) {
+        var _key2 = resolvedSchema.key;
+        if (typeof _key2 !== "string") {
+          return {
+            v: {
+              status: "ok",
+              path: origParts.map(function (p) {
+                if (!Number.isNaN(Number(p))) {
+                  return p;
+                } else {
+                  return JSON.stringify(p);
+                }
+              }).join("."),
+              // TODO: create a function generate path from parts (not sure if this always works)
+              schema: resolvedSchema,
+              source: resolvedSource
+            }
+          };
+        }
+        var keyValue = resolvedSource[_key2];
+        if (!keyValue) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: union source ".concat(resolvedSchema, " did not have required key ").concat(_key2, " in path: ").concat(path)
+            }
+          };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var schemaOfUnionKey = resolvedSchema.items.find(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function (child) {
+          var _child$items2;
+          return (child === null || child === void 0 || (_child$items2 = child.items) === null || _child$items2 === void 0 || (_child$items2 = _child$items2[_key2]) === null || _child$items2 === void 0 ? void 0 : _child$items2.value) === keyValue;
+        });
+        if (!schemaOfUnionKey) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: union schema ".concat(resolvedSchema, " did not have a child object with ").concat(_key2, " of value ").concat(keyValue, " in path: ").concat(path)
+            }
+          };
+        }
+        resolvedSchema = schemaOfUnionKey.items[part];
+        resolvedSource = resolvedSource[part];
+      } else if (isRichTextSchema(resolvedSchema)) {
+        if ("src" in resolvedSource && "tag" in resolvedSource && resolvedSource.tag === "img" && parts.length === 0) {
+          var _resolvedSchema$optio3, _resolvedSchema$optio4;
+          resolvedSchema = (_resolvedSchema$optio3 = resolvedSchema.options) !== null && _resolvedSchema$optio3 !== void 0 && (_resolvedSchema$optio3 = _resolvedSchema$optio3.inline) !== null && _resolvedSchema$optio3 !== void 0 && _resolvedSchema$optio3.img && typeof ((_resolvedSchema$optio4 = resolvedSchema.options) === null || _resolvedSchema$optio4 === void 0 || (_resolvedSchema$optio4 = _resolvedSchema$optio4.inline) === null || _resolvedSchema$optio4 === void 0 ? void 0 : _resolvedSchema$optio4.img) !== "boolean" ? resolvedSchema.options.inline.img : resolvedSchema;
+        }
+        resolvedSource = resolvedSource[part];
+      } else {
+        return {
+          v: {
+            status: "error",
+            message: "Invalid path: ".concat(part, " resolved to an unexpected schema ").concat(JSON.stringify(resolvedSchema))
+          }
+        };
+      }
+    },
+    _ret2;
+  while (parts.length > 0) {
+    _ret2 = _loop2();
+    if (_ret2) return _ret2.v;
+  }
+  if (parts.length > 0) {
+    return {
+      status: "error",
+      message: "Invalid path: ".concat(parts.join("."), " is not a valid path")
+    };
+  }
+  return {
+    status: "ok",
+    path: origParts.map(function (p) {
+      if (!Number.isNaN(Number(p))) {
+        return p;
+      } else {
+        return JSON.stringify(p);
+      }
+    }).join("."),
+    // TODO: create a function generate path from parts (not sure if this always works)
+    schema: resolvedSchema,
+    source: resolvedSource
+  };
+}
 function splitModuleFilePath(input) {
   var parts = input.split("/").slice(1);
   return parts;
@@ -4637,6 +4864,7 @@ var Internal = {
   getValPath: getValPath,
   getSource: getSource,
   resolvePath: resolvePath,
+  safeResolvePath: safeResolvePath,
   splitModuleFilePathAndModulePath: splitModuleFilePathAndModulePath,
   joinModuleFilePathAndModulePath: joinModuleFilePathAndModulePath,
   remote: {

package/dist/{index-047950e1.cjs.prod.js → index-3ecf0ca6.cjs.prod.js}

@@ -1589,7 +1589,7 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new ImageSchema(this.options, true);
+      return new ImageSchema(this.options, true, this.isRemote);
     }
   }, {
     key: "serialize",
@@ -2438,6 +2438,233 @@ function resolvePath(path, valModule, schema) {
     source: resolvedSource
   };
 }
+
+// TODO: replace all usages of resolvePath with safeResolvePath
+function safeResolvePath(path, valModule, schema) {
+  var parts = splitModulePath(path);
+  var origParts = _toConsumableArray(parts);
+  var resolvedSchema = schema;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var resolvedSource = valModule;
+  var _loop2 = function _loop2() {
+      var part = parts.shift();
+      if (part === undefined) {
+        return {
+          v: {
+            status: "error",
+            message: "Unexpected undefined part"
+          }
+        };
+      }
+      if (isArraySchema(resolvedSchema)) {
+        if (Number.isNaN(Number(part))) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: array schema ".concat(JSON.stringify(resolvedSchema), " must have a number as path, but got ").concat(part, ". Path: ").concat(path)
+            }
+          };
+        }
+        if (resolvedSource === undefined) {
+          return {
+            v: {
+              status: "source-undefined",
+              path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+                return JSON.stringify(p);
+              }).join(".") // TODO: create a function generate path from parts (not sure if this always works)
+            }
+          };
+        }
+        if (_typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
+          return {
+            v: {
+              status: "error",
+              message: "Schema type error: expected source to be type of array, but got ".concat(_typeof(resolvedSource))
+            }
+          };
+        }
+        resolvedSource = resolvedSource[part];
+        resolvedSchema = resolvedSchema.item;
+      } else if (isRecordSchema(resolvedSchema)) {
+        if (typeof part !== "string") {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: record schema ".concat(resolvedSchema, " must have path: ").concat(part, " as string")
+            }
+          };
+        }
+        if (resolvedSource === undefined) {
+          return {
+            v: {
+              status: "source-undefined",
+              path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+                return JSON.stringify(p);
+              }).join(".") // TODO: create a function generate path from parts (not sure if this always works)
+            }
+          };
+        }
+        if (_typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
+          return {
+            v: {
+              status: "error",
+              message: "Schema type error: expected source to be type of record, but got ".concat(_typeof(resolvedSource))
+            }
+          };
+        }
+        if (!resolvedSource[part]) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: record source did not have key ".concat(part, " from path: ").concat(path)
+            }
+          };
+        }
+        resolvedSource = resolvedSource[part];
+        resolvedSchema = resolvedSchema.item;
+      } else if (isObjectSchema(resolvedSchema)) {
+        if (resolvedSource === undefined) {
+          return {
+            v: {
+              status: "source-undefined",
+              path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+                return JSON.stringify(p);
+              }).join(".") // TODO: create a function generate path from parts (not sure if this always works)
+            }
+          };
+        }
+        if (_typeof(resolvedSource) !== "object") {
+          return {
+            v: {
+              status: "error",
+              message: "Schema type error: expected source to be type of object, but got ".concat(_typeof(resolvedSource))
+            }
+          };
+        }
+        if (resolvedSource !== null && resolvedSource[part] === undefined) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: object source did not have key ".concat(part, " from path: ").concat(path)
+            }
+          };
+        }
+        resolvedSource = resolvedSource === null ? resolvedSource : resolvedSource[part];
+        resolvedSchema = resolvedSchema.items[part];
+        // } else if (isI18nSchema(resolvedSchema)) {
+        //   if (!resolvedSchema.locales.includes(part)) {
+        //     throw Error(
+        //       `Invalid path: i18n schema ${resolvedSchema} supports locales ${resolvedSchema.locales.join(
+        //         ", "
+        //       )}, but found: ${part}`
+        //     );
+        //   }
+        //   if (!Object.keys(resolvedSource).includes(part)) {
+        //     throw Error(
+        //       `Schema type error: expected source to be type of i18n with locale ${part}, but got ${JSON.stringify(
+        //         Object.keys(resolvedSource)
+        //       )}`
+        //     );
+        //   }
+        //   resolvedSource = resolvedSource[part];
+        //   resolvedSchema = resolvedSchema.item;
+      } else if (isImageSchema(resolvedSchema)) {
+        return {
+          v: {
+            status: "ok",
+            path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+              return JSON.stringify(p);
+            }).join("."),
+            // TODO: create a function generate path from parts (not sure if this always works)
+            schema: resolvedSchema,
+            source: resolvedSource
+          }
+        };
+      } else if (isUnionSchema(resolvedSchema)) {
+        var _key2 = resolvedSchema.key;
+        if (typeof _key2 !== "string") {
+          return {
+            v: {
+              status: "ok",
+              path: origParts.map(function (p) {
+                if (!Number.isNaN(Number(p))) {
+                  return p;
+                } else {
+                  return JSON.stringify(p);
+                }
+              }).join("."),
+              // TODO: create a function generate path from parts (not sure if this always works)
+              schema: resolvedSchema,
+              source: resolvedSource
+            }
+          };
+        }
+        var keyValue = resolvedSource[_key2];
+        if (!keyValue) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: union source ".concat(resolvedSchema, " did not have required key ").concat(_key2, " in path: ").concat(path)
+            }
+          };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var schemaOfUnionKey = resolvedSchema.items.find(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function (child) {
+          var _child$items2;
+          return (child === null || child === void 0 || (_child$items2 = child.items) === null || _child$items2 === void 0 || (_child$items2 = _child$items2[_key2]) === null || _child$items2 === void 0 ? void 0 : _child$items2.value) === keyValue;
+        });
+        if (!schemaOfUnionKey) {
+          return {
+            v: {
+              status: "error",
+              message: "Invalid path: union schema ".concat(resolvedSchema, " did not have a child object with ").concat(_key2, " of value ").concat(keyValue, " in path: ").concat(path)
+            }
+          };
+        }
+        resolvedSchema = schemaOfUnionKey.items[part];
+        resolvedSource = resolvedSource[part];
+      } else if (isRichTextSchema(resolvedSchema)) {
+        if ("src" in resolvedSource && "tag" in resolvedSource && resolvedSource.tag === "img" && parts.length === 0) {
+          var _resolvedSchema$optio3, _resolvedSchema$optio4;
+          resolvedSchema = (_resolvedSchema$optio3 = resolvedSchema.options) !== null && _resolvedSchema$optio3 !== void 0 && (_resolvedSchema$optio3 = _resolvedSchema$optio3.inline) !== null && _resolvedSchema$optio3 !== void 0 && _resolvedSchema$optio3.img && typeof ((_resolvedSchema$optio4 = resolvedSchema.options) === null || _resolvedSchema$optio4 === void 0 || (_resolvedSchema$optio4 = _resolvedSchema$optio4.inline) === null || _resolvedSchema$optio4 === void 0 ? void 0 : _resolvedSchema$optio4.img) !== "boolean" ? resolvedSchema.options.inline.img : resolvedSchema;
+        }
+        resolvedSource = resolvedSource[part];
+      } else {
+        return {
+          v: {
+            status: "error",
+            message: "Invalid path: ".concat(part, " resolved to an unexpected schema ").concat(JSON.stringify(resolvedSchema))
+          }
+        };
+      }
+    },
+    _ret2;
+  while (parts.length > 0) {
+    _ret2 = _loop2();
+    if (_ret2) return _ret2.v;
+  }
+  if (parts.length > 0) {
+    return {
+      status: "error",
+      message: "Invalid path: ".concat(parts.join("."), " is not a valid path")
+    };
+  }
+  return {
+    status: "ok",
+    path: origParts.map(function (p) {
+      if (!Number.isNaN(Number(p))) {
+        return p;
+      } else {
+        return JSON.stringify(p);
+      }
+    }).join("."),
+    // TODO: create a function generate path from parts (not sure if this always works)
+    schema: resolvedSchema,
+    source: resolvedSource
+  };
+}
 function splitModuleFilePath(input) {
   var parts = input.split("/").slice(1);
   return parts;
@@ -4639,6 +4866,7 @@ var Internal = {
   getValPath: getValPath,
   getSource: getSource,
   resolvePath: resolvePath,
+  safeResolvePath: safeResolvePath,
   splitModuleFilePathAndModulePath: splitModuleFilePathAndModulePath,
   joinModuleFilePathAndModulePath: joinModuleFilePathAndModulePath,
   remote: {

package/dist/valbuild-core.cjs.dev.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dist_valbuildCore = require('./index-2e346d06.cjs.dev.js');
+var dist_valbuildCore = require('./index-041f7675.cjs.dev.js');
 require('./result-bb1f436e.cjs.dev.js');
 
 

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

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dist_valbuildCore = require('./index-047950e1.cjs.prod.js');
+var dist_valbuildCore = require('./index-3ecf0ca6.cjs.prod.js');
 require('./result-787e35f6.cjs.prod.js');
 
 

package/dist/valbuild-core.esm.js

@@ -1,2 +1,2 @@
-export { A as ArraySchema, B as BooleanSchema, e as DEFAULT_APP_HOST, D as DEFAULT_CONTENT_HOST, f as DEFAULT_VAL_REMOTE_HOST, o as DateSchema, F as FATAL_ERROR_TYPES, g as FILE_REF_PROP, h as FILE_REF_SUBTYPE_TAG, n as FileSchema, G as GenericSelector, l as ImageSchema, I as Internal, K as KeyOfSchema, L as LiteralSchema, M as ModuleFilePathSep, N as NumberSchema, O as ObjectSchema, R as RecordSchema, p as RichTextSchema, S as Schema, k as StringSchema, U as UnionSchema, V as VAL_EXTENSION, j as derefPatch, q as deserializeSchema, i as initVal, m as modules } from './index-b59ab889.esm.js';
+export { A as ArraySchema, B as BooleanSchema, e as DEFAULT_APP_HOST, D as DEFAULT_CONTENT_HOST, f as DEFAULT_VAL_REMOTE_HOST, o as DateSchema, F as FATAL_ERROR_TYPES, g as FILE_REF_PROP, h as FILE_REF_SUBTYPE_TAG, n as FileSchema, G as GenericSelector, l as ImageSchema, I as Internal, K as KeyOfSchema, L as LiteralSchema, M as ModuleFilePathSep, N as NumberSchema, O as ObjectSchema, R as RecordSchema, p as RichTextSchema, S as Schema, k as StringSchema, U as UnionSchema, V as VAL_EXTENSION, j as derefPatch, q as deserializeSchema, i as initVal, m as modules } from './index-1d5e4912.esm.js';
 import './result-daff1cae.esm.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valbuild/core",
-  "version": "0.78.3",
+  "version": "0.79.1",
   "private": false,
   "description": "Val - supercharged hard-coded content",
   "scripts": {

package/patch/dist/valbuild-core-patch.cjs.dev.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dist_valbuildCore = require('../../dist/index-2e346d06.cjs.dev.js');
+var dist_valbuildCore = require('../../dist/index-041f7675.cjs.dev.js');
 var result = require('../../dist/result-bb1f436e.cjs.dev.js');
 var util = require('../../dist/util-b213092b.cjs.dev.js');
 

package/patch/dist/valbuild-core-patch.cjs.prod.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dist_valbuildCore = require('../../dist/index-047950e1.cjs.prod.js');
+var dist_valbuildCore = require('../../dist/index-3ecf0ca6.cjs.prod.js');
 var result = require('../../dist/result-787e35f6.cjs.prod.js');
 var util = require('../../dist/util-030d8a1f.cjs.prod.js');
 

package/patch/dist/valbuild-core-patch.esm.js

@@ -1,5 +1,5 @@
-import { _ as _typeof, a as _slicedToArray, P as PatchError, s as splitModuleFilePathAndModulePath, b as _createClass, c as _classCallCheck, d as _toConsumableArray } from '../../dist/index-b59ab889.esm.js';
-export { P as PatchError } from '../../dist/index-b59ab889.esm.js';
+import { _ as _typeof, a as _slicedToArray, P as PatchError, s as splitModuleFilePathAndModulePath, b as _createClass, c as _classCallCheck, d as _toConsumableArray } from '../../dist/index-1d5e4912.esm.js';
+export { P as PatchError } from '../../dist/index-1d5e4912.esm.js';
 import { f as isNonEmpty, e as err, o as ok, m as map, g as flatMap, i as isErr, h as flatMapReduce, j as filterOrElse, k as mapErr, l as map$1, n as all, p as flatten, q as allT } from '../../dist/result-daff1cae.esm.js';
 import { p as pipe } from '../../dist/util-18613e99.esm.js';