@valbuild/core 0.63.6 → 0.65.0

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

@@ -1,8 +1,8 @@
 export declare abstract class Expr {
-    readonly span?: [number, (number | undefined)?] | undefined;
+    readonly span?: [number, number?] | undefined;
     abstract type: "StringLiteral" | "Sym" | "StringTemplate" | "Call";
     abstract transpile(): string;
-    constructor(span?: [number, (number | undefined)?] | undefined);
+    constructor(span?: [number, number?] | undefined);
 }
 export declare class StringLiteral extends Expr {
     readonly value: string;

package/dist/declarations/src/expr/parser.d.ts

@@ -2,7 +2,7 @@ import { result } from "../fp/index.js";
 import { Expr } from "./expr.js";
 export declare class ParserError {
     readonly message: string;
-    readonly span?: [number, (number | undefined)?] | undefined;
-    constructor(message: string, span?: [number, (number | undefined)?] | undefined);
+    readonly span?: [number, number?] | undefined;
+    constructor(message: string, span?: [number, number?] | undefined);
 }
 export declare function parse(input: string): result.Result<Expr, ParserError>;

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

@@ -1,4 +1,4 @@
-export { initVal } from "./initVal.js";
+export { initVal, type ConfigDirectory } from "./initVal.js";
 export { modules, type ValModules } from "./modules.js";
 export type { InitVal, ValConfig, ValConstructor, ContentConstructor, } from "./initVal.js";
 export { Schema, type SerializedSchema, type SelectorOfSchema } from "./schema/index.js";
@@ -15,23 +15,25 @@ 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";
 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, resolvePath, splitModuleFilePathAndModulePath } from "./module.js";
+import { getSource, splitModulePath, splitModuleFilePath, resolvePath, splitModuleFilePathAndModulePath, joinModuleFilePathAndModulePath, parentOfSourcePath, patchPathToModulePath, splitJoinedSourcePaths } from "./module.js";
+declare const ModuleFilePathSep = "?p=";
+export { ModuleFilePathSep };
 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";
+import { type ImageMetadata } from "./schema/image.js";
+import { type FileMetadata } from "./schema/file.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 +43,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 SerializedUnionSchema, UnionSchema, type SerializedStringUnionSchema, type SerializedObjectUnionSchema, } 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;
@@ -142,12 +61,43 @@ declare const Internal: {
     getSource: typeof getSource;
     resolvePath: typeof resolvePath;
     splitModuleFilePathAndModulePath: typeof splitModuleFilePathAndModulePath;
+    joinModuleFilePathAndModulePath: typeof joinModuleFilePathAndModulePath;
     isVal: typeof isVal;
     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;
+    notFileOp: (op: Operation) => op is {
+        op: "add";
+        path: string[];
+        value: import("./patch/index.js").JSONValue;
+    } | {
+        op: "remove";
+        path: import("./fp/array.js").NonEmptyArray<string>;
+    } | {
+        op: "replace";
+        path: string[];
+        value: import("./patch/index.js").JSONValue;
+    } | {
+        op: "move";
+        from: import("./fp/array.js").NonEmptyArray<string>;
+        path: string[];
+    } | {
+        op: "copy";
+        from: string[];
+        path: string[];
+    } | {
+        op: "test";
+        path: string[];
+        value: import("./patch/index.js").JSONValue;
+    };
     isFileOp: (op: Operation) => op is {
         op: "file";
         path: string[];
@@ -156,9 +106,14 @@ declare const Internal: {
     };
     createPatchJSONPath: (modulePath: ModulePath) => string;
     createPatchPath: (modulePath: ModulePath) => string[];
-    patchPathToModulePath: (patchPath: string[]) => ModulePath;
+    splitModulePath: typeof splitModulePath;
+    splitModuleFilePath: typeof splitModuleFilePath;
+    splitJoinedSourcePaths: typeof splitJoinedSourcePaths;
+    parentOfSourcePath: typeof parentOfSourcePath;
+    patchPathToModulePath: typeof patchPathToModulePath;
     VAL_ENABLE_COOKIE_NAME: "val_enable";
     VAL_STATE_COOKIE: "val_state";
     VAL_SESSION_COOKIE: "val_session";
+    createFilename: (data: string | null, filename: string | null, metadata: FileMetadata | ImageMetadata | undefined, sha256: string) => string | null;
 };
 export { Internal };

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

@@ -27,60 +27,30 @@ export type InitSchema = {
     readonly date: typeof date;
 };
 export declare function initSchema(): {
-    string: <T extends string>(options?: Record<string, never> | undefined) => import("./schema/string.js").StringSchema<T>;
+    string: <T extends string>(options?: Record<string, never>) => import("./schema/string.js").StringSchema<T>;
     boolean: () => import("./schema/index.js").Schema<boolean>;
     array: <S extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S) => import("./schema/index.js").Schema<import("./schema/index.js").SelectorOfSchema<S>[]>;
     object: <Props extends {
         [key: string]: import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>;
     } & {
-        valPath?: undefined;
-        val?: undefined;
-        _type?: undefined;
-        _ref?: undefined;
-        andThen?: undefined;
-        assert?: undefined;
-        fold?: undefined;
+        valPath?: never;
+        val?: never;
+        _type?: never;
+        _ref?: never;
+        andThen?: never;
+        assert?: never;
+        fold?: never;
     }>(schema: Props) => import("./schema/index.js").Schema<{ [key in keyof Props]: import("./schema/index.js").SelectorOfSchema<Props[key]>; }>;
     number: (options?: {
-        max?: number | undefined;
-        min?: number | undefined;
-    } | undefined) => import("./schema/index.js").Schema<number>;
-    union: <Key extends string | import("./schema/index.js").Schema<string>, T_1 extends import("./schema/index.js").Schema<Key extends string ? {
-        [x: string]: import("./source/index.js").Source;
-    } & {
-        fold?: undefined;
-        assert?: undefined;
-        andThen?: undefined;
-        _ref?: undefined;
-        _type?: undefined;
-        val?: undefined;
-        valPath?: undefined;
-    } & { [k in Key]: string; } : Key extends import("./schema/index.js").Schema<string> ? string : unknown>[]>(key: Key, ...objects: T_1) => import("./schema/index.js").Schema<T_1 extends import("./schema/index.js").Schema<infer S_1 extends import("./selector/index.js").SelectorSource>[] ? S_1 extends import("./selector/index.js").SelectorSource ? S_1 | (Key extends import("./schema/index.js").Schema<infer K extends import("./selector/index.js").SelectorSource> ? K : never) : never : never>;
-    richtext: <O extends Partial<{
-        style: Partial<{
-            bold: boolean;
-            italic: boolean;
-            lineThrough: boolean;
-        }>;
-        block: Partial<{
-            h1: boolean;
-            h2: boolean;
-            h3: boolean;
-            h4: boolean;
-            h5: boolean;
-            h6: boolean;
-            ul: boolean;
-            ol: boolean;
-        }>;
-        inline: Partial<{
-            a: boolean;
-            img: boolean;
-        }>;
-    }>>(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>;
-    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>;
+        max?: number;
+        min?: number;
+    }) => import("./schema/index.js").Schema<number>;
+    union: <Key extends string | import("./schema/index.js").Schema<string>, T extends import("./schema/index.js").Schema<Key extends string ? import("./source/index.js").SourceObject & { [k in Key]: string; } : Key extends import("./schema/index.js").Schema<string> ? string : unknown>[]>(key: Key, ...objects: T) => import("./schema/index.js").Schema<T extends import("./schema/index.js").Schema<infer S extends import("./selector/index.js").SelectorSource>[] ? S extends import("./selector/index.js").SelectorSource ? S | (Key extends import("./schema/index.js").Schema<infer K extends import("./selector/index.js").SelectorSource> ? K : never) : never : never>;
+    richtext: <O extends import("./index.js").RichTextOptions>(options?: O) => import("./schema/index.js").Schema<import("./index.js").RichTextSource<O>>;
+    image: (options?: import("./schema/image.js").ImageOptions) => import("./schema/index.js").Schema<import("./index.js").ImageSource>;
+    literal: <T extends string>(value: T) => import("./schema/literal.js").LiteralSchema<T>;
+    keyOf: <Src extends import("./selector/index.js").GenericSelector<import("./source/index.js").SourceObject> & import("./module.js").ValModuleBrand>(valModule: Src) => import("./schema/index.js").Schema<Src extends import("./selector/index.js").GenericSelector<infer S extends import("./source/index.js").Source, undefined> ? S extends readonly import("./source/index.js").Source[] ? number : S extends import("./source/index.js").SourceObject ? string extends keyof S ? import("./schema/string.js").RawString : keyof S : S extends Record<string, import("./source/index.js").Source> ? import("./schema/string.js").RawString : never : never>;
+    record: <S extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S) => import("./schema/index.js").Schema<Record<string, import("./schema/index.js").SelectorOfSchema<S>>>;
+    file: (options?: import("./schema/file.js").FileOptions) => import("./schema/index.js").Schema<import("./index.js").FileSource<import("./schema/file.js").FileMetadata>>;
+    date: (options?: Record<string, never>) => import("./schema/date.js").DateSchema<import("./schema/string.js").RawString>;
 };

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

@@ -1,14 +1,14 @@
 import { define } from "./module.js";
 import { InitSchema } from "./initSchema.js";
 import { getValPath as getPath } from "./val/index.js";
-import { file } from "./source/file.js";
+import { initFile } from "./source/file.js";
 import { richtext } from "./source/richtext.js";
 import { link } from "./source/link.js";
 export type ContentConstructor = {
     define: typeof define;
-    file: typeof file;
+    file: ReturnType<typeof initFile>;
     rt: {
-        image: typeof file;
+        image: ReturnType<typeof initFile>;
         link: typeof link;
     };
     richtext: typeof richtext;
@@ -16,11 +16,16 @@ export type ContentConstructor = {
 export type ValConstructor = {
     unstable_getPath: typeof getPath;
 };
+export type ConfigDirectory = `/public/${string}`;
 export type ValConfig = {
     project?: string;
     root?: string;
+    files?: {
+        directory: ConfigDirectory;
+    };
     gitCommit?: string;
     gitBranch?: string;
+    defaultTheme?: "dark" | "light";
 };
 export type InitVal = {
     c: ContentConstructor;

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/module.d.ts

@@ -21,14 +21,18 @@ export declare function define<T extends Schema<SelectorSource>>(id: string, //
 schema: T, source: ReplaceRawStringWithString<SelectorOfSchema<T>>): ValModule<SelectorOfSchema<T>>;
 export declare function getSource(valModule: ValModule<SelectorSource>): Source;
 export declare function splitModuleFilePathAndModulePath(path: SourcePath): [moduleId: ModuleFilePath, path: ModulePath];
-export declare const ModuleFilePathSep = "?p=";
+export declare function joinModuleFilePathAndModulePath(moduleFilePath: ModuleFilePath, modulePath: ModulePath): SourcePath;
 export declare function getSourceAtPath(modulePath: ModulePath, valModule: ValModule<SelectorSource> | Source): any;
 export declare function resolvePath<Src extends ValModule<SelectorSource> | Source, Sch extends Schema<SelectorSource> | SerializedSchema>(path: ModulePath, valModule: Src, schema: Sch): {
     path: SourcePath;
     schema: Sch;
     source: Src;
 };
-export declare function parsePath(input: ModulePath): string[];
+export declare function splitModuleFilePath(input: ModuleFilePath): string[];
+export declare function splitModulePath(input: ModulePath): string[];
+export declare function splitJoinedSourcePaths(input: string): SourcePath[];
+export declare function parentOfSourcePath(sourcePath: SourcePath): SourcePath;
+export declare function patchPathToModulePath(patchPath: string[]): ModulePath;
 export type SerializedModule = {
     source: Json;
     schema: SerializedSchema;

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,16 +1,17 @@
 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;
     opt: boolean;
 };
 export type FileMetadata = {
-    sha256: string;
     mimeType?: string;
 };
 export declare class FileSchema<Src extends FileSource<FileMetadata | undefined> | null> extends Schema<Src> {
@@ -18,7 +19,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";
@@ -16,7 +17,6 @@ export type SerializedImageSchema = {
 export type ImageMetadata = {
     width: number;
     height: number;
-    sha256: string;
     mimeType: string;
     hotspot?: {
         x: number;
@@ -30,7 +30,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,7 +1,7 @@
-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";
+import { Source, SourceObject } from "../source/index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 import { RawString } from "./string.js";
@@ -10,18 +10,18 @@ export type SerializedKeyOfSchema = {
     path: SourcePath;
     schema: SerializedSchema;
     opt: boolean;
-    values: "string" | "number" | string[];
+    values: "string" | 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>> {
+type KeyOfSelector<Sel extends GenericSelector<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<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>>;
+export declare const keyOf: <Src extends GenericSelector<SourceObject> & ValModuleBrand>(valModule: Src) => Schema<KeyOfSelector<Src>>;
 export {};

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>;