@valbuild/core 0.93.0 → 0.95.0

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

@@ -0,0 +1,15 @@
+import type { ModuleFilePath, SourcePath } from "./val/index.js";
+import type { SerializedSchema } from "./schema/index.js";
+/**
+ * Given a URL pathname (e.g. "/blogs/blog-1") and all serialized module schemas,
+ * finds the matching next-app-router module and returns the module file path
+ * and the source path for that route's content.
+ *
+ * External routers (e.g. external-url-router) are intentionally skipped.
+ * Returns null if no next-app-router module matches the pathname.
+ */
+export declare function getSourcePathFromRoute(pathname: string, schemas: Record<ModuleFilePath, SerializedSchema>): {
+    moduleFilePath: ModuleFilePath;
+    sourcePath: SourcePath;
+    route: string;
+} | null;

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

@@ -55,6 +55,7 @@ export { type SerializedLiteralSchema, LiteralSchema } from "./schema/literal.js
 export { deserializeSchema } from "./schema/deserialize.js";
 export { type ListRecordRender, type ListArrayRender, type ReifiedRender, type CodeLanguage, type CodeRender, } from "./render.js";
 export type { ValRouter, RouteValidationError } from "./router.js";
+export { getSourcePathFromRoute } from "./getSourcePathFromRoute.js";
 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 declare const DEFAULT_CONTENT_HOST = "https://content.val.build";

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

@@ -10,9 +10,11 @@ import { literal } from "./schema/literal.js";
 import { keyOf } from "./schema/keyOf.js";
 import { record } from "./schema/record.js";
 import { file } from "./schema/file.js";
+import { files } from "./schema/files.js";
 import { date } from "./schema/date.js";
 import { route } from "./schema/route.js";
 import { router } from "./schema/router.js";
+import { images } from "./schema/images.js";
 export type InitSchema = {
     /**
      * Define a string.
@@ -196,6 +198,44 @@ export type InitSchema = {
      * @returns A RecordSchema configured as a router
      */
     readonly router: typeof router;
+    /**
+     * Define a collection of images.
+     *
+     * @example
+     * ```typescript
+     * const schema = s.images({
+     *   accept: "image/webp",
+     *   directory: "/public/val/images",
+     *   alt: s.string().minLength(4),
+     * });
+     * export default c.define("/content/images.val.ts", schema, {
+     *   "/public/val/images/hero.webp": {
+     *     width: 1920,
+     *     height: 1080,
+     *     mimeType: "image/webp",
+     *     alt: "Hero image",
+     *   },
+     * });
+     * ```
+     */
+    readonly images: typeof images;
+    /**
+     * Define a collection of files.
+     *
+     * @example
+     * ```typescript
+     * const schema = s.files({
+     *   accept: "application/pdf",
+     *   directory: "/public/val/documents",
+     * });
+     * export default c.define("/content/documents.val.ts", schema, {
+     *   "/public/val/documents/report.pdf": {
+     *     mimeType: "application/pdf",
+     *   },
+     * });
+     * ```
+     */
+    readonly files: typeof files;
 };
 export declare function initSchema(): {
     string: <T extends string>(options?: Record<string, never>) => import("./schema/string.js").StringSchema<T>;
@@ -211,6 +251,7 @@ export declare function initSchema(): {
         andThen?: never;
         assert?: never;
         fold?: never;
+        patch_id?: never;
     }>(schema: Props) => import("./schema/object.js").ObjectSchema<Props, { [key in keyof Props]: import("./schema/index.js").SelectorOfSchema<Props[key]>; }>;
     number: (options?: {
         max?: number;
@@ -218,12 +259,28 @@ export declare function initSchema(): {
     }) => import("./schema/number.js").NumberSchema<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/union.js").UnionSchema<Key, T, 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/richtext.js").RichTextSchema<O, import("./index.js").RichTextSource<O>>;
-    image: (options?: import("./schema/image.js").ImageOptions) => import("./schema/image.js").ImageSchema<import("./index.js").ImageSource>;
+    image: (options?: import("./schema/image.js").ImageOptions | import("./module.js").ValModule<Record<string, import("./schema/images.js").ImagesEntryMetadata>>) => import("./schema/image.js").ImageSchema<import("./index.js").ImageSource | import("./index.js").RemoteSource<import("./schema/image.js").ImageMetadata | undefined>>;
     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/keyOf.js").KeyOfSchema<Src, 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: typeof record;
-    file: (options?: import("./schema/file.js").FileOptions) => import("./schema/file.js").FileSchema<import("./index.js").FileSource<import("./schema/file.js").FileMetadata>>;
+    file: (options?: import("./schema/file.js").FileOptions | import("./module.js").ValModule<Record<string, import("./schema/files.js").FilesEntryMetadata>>) => import("./schema/file.js").FileSchema<import("./index.js").FileSource | import("./index.js").RemoteSource<import("./schema/file.js").FileMetadata | undefined>>;
+    files: (options: import("./schema/files.js").FilesOptions) => import("./schema/record.js").RecordSchema<import("./schema/object.js").ObjectSchema<{
+        mimeType: import("./schema/string.js").StringSchema<string>;
+    }, {
+        mimeType: string;
+    }>, import("./schema/index.js").Schema<string>, Record<string, import("./schema/files.js").FilesEntryMetadata>>;
     date: (options?: Record<string, never>) => import("./schema/date.js").DateSchema<import("./schema/string.js").RawString>;
     route: <T extends string>(options?: Record<string, never>) => import("./schema/route.js").RouteSchema<T>;
     router: typeof router;
+    images: <Accept extends `image/${string}`>(options: import("./schema/images.js").ImagesOptions<Accept>) => import("./schema/record.js").RecordSchema<import("./schema/object.js").ObjectSchema<{
+        width: import("./schema/number.js").NumberSchema<number>;
+        height: import("./schema/number.js").NumberSchema<number>;
+        mimeType: import("./schema/string.js").StringSchema<string>;
+        alt: import("./schema/string.js").StringSchema<string | null>;
+    }, {
+        width: number;
+        height: number;
+        mimeType: string;
+        alt: string | null;
+    }>, import("./schema/index.js").Schema<string>, Record<string, import("./schema/images.js").ImagesEntryMetadata>>;
 };

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

@@ -27,6 +27,14 @@ export type ValConfig = {
         commitMessages?: {
             disabled?: boolean;
         };
+        chat?: {
+            experimental?: {
+                enable?: boolean;
+            };
+            suggestions?: string[];
+            title?: string;
+            description?: string;
+        };
     };
 };
 export type InitVal = {

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

@@ -19,7 +19,8 @@ export type ReplaceRawStringWithString<T extends SelectorSource> = SelectorSourc
 } : T extends SelectorSource[] ? ReplaceRawStringWithString<T[number]>[] : T;
 export declare function define<T extends Schema<SelectorSource>>(id: string, // TODO: `/${string}`
 schema: T, source: ReplaceRawStringWithString<SelectorOfSchema<T>>): ValModule<SelectorOfSchema<T>>;
-export declare function getSource(valModule: ValModule<SelectorSource>): Source;
+export declare function enrichFileImageRemoteSourceWithMetadata<T extends SelectorSource>(source: T, schema: Schema<SelectorSource>): T;
+export declare function getSource<T extends Source>(valModule: ValModule<T>): T;
 export declare function splitModuleFilePathAndModulePath(path: SourcePath | ModuleFilePath): [moduleId: ModuleFilePath, path: ModulePath];
 export declare function joinModuleFilePathAndModulePath(moduleFilePath: ModuleFilePath, modulePath: ModulePath): SourcePath;
 export declare function getSourceAtPath(modulePath: ModulePath, valModule: ValModule<SelectorSource> | Source): any;

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

@@ -7,6 +7,10 @@ export type RouteValidationError = {
         expectedPath: string | null;
     };
 };
+export declare function validateUrlAgainstPattern(urlPath: string, routePattern: string[]): {
+    isValid: boolean;
+    expectedPath?: string;
+};
 export declare const nextAppRouter: ValRouter;
 /**
  * Parse Next.js route pattern from file path

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

@@ -1,10 +1,11 @@
 import { Json } from "../Json.js";
 import { FileSource } from "../source/file.js";
 import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
-import { SourcePath } from "../val/index.js";
+import { ModulePath, SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
-import { RemoteSource } from "../index.js";
+import { RemoteSource, ValModule } from "../index.js";
 import { ReifiedRender } from "../render.js";
+import { FilesEntryMetadata } from "./files.js";
 export type FileOptions = {
     accept?: string;
 };
@@ -14,6 +15,7 @@ export type SerializedFileSchema = {
     remote?: boolean;
     opt: boolean;
     customValidate?: boolean;
+    referencedModule?: string;
 };
 export type FileMetadata = {
     mimeType?: string;
@@ -23,7 +25,8 @@ export declare class FileSchema<Src extends FileSource<FileMetadata | undefined>
     private readonly opt;
     protected readonly isRemote: boolean;
     private readonly customValidateFunctions;
-    constructor(options?: FileOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    private readonly moduleMetadata;
+    constructor(options?: FileOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, FilesEntryMetadata>>);
     remote(): FileSchema<Src | RemoteSource<FileMetadata | undefined>>;
     validate(validationFunction: CustomValidateFunction<Src>): FileSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
@@ -32,7 +35,7 @@ export declare class FileSchema<Src extends FileSource<FileMetadata | undefined>
     protected executeSerialize(): SerializedSchema;
     protected executeRender(): ReifiedRender;
 }
-export declare const file: (options?: FileOptions) => FileSchema<FileSource<FileMetadata>>;
+export declare const file: (options?: FileOptions | ValModule<Record<string, FilesEntryMetadata>>) => FileSchema<FileSource | RemoteSource<FileMetadata | undefined>>;
 export declare function convertFileSource<Metadata extends {
     readonly [key: string]: Json;
 } | undefined = {

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

@@ -0,0 +1,56 @@
+import { Schema } from "./index.js";
+import type { SerializedRecordSchema } from "./record.js";
+import { RecordSchema } from "./record.js";
+import { ObjectSchema } from "./object.js";
+import { StringSchema } from "./string.js";
+/**
+ * Options for s.files()
+ */
+export type FilesOptions = {
+    /**
+     * The accepted mime type pattern (e.g., "application/pdf", "text/*", "*\/*")
+     */
+    accept: string;
+    /**
+     * The directory where files should be stored.
+     * Must start with "/public" (e.g., "/public/val/files")
+     * @default "/public/val"
+     */
+    directory?: "/public" | `/public/${string}`;
+    /**
+     * Whether remote files are allowed
+     * @default false
+     */
+    remote?: boolean;
+};
+/**
+ * Metadata for a file entry in the files record
+ */
+export type FilesEntryMetadata = {
+    mimeType: string;
+};
+export type SerializedFilesSchema = SerializedRecordSchema;
+type FilesItemProps = {
+    mimeType: StringSchema<string>;
+};
+type FilesItemSrc = {
+    mimeType: string;
+};
+/**
+ * Define a collection of files.
+ *
+ * @example
+ * ```typescript
+ * const schema = s.files({
+ *   accept: "application/pdf",
+ *   directory: "/public/val/documents",
+ * });
+ * export default c.define("/content/documents.val.ts", schema, {
+ *   "/public/val/documents/report.pdf": {
+ *     mimeType: "application/pdf",
+ *   },
+ * });
+ * ```
+ */
+export declare const files: (options: FilesOptions) => RecordSchema<ObjectSchema<FilesItemProps, FilesItemSrc>, Schema<string>, Record<string, FilesEntryMetadata>>;
+export {};

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

@@ -1,11 +1,12 @@
 import { CustomValidateFunction, 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 { ModulePath, SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
-import { FileMetadata } from "../index.js";
+import { ValModule } from "../index.js";
 import { RemoteSource } from "../source/remote.js";
 import { ReifiedRender } from "../render.js";
+import { ImagesEntryMetadata } from "./images.js";
 export type ImageOptions = {
     ext?: ["jpg"] | ["webp"];
     directory?: string;
@@ -18,10 +19,12 @@ export type SerializedImageSchema = {
     opt: boolean;
     remote?: boolean;
     customValidate?: boolean;
+    referencedModule?: string;
 };
-export type ImageMetadata = FileMetadata & {
-    width: number;
-    height: number;
+export type ImageMetadata = {
+    width?: number;
+    height?: number;
+    mimeType?: string;
     alt?: string;
     hotspot?: {
         x: number;
@@ -33,7 +36,8 @@ export declare class ImageSchema<Src extends FileSource<ImageMetadata | undefine
     private readonly opt;
     protected readonly isRemote: boolean;
     private readonly customValidateFunctions;
-    constructor(options?: ImageOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    private readonly moduleMetadata;
+    constructor(options?: ImageOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, ImagesEntryMetadata>>);
     remote(): ImageSchema<Src | RemoteSource<ImageMetadata | undefined>>;
     validate(validationFunction: CustomValidateFunction<Src>): ImageSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
@@ -42,4 +46,4 @@ export declare class ImageSchema<Src extends FileSource<ImageMetadata | undefine
     protected executeSerialize(): SerializedSchema;
     protected executeRender(): ReifiedRender;
 }
-export declare const image: (options?: ImageOptions) => ImageSchema<ImageSource>;
+export declare const image: (options?: ImageOptions | ValModule<Record<string, ImagesEntryMetadata>>) => ImageSchema<ImageSource | RemoteSource<ImageMetadata | undefined>>;

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

@@ -0,0 +1,85 @@
+import { Schema } from "./index.js";
+import type { SerializedRecordSchema } from "./record.js";
+import { RecordSchema } from "./record.js";
+import { ObjectSchema } from "./object.js";
+import { StringSchema } from "./string.js";
+import { NumberSchema } from "./number.js";
+/**
+ * Alt schema type - can be a string, nullable string, or a record of locale to string
+ */
+export type AltSchema = StringSchema<string> | StringSchema<string | null> | RecordSchema<StringSchema<string>, Schema<string>, Record<string, string>>;
+/**
+ * Options for s.images()
+ */
+export type ImagesOptions<Accept extends `image/${string}`> = {
+    /**
+     * The accepted mime type pattern. Must be an image type (e.g., "image/png", "image/webp", "image/*")
+     */
+    accept: Accept;
+    /**
+     * The directory where images should be stored.
+     * Must start with "/public" (e.g., "/public/val/images")
+     * @default "/public/val"
+     */
+    directory?: "/public" | `/public/${string}`;
+    /**
+     * Alt text schema. Can be:
+     * - s.string() for required alt text
+     * - s.string().nullable() for optional alt text (default)
+     * - s.record(s.string(), s.string()) for locale-based alt text
+     */
+    alt?: AltSchema;
+    /**
+     * Whether remote images are allowed
+     * @default false
+     */
+    remote?: boolean;
+};
+/**
+ * Metadata for an image entry in the images record
+ */
+export type ImagesEntryMetadata = {
+    width: number;
+    height: number;
+    mimeType: string;
+    alt: string | null;
+    hotspot?: {
+        x: number;
+        y: number;
+    };
+};
+export type SerializedImagesSchema = SerializedRecordSchema;
+type ImagesItemProps = {
+    width: NumberSchema<number>;
+    height: NumberSchema<number>;
+    mimeType: StringSchema<string>;
+    alt: StringSchema<string | null>;
+};
+type ImagesItemSrc = {
+    width: number;
+    height: number;
+    mimeType: string;
+    alt: string | null;
+};
+/**
+ * Define a collection of images.
+ *
+ * @example
+ * ```typescript
+ * const schema = s.images({
+ *   accept: "image/webp",
+ *   directory: "/public/val/images",
+ *   alt: s.string().minLength(4),
+ * });
+ * export default c.define("/content/images.val.ts", schema, {
+ *   "/public/val/images/hero.webp": {
+ *     width: 1920,
+ *     height: 1080,
+ *     mimeType: "image/webp",
+ *     alt: "Hero image",
+ *   },
+ * });
+ * ```
+ */
+export declare const images: <Accept extends `image/${string}`>(options: ImagesOptions<Accept>) => RecordSchema<ObjectSchema<ImagesItemProps, ImagesItemSrc>, Schema<string>, Record<string, ImagesEntryMetadata>>;
+export {};

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

@@ -26,6 +26,8 @@ type ObjectSchemaProps = {
     assert?: never;
     /** Cannot create object with key: fold. It is a reserved name */
     fold?: never;
+    /** Cannot create object with key: patch_id. It is a reserved name */
+    patch_id?: never;
 };
 type ObjectSchemaSrcOf<Props extends ObjectSchemaProps> = {
     [key in keyof Props]: SelectorOfSchema<Props[key]>;

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

@@ -7,6 +7,13 @@ import { RemoteSource } from "../source/remote.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
 import { ImageMetadata } from "./image.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
+type MediaOptions = {
+    type: "files" | "images";
+    accept: string;
+    directory: string;
+    remote: boolean;
+    altSchema?: Schema<SelectorSource>;
+};
 export type SerializedRecordSchema = {
     type: "record";
     item: SerializedSchema;
@@ -14,6 +21,11 @@ export type SerializedRecordSchema = {
     opt: boolean;
     router?: string;
     customValidate?: boolean;
+    mediaType?: "files" | "images";
+    accept?: string;
+    directory?: string;
+    remote?: boolean;
+    alt?: SerializedSchema;
 };
 export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Schema<string>, Src extends Record<SelectorOfSchema<K>, SelectorOfSchema<T>> | null> extends Schema<Src> {
     private readonly item;
@@ -21,12 +33,18 @@ export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Sc
     private readonly customValidateFunctions;
     private readonly currentRouter;
     private readonly keySchema;
-    constructor(item: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], currentRouter?: ValRouter | null, keySchema?: Schema<string> | null);
+    private readonly mediaOptions?;
+    constructor(item: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], currentRouter?: ValRouter | null, keySchema?: Schema<string> | null, mediaOptions?: MediaOptions | undefined);
     validate(validationFunction: (src: Src) => false | string): RecordSchema<T, K, Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    private isRemoteUrl;
+    private validateMediaKey;
+    private validateMediaEntry;
+    private validateMediaMimeType;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): RecordSchema<T, K, Src | null>;
     router(router: ValRouter): RecordSchema<T, K, Src>;
+    remote(): RecordSchema<T, K, Src>;
     private getRouterValidations;
     protected executeSerialize(): SerializedRecordSchema;
     private renderInput;
@@ -45,3 +63,4 @@ export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Sc
 }
 export declare function record<K extends Schema<string>, S extends Schema<SelectorSource>>(key: K, schema: S): RecordSchema<S, K, Record<SelectorOfSchema<K>, SelectorOfSchema<S>>>;
 export declare function record<S extends Schema<SelectorSource>>(schema: S): RecordSchema<S, Schema<string>, Record<string, SelectorOfSchema<S>>>;
+export {};

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

@@ -1,2 +1,2 @@
-export declare const ValidationFix: readonly ["image:add-metadata", "image:check-metadata", "image:upload-remote", "image:download-remote", "image:check-remote", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote", "file:check-remote", "keyof:check-keys", "router:check-route"];
+export declare const ValidationFix: readonly ["image:add-metadata", "image:check-metadata", "image:upload-remote", "image:download-remote", "image:check-remote", "images:check-remote", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote", "file:check-remote", "files:check-remote", "keyof:check-keys", "router:check-route", "images:check-unique-folder", "files:check-unique-folder", "images:check-all-files", "files:check-all-files"];
 export type ValidationFix = (typeof ValidationFix)[number];

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

@@ -18,7 +18,7 @@ import { RemoteSource } from "../source/remote.js";
 export type Selector<T extends Source> = Source extends T ? GenericSelector<T> : T extends ImageSource ? ImageSelector : T extends FileSource<infer M> ? FileSelector<M> : T extends RichTextSource<infer O> ? RichTextSelector<O> : T extends SourceObject ? ObjectSelector<T> : T extends SourceArray ? ArraySelector<T> : T extends string ? StringSelector<T> : T extends number ? NumberSelector<T> : T extends boolean ? BooleanSelector<T> : T extends null ? PrimitiveSelector<null> : never;
 export type SelectorSource = SourcePrimitive | undefined | readonly SelectorSource[] | {
     [key: string]: SelectorSource;
-} | FileSource | RemoteSource | RichTextSource<AllRichTextOptions> | GenericSelector<Source>;
+} | ImageSource | FileSource | RemoteSource | RichTextSource<AllRichTextOptions> | GenericSelector<Source>;
 /**
  * @internal
  */

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

@@ -1,7 +1,8 @@
 import { FileSource } from "./file.js";
+import { ImageSource } from "./image.js";
 import { RemoteSource } from "./remote.js";
 import { RichTextOptions, RichTextSource } from "./richtext.js";
-export type Source = SourcePrimitive | SourceObject | SourceArray | RemoteSource | FileSource | RichTextSource<RichTextOptions>;
+export type Source = SourcePrimitive | SourceObject | SourceArray | RemoteSource | FileSource | ImageSource | RichTextSource<RichTextOptions>;
 export type SourceObject = {
     [key in string]: Source;
 } & {
@@ -23,7 +24,7 @@ export type SourceObject = {
 export type SourceArray = readonly Source[];
 export type SourcePrimitive = string | number | boolean | null;
 export declare const VAL_EXTENSION: "_type";
-export declare function getValExtension(source: Source): false | "" | 0 | "file" | "remote" | null | undefined;
+export declare function getValExtension(source: Source): false | "" | 0 | "remote" | "file" | null | undefined;
 /**
  * A phantom type parameter is one that doesn't show up at runtime, but is checked statically (and only) at compile time.
  *

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

@@ -11,7 +11,7 @@ export type RemoteSource<Metadata extends FileMetadata | undefined = FileMetadat
     readonly metadata?: Metadata;
     readonly patch_id?: string;
 };
-export declare const initRemote: (config?: ValConfig) => <Metadata extends FileMetadata | ImageMetadata>(ref: RemoteRef, metadata: Metadata) => RemoteSource<Metadata>;
+export declare const initRemote: (config?: ValConfig) => <Metadata extends FileMetadata | ImageMetadata>(ref: RemoteRef, metadata?: Metadata) => RemoteSource<Metadata>;
 export type RemoteRef = `${string}/file/p/${string}/v/${string}/h/${string}/f/${string}/p/public/val/${string}`;
 export declare function createRemoteRef(remoteHost: string, { publicProjectId, coreVersion, validationHash, fileHash, filePath, bucket, }: {
     publicProjectId: string;

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

@@ -22,7 +22,7 @@ export type RichTextOptions = Partial<{
     }>;
     inline: Partial<{
         a: boolean | RouteSchema<string> | StringSchema<string>;
-        img: boolean | ImageSchema<ImageSource | RemoteSource<ImageMetadata>>;
+        img: boolean | ImageSchema<ImageSource> | ImageSchema<RemoteSource<ImageMetadata | undefined>> | ImageSchema<ImageSource | RemoteSource<ImageMetadata | undefined>>;
     }>;
 }>;
 export type SerializedRichTextOptions = Partial<{
@@ -93,7 +93,7 @@ export type SpanNode<O extends RichTextOptions> = {
 export type ImageNode<O extends RichTextOptions> = NonNullable<O["inline"]>["img"] extends true ? {
     tag: "img";
     src: ImageSource | RemoteSource<ImageMetadata>;
-} : NonNullable<O["inline"]>["img"] extends ImageSchema<infer Src> ? Src extends RemoteSource | FileSource ? {
+} : NonNullable<O["inline"]>["img"] extends ImageSchema<infer Src> ? Src extends RemoteSource | FileSource | ImageSource ? {
     tag: "img";
     src: Src;
 } : never : never;