@valbuild/core 0.63.6 → 0.64.0

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

@@ -15,7 +15,6 @@ export type { AllRichTextOptions, Bold, Styles, HeadingNode, ImageNode, Italic,
 export { type Val, type SerializedVal, type ModuleFilePath, type PatchId, type ModulePath, type SourcePath, type JsonOfSource, } from "./val/index.js";
 export type { Json, JsonPrimitive, JsonArray, JsonObject } from "./Json.js";
 export type { ValidationError, ValidationErrors, } from "./schema/validation/ValidationError.js";
-import type { ValidationError, ValidationErrors } from "./schema/validation/ValidationError.js";
 export type { ValidationFix } from "./schema/validation/ValidationFix.js";
 export * as expr from "./expr/index.js";
 export { FILE_REF_PROP, FILE_REF_SUBTYPE_TAG } from "./source/file.js";
@@ -24,14 +23,13 @@ export { derefPatch } from "./patch/deref.js";
 export { type SelectorSource, type SelectorOf, GenericSelector, } from "./selector/index.js";
 import { getSource, resolvePath, splitModuleFilePathAndModulePath } from "./module.js";
 import { getSchema } from "./selector/index.js";
-import { ModuleFilePath, ModulePath, PatchId, SourcePath, getValPath, isVal } from "./val/index.js";
+import { ModulePath, getValPath, isVal } from "./val/index.js";
 import { convertFileSource } from "./schema/file.js";
 import { createValPathOfItem } from "./selector/SelectorProxy.js";
 import { getVal } from "./future/fetchVal.js";
-import type { Json } from "./Json.js";
-import { Operation, Patch } from "./patch/index.js";
+import { Operation } from "./patch/index.js";
 import { initSchema } from "./initSchema.js";
-import { SerializedSchema } from "./schema/index.js";
+import { getMimeType, mimeTypeToFileExt, filenameToMimeType } from "./mimeType/index.js";
 export { type SerializedArraySchema, ArraySchema } from "./schema/array.js";
 export { type SerializedObjectSchema, ObjectSchema } from "./schema/object.js";
 export { type SerializedRecordSchema, RecordSchema } from "./schema/record.js";
@@ -41,96 +39,13 @@ export { type SerializedBooleanSchema, BooleanSchema } from "./schema/boolean.js
 export { type SerializedImageSchema, ImageSchema } from "./schema/image.js";
 export { type SerializedFileSchema, FileSchema } from "./schema/file.js";
 export { type SerializedDateSchema, DateSchema } from "./schema/date.js";
+export { type SerializedKeyOfSchema, KeyOfSchema } from "./schema/keyOf.js";
 export { type SerializedRichTextSchema, RichTextSchema, } from "./schema/richtext.js";
 export { type SerializedUnionSchema, UnionSchema } from "./schema/union.js";
 export { type SerializedLiteralSchema, LiteralSchema } from "./schema/literal.js";
 export { deserializeSchema } from "./schema/deserialize.js";
-export { ValApi } from "./ValApi.js";
-export type ApiCommitResponse = {};
-export type ApiSchemaResponse = {
-    schemaSha: string;
-    schemas: Record<ModuleFilePath, SerializedSchema>;
-};
-export type ApiTreeResponse = {
-    schemaSha: string;
-    fatalErrors?: ({
-        message: string;
-        type: "invalid-module-file-path";
-        actualModuleFilePath: string;
-        expectedModuleFilePath: string;
-    } | {
-        message: string;
-        stack?: string;
-        type?: undefined;
-    })[];
-    newPatchId?: PatchId;
-    modules: Record<ModuleFilePath, {
-        source: Json;
-        patches?: {
-            applied: PatchId[];
-            skipped?: PatchId[];
-            errors?: Record<PatchId, {
-                message: string;
-            }>;
-        };
-        validationErrors?: Record<SourcePath, ValidationError[]>;
-    }>;
-};
-export type ApiGetPatchResponse = {
-    patches: Record<PatchId, {
-        path: ModuleFilePath;
-        patch?: Patch;
-        createdAt: string;
-        authorId: string | null;
-        appliedAt: {
-            baseSha: string;
-            git?: {
-                commitSha: string;
-            };
-            timestamp: string;
-        } | null;
-    }>;
-    error?: {
-        message: string;
-    };
-    errors?: Record<PatchId, {
-        message: string;
-    }>;
-};
-export type ApiDeletePatchResponse = PatchId[];
-export type ApiPostPatchResponse = Record<ModuleFilePath, {
-    patch_id: PatchId;
-}>;
-export type ApiPostValidationResponse = {
-    validationErrors: false;
-    modules: Record<ModuleFilePath, {
-        patches: {
-            applied: PatchId[];
-        };
-    }>;
-};
 export declare const FATAL_ERROR_TYPES: readonly ["no-schema", "no-source", "invalid-id", "no-module", "invalid-patch"];
 export type FatalErrorType = (typeof FATAL_ERROR_TYPES)[number];
-export type ApiPostValidationErrorResponse = {
-    modules: Record<ModuleFilePath, {
-        patches: {
-            applied: PatchId[];
-            failed?: PatchId[];
-        };
-    }>;
-    validationErrors: Record<ModuleFilePath, {
-        source?: Json;
-        errors: {
-            invalidModulePath?: ModuleFilePath;
-            validation?: ValidationErrors;
-            fatal?: {
-                message: string;
-                stack?: string;
-                type?: FatalErrorType;
-            }[];
-        };
-    }>;
-};
 declare const Internal: {
     VERSION: {
         core: string | null;
@@ -146,6 +61,13 @@ declare const Internal: {
     createValPathOfItem: typeof createValPathOfItem;
     getSHA256Hash: (bits: Uint8Array) => string;
     initSchema: typeof initSchema;
+    getMimeType: typeof getMimeType;
+    mimeTypeToFileExt: typeof mimeTypeToFileExt;
+    filenameToMimeType: typeof filenameToMimeType;
+    EXT_TO_MIME_TYPES: Record<string, string>;
+    MIME_TYPES_TO_EXT: {
+        [k: string]: string;
+    };
     ModuleFilePathSep: string;
     notFileOp: (op: Operation) => boolean;
     isFileOp: (op: Operation) => op is {

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

@@ -78,9 +78,9 @@ export declare function initSchema(): {
         }>;
     }>>(options?: O | undefined) => import("./schema/index.js").Schema<import("./index.js").RichTextSource<O>>;
     image: (options?: import("./schema/image.js").ImageOptions | undefined) => import("./schema/index.js").Schema<import("./index.js").ImageSource>;
-    literal: <T_2 extends string>(value: T_2) => import("./schema/index.js").Schema<T_2>;
+    literal: <T_2 extends string>(value: T_2) => import("./schema/literal.js").LiteralSchema<T_2>;
     keyOf: <Src extends import("./selector/index.js").GenericSelector<import("./source/index.js").SourceObject | import("./source/index.js").SourceArray, undefined> & import("./module.js").ValModuleBrand>(valModule: Src) => import("./schema/index.js").Schema<Src extends import("./selector/index.js").GenericSelector<infer S_2 extends import("./source/index.js").Source, undefined> ? S_2 extends readonly import("./source/index.js").Source[] ? number : S_2 extends import("./source/index.js").SourceObject ? string extends keyof S_2 ? import("./schema/string.js").RawString : keyof S_2 : S_2 extends Record<string, import("./source/index.js").Source> ? import("./schema/string.js").RawString : never : never>;
     record: <S_3 extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S_3) => import("./schema/index.js").Schema<Record<string, import("./schema/index.js").SelectorOfSchema<S_3>>>;
     file: (options?: import("./schema/file.js").FileOptions | undefined) => import("./schema/index.js").Schema<import("./index.js").FileSource<import("./schema/file.js").FileMetadata>>;
-    date: <T_3 extends string>(options?: Record<string, never> | undefined) => import("./schema/date.js").DateSchema<T_3>;
+    date: (options?: Record<string, never> | undefined) => import("./schema/date.js").DateSchema<import("./schema/string.js").RawString>;
 };

package/dist/declarations/src/mimeType/all.d.ts

@@ -0,0 +1,4 @@
+export declare const EXT_TO_MIME_TYPES: Record<string, string>;
+export declare const MIME_TYPES_TO_EXT: {
+    [k: string]: string;
+};

package/dist/declarations/src/mimeType/convertMimeType.d.ts

@@ -0,0 +1,3 @@
+export declare function getMimeType(base64Url: string): string | undefined;
+export declare function mimeTypeToFileExt(mimeType: string): string;
+export declare function filenameToMimeType(filename: string): string | undefined;

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

@@ -0,0 +1,2 @@
+export * from "./convertMimeType.js";
+export * from "./all.js";

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

@@ -1,4 +1,4 @@
-import { Schema, SelectorOfSchema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
@@ -7,13 +7,13 @@ export type SerializedArraySchema = {
     item: SerializedSchema;
     opt: boolean;
 };
-export declare class ArraySchema<T extends Schema<SelectorSource>> extends Schema<SelectorOfSchema<T>[]> {
+export declare class ArraySchema<T extends Schema<SelectorSource>, Src extends SelectorOfSchema<T>[] | null> extends Schema<Src> {
     readonly item: T;
     readonly opt: boolean;
     constructor(item: T, opt?: boolean);
-    validate(path: SourcePath, src: SelectorOfSchema<T>[]): ValidationErrors;
-    assert(src: SelectorOfSchema<T>[]): boolean;
-    nullable(): Schema<SelectorOfSchema<T>[] | null>;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): Schema<Src | null>;
     serialize(): SerializedArraySchema;
 }
 export declare const array: <S extends Schema<SelectorSource>>(schema: S) => Schema<SelectorOfSchema<S>[]>;

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

@@ -1,4 +1,4 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedBooleanSchema = {
@@ -9,7 +9,7 @@ export declare class BooleanSchema<Src extends boolean | null> extends Schema<Sr
     readonly opt: boolean;
     constructor(opt?: boolean);
     validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(src: Src): boolean;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }

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

@@ -1,5 +1,6 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
+import { RawString } from "./string.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 type DateOptions = {
     /**
@@ -25,14 +26,13 @@ export type SerializedDateSchema = {
 export declare class DateSchema<Src extends string | null> extends Schema<Src> {
     readonly options?: DateOptions | undefined;
     readonly opt: boolean;
-    private readonly isRaw;
-    constructor(options?: DateOptions | undefined, opt?: boolean, isRaw?: boolean);
+    constructor(options?: DateOptions | undefined, opt?: boolean);
     validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(src: Src): boolean;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     from(from: string): DateSchema<Src>;
     to(to: string): DateSchema<Src>;
     nullable(): DateSchema<Src | null>;
     serialize(): SerializedSchema;
 }
-export declare const date: <T extends string>(options?: Record<string, never>) => DateSchema<T>;
+export declare const date: (options?: Record<string, never>) => DateSchema<RawString>;
 export {};

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

@@ -1,9 +1,11 @@
 import { Json } from "../Json.js";
 import { FileSource } from "../source/file.js";
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
-export type FileOptions = Record<string, never>;
+export type FileOptions = {
+    accept?: string;
+};
 export type SerializedFileSchema = {
     type: "file";
     options?: FileOptions;
@@ -18,7 +20,7 @@ export declare class FileSchema<Src extends FileSource<FileMetadata | undefined>
     readonly opt: boolean;
     constructor(options?: FileOptions | undefined, opt?: boolean);
     validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(src: Src): boolean;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }

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

@@ -1,12 +1,13 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { FileSource } from "../source/file.js";
 import { ImageSource } from "../source/image.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 export type ImageOptions = {
-    ext: ["jpg"] | ["webp"];
+    ext?: ["jpg"] | ["webp"];
     directory?: string;
     prefix?: string;
+    accept?: string;
 };
 export type SerializedImageSchema = {
     type: "image";
@@ -30,7 +31,7 @@ export declare class ImageSchema<Src extends FileSource<ImageMetadata | undefine
     readonly opt: boolean;
     constructor(options?: ImageOptions | undefined, opt?: boolean);
     validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(src: Src): boolean;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }

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

@@ -10,17 +10,58 @@ import { SerializedNumberSchema } from "./number.js";
 import { SerializedObjectSchema } from "./object.js";
 import { SerializedRecordSchema } from "./record.js";
 import { SerializedRichTextSchema } from "./richtext.js";
-import { SerializedStringSchema } from "./string.js";
+import { RawString, SerializedStringSchema } from "./string.js";
 import { SerializedUnionSchema } from "./union.js";
 import { SerializedDateSchema } from "./date.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
+import { FileSource } from "../source/file.js";
+import { GenericRichTextSourceNode, RichTextSource } from "../source/richtext.js";
 export type SerializedSchema = SerializedStringSchema | SerializedLiteralSchema | SerializedBooleanSchema | SerializedNumberSchema | SerializedObjectSchema | SerializedArraySchema | SerializedUnionSchema | SerializedRichTextSchema | SerializedRecordSchema | SerializedKeyOfSchema | SerializedFileSchema | SerializedDateSchema | SerializedImageSchema;
+type Primitives = number | string | boolean | null | FileSource;
+export type AssertError = {
+    message: string;
+    schemaError: true;
+} | {
+    message: string;
+    typeError: true;
+} | {
+    message: string;
+    internalError: true;
+};
+export type SchemaAssertResult<Src extends SelectorSource> = {
+    data: Src extends RawString ? string : Src extends RichTextSource<{}> ? GenericRichTextSourceNode[] : Src extends Primitives ? Src : Src extends Array<SelectorSource> ? SelectorSource[] : Src extends {
+        [key: string]: SelectorSource;
+    } ? {
+        [key in keyof Src]: SelectorSource;
+    } : never;
+    success: true;
+} | {
+    success: false;
+    errors: Record<SourcePath, AssertError[]>;
+};
 export declare abstract class Schema<Src extends SelectorSource> {
+    /** Validate the value of source content */
     abstract validate(path: SourcePath, src: Src): ValidationErrors;
-    abstract assert(src: Src): boolean;
+    /**
+     * Check if the **root** **type** of source is correct.
+     *
+     * The difference between assert and validate is:
+     * - assert verifies that the root **type** of the source is correct (it does not recurse down). Therefore, assert can be used as a runtime type check.
+     * - validate checks the **value** of the source in addition to the type. It recurses down the source.
+     *
+     * For example assert fails for a StringSchema if the source is not a string,
+     * it will not fail if the length is not correct.
+     * Validate will check the length and all other constraints.
+     *
+     * Assert is useful if you have a generic schema and need to make sure the root type is valid.
+     * When using assert, you must assert recursively if you want to verify the entire source.
+     * For example, if you have an object schema, you must assert each key / value pair manually.
+     */
+    abstract assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     abstract nullable(): Schema<Src | null>;
     abstract serialize(): SerializedSchema;
     /** MUTATES! since internal and perf sensitive */
-    protected appendValidationError(current: ValidationErrors, path: SourcePath, message: string, value?: unknown): ValidationErrors;
+    protected appendValidationError(current: ValidationErrors, path: SourcePath, message: string, value: unknown): ValidationErrors;
 }
 export type SelectorOfSchema<T extends Schema<SelectorSource>> = T extends Schema<infer Src> ? Src : never;
+export {};

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

@@ -1,4 +1,4 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ValModuleBrand } from "../module.js";
 import { GenericSelector } from "../selector/index.js";
 import { Source, SourceArray, SourceObject } from "../source/index.js";
@@ -13,14 +13,14 @@ export type SerializedKeyOfSchema = {
     values: "string" | "number" | string[];
 };
 type KeyOfSelector<Sel extends GenericSelector<SourceArray | SourceObject>> = Sel extends GenericSelector<infer S> ? S extends readonly Source[] ? number : S extends SourceObject ? string extends keyof S ? RawString : keyof S : S extends Record<string, Source> ? RawString : never : never;
-export declare class KeyOfSchema<Sel extends GenericSelector<SourceArray | SourceObject>> extends Schema<KeyOfSelector<Sel>> {
+export declare class KeyOfSchema<Sel extends GenericSelector<SourceArray | SourceObject>, Src extends KeyOfSelector<Sel> | null> extends Schema<Src> {
     readonly schema?: SerializedSchema | undefined;
     readonly sourcePath?: SourcePath | undefined;
     readonly opt: boolean;
     constructor(schema?: SerializedSchema | undefined, sourcePath?: SourcePath | undefined, opt?: boolean);
-    validate(path: SourcePath, src: KeyOfSelector<Sel>): ValidationErrors;
-    assert(src: KeyOfSelector<Sel>): boolean;
-    nullable(): Schema<KeyOfSelector<Sel> | null>;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }
 export declare const keyOf: <Src extends GenericSelector<SourceObject | SourceArray, undefined> & ValModuleBrand>(valModule: Src) => Schema<KeyOfSelector<Src>>;

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

@@ -1,4 +1,4 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedLiteralSchema = {
@@ -11,8 +11,8 @@ export declare class LiteralSchema<Src extends string | null> extends Schema<Src
     readonly opt: boolean;
     constructor(value: string, opt?: boolean);
     validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(src: Src): boolean;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }
-export declare const literal: <T extends string>(value: T) => Schema<T>;
+export declare const literal: <T extends string>(value: T) => LiteralSchema<T>;

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

@@ -1,4 +1,4 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 type NumberOptions = {
@@ -15,8 +15,8 @@ export declare class NumberSchema<Src extends number | null> extends Schema<Src>
     readonly opt: boolean;
     constructor(options?: NumberOptions | undefined, opt?: boolean);
     validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(src: Src): boolean;
-    nullable(): Schema<Src | null>;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): Schema<Src>;
     serialize(): SerializedSchema;
 }
 export declare const number: (options?: NumberOptions) => Schema<number>;

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

@@ -1,4 +1,4 @@
-import { Schema, SelectorOfSchema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
@@ -28,13 +28,13 @@ type ObjectSchemaProps = {
 type ObjectSchemaSrcOf<Props extends ObjectSchemaProps> = {
     [key in keyof Props]: SelectorOfSchema<Props[key]>;
 };
-export declare class ObjectSchema<Props extends ObjectSchemaProps> extends Schema<ObjectSchemaSrcOf<Props>> {
+export declare class ObjectSchema<Props extends ObjectSchemaProps, Src extends ObjectSchemaSrcOf<Props> | null> extends Schema<Src> {
     readonly items: Props;
     readonly opt: boolean;
     constructor(items: Props, opt?: boolean);
-    validate(path: SourcePath, src: ObjectSchemaSrcOf<Props>): ValidationErrors;
-    assert(src: ObjectSchemaSrcOf<Props>): boolean;
-    nullable(): Schema<ObjectSchemaSrcOf<Props> | null>;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }
 export declare const object: <Props extends ObjectSchemaProps>(schema: Props) => Schema<{ [key in keyof Props]: SelectorOfSchema<Props[key]>; }>;

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

@@ -1,4 +1,4 @@
-import { Schema, SelectorOfSchema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
@@ -7,13 +7,13 @@ export type SerializedRecordSchema = {
     item: SerializedSchema;
     opt: boolean;
 };
-export declare class RecordSchema<T extends Schema<SelectorSource>> extends Schema<Record<string, SelectorOfSchema<T>>> {
+export declare class RecordSchema<T extends Schema<SelectorSource>, Src extends Record<string, SelectorOfSchema<T>> | null> extends Schema<Src> {
     readonly item: T;
     readonly opt: boolean;
     constructor(item: T, opt?: boolean);
-    validate(path: SourcePath, src: Record<string, SelectorOfSchema<T>>): ValidationErrors;
-    assert(src: Record<string, SelectorOfSchema<T>>): boolean;
-    nullable(): Schema<Record<string, SelectorOfSchema<T>> | null>;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): Schema<Src | null>;
     serialize(): SerializedRecordSchema;
 }
 export declare const record: <S extends Schema<SelectorSource>>(schema: S) => Schema<Record<string, SelectorOfSchema<S>>>;

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

@@ -1,19 +1,20 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { RichTextSource, RichTextOptions } from "../source/richtext.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedRichTextSchema = {
     type: "richtext";
     opt: boolean;
-    options: RichTextOptions;
+    options?: RichTextOptions;
 };
 export declare class RichTextSchema<O extends RichTextOptions, Src extends RichTextSource<O> | null> extends Schema<Src> {
     readonly options: O;
     readonly opt: boolean;
     constructor(options: O, opt?: boolean);
     validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(src: Src): boolean;
-    nullable(): Schema<RichTextSource<O> | null>;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    private recursiveAssert;
+    nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }
 export declare const richtext: <O extends Partial<{

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

@@ -1,4 +1,4 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 type StringOptions = {
@@ -32,7 +32,7 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
     max(maxLength: number): StringSchema<Src>;
     regexp(regexp: RegExp): StringSchema<Src>;
     validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(src: Src): boolean;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): StringSchema<Src | null>;
     raw(): StringSchema<Src extends null ? RawString | null : RawString>;
     serialize(): SerializedSchema;

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

@@ -1,4 +1,4 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourceObject } from "../source/index.js";
 import { SourcePath } from "../val/index.js";
@@ -14,13 +14,13 @@ type SourceOf<Key extends string | Schema<string>, T extends Schema<Key extends
 } : Key extends Schema<string> ? string : unknown>[]> = T extends Schema<infer S>[] ? S extends SelectorSource ? S | (Key extends Schema<infer K> ? K : never) : never : never;
 export declare class UnionSchema<Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & {
     [k in Key]: string;
-} : Key extends Schema<string> ? string : unknown>[]> extends Schema<SourceOf<Key, T>> {
+} : Key extends Schema<string> ? string : unknown>[], Src extends SourceOf<Key, T> | null> extends Schema<Src> {
     readonly key: Key;
     readonly items: T;
     readonly opt: boolean;
-    validate(path: SourcePath, src: SourceOf<Key, T>): ValidationErrors;
-    assert(src: SourceOf<Key, T>): boolean;
-    nullable(): Schema<SourceOf<Key, T> | null>;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
     constructor(key: Key, items: T, opt?: boolean);
 }

package/dist/declarations/src/schema/validation/ValidationError.d.ts

@@ -3,7 +3,8 @@ import { ValidationFix } from "./ValidationFix.js";
 export type ValidationError = {
     message: string;
     value?: unknown;
-    fatal?: boolean;
+    typeError?: boolean;
+    schemaError?: boolean;
     fixes?: ValidationFix[];
 };
 /**

package/dist/declarations/src/selector/SelectorProxy.d.ts

@@ -4,4 +4,5 @@ import { ModulePath, SourcePath } from "../val/index.js";
 export declare function isSelector(source: any): source is GenericSelector<Source>;
 export declare function newSelectorProxy(source: any, path?: SourcePath, moduleSchema?: any): any;
 export declare function createValPathOfItem(arrayPath: SourcePath | ModulePath | undefined, prop: string | number | symbol): SourcePath | undefined;
+export declare function unsafeCreateSourcePath(path: string, itemKey: string | number | symbol): SourcePath;
 export declare function selectorToVal(s: any): any;

package/dist/declarations/src/source/richtext.d.ts

@@ -48,6 +48,13 @@ export type LineThrough<O extends RichTextOptions> = NonNullable<O["style"]>["li
 export type Italic<O extends RichTextOptions> = NonNullable<O["style"]>["italic"] extends true ? "italic" : never;
 export type Bold<O extends RichTextOptions> = NonNullable<O["style"]>["bold"] extends true ? "bold" : never;
 export type Styles<O extends RichTextOptions> = LineThrough<O> | Italic<O> | Bold<O>;
+export type GenericRichTextSourceNode = {
+    tag: string;
+    styles?: string[];
+    href?: string;
+    src?: ImageSource;
+    children?: (string | GenericRichTextSourceNode)[];
+};
 export type ParagraphNode<O extends RichTextOptions> = {
     tag: "p";
     children: (string | SpanNode<O> | BrNode | LinkNode<O> | ImageNode<O> | CustomInlineNode<O>)[];

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

@@ -22,7 +22,7 @@ export type Val<T extends Json> = Json extends T ? {
     readonly val: Source;
 } : T extends JsonObject ? ObjectVal<T> : T extends JsonArray ? ArrayVal<T> : T extends JsonPrimitive ? PrimitiveVal<T> : never;
 export declare function isVal<T extends Json>(val: unknown): val is Val<T>;
-declare const brand: unique symbol;
+declare const brand = "VAL_DATA_TYPE";
 /**
  * The path of the source value.
  *