@valbuild/core 0.101.0 → 0.103.0

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

@@ -1,12 +1,10 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
-import { RenderSelector, ReifiedRender } from "../render.js";
+import { RenderSelector, ReifiedRender, RenderScope } from "../render.js";
 import { ValRouter } from "../router.js";
 import { SelectorSource } from "../selector/index.js";
-import { ImageSource } from "../source/image.js";
+import { ImageSource } from "../source/media.js";
 import { JsonOf, JsonSource } from "../source/json.js";
-import { RemoteSource } from "../source/remote.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
-import { ImageMetadata } from "./image.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 type MediaOptions = {
     type: "files" | "images";
@@ -20,6 +18,8 @@ export type SerializedRecordSchema = {
     item: SerializedSchema;
     key?: SerializedSchema;
     opt: boolean;
+    /** Set when this schema declares a `render`. See `SerializedArraySchema`. */
+    render?: true;
     router?: string;
     customValidate?: boolean;
     mediaType?: "files" | "images";
@@ -54,7 +54,7 @@ type RecordRenderInput<T extends Schema<SelectorSource>> = {
     }) => {
         title: string;
         subtitle?: string | null;
-        image?: ImageSource | RemoteSource<ImageMetadata> | null;
+        image?: ImageSource | null;
     };
 };
 export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Schema<string>, Src extends Record<SelectorOfSchema<K>, SelectorOfSchema<T>> | JsonValuesRecordSrc<T, K> | null> extends Schema<Src> {
@@ -113,7 +113,7 @@ export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Sc
      * defers).
      */
     validateJsonEntryContent(path: SourcePath, content: SelectorSource): ValidationErrors;
-    protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedRender;
+    protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src, scope?: RenderScope): ReifiedRender;
     render(input: {
         as: "list";
         select: (input: {
@@ -122,7 +122,7 @@ export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Sc
         }) => {
             title: string;
             subtitle?: string | null;
-            image?: ImageSource | RemoteSource<ImageMetadata> | null;
+            image?: ImageSource | null;
         };
     }): RecordSchema<T, K, Src>;
 }

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

@@ -1,11 +1 @@
-import { Json } from "../index.js";
-import { RemoteSource } from "../source/remote.js";
 export declare const DEFAULT_VAL_REMOTE_HOST = "https://remote.val.build";
-export declare function convertRemoteSource<Metadata extends {
-    readonly [key: string]: Json;
-} | undefined = {
-    readonly [key: string]: Json;
-} | undefined>(src: RemoteSource<Metadata>): {
-    url: string;
-    metadata?: Metadata;
-};

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

@@ -1,5 +1,5 @@
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
-import { CodeLanguage, ReifiedRender } from "../render.js";
+import { CodeLanguage, ReifiedRender, RenderScope } from "../render.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 type StringOptions = {
@@ -10,6 +10,8 @@ type StringOptions = {
 };
 export type SerializedStringSchema = {
     type: "string";
+    /** Set when this schema declares a `render`. See `SerializedArraySchema`. */
+    render?: true;
     options?: {
         maxLength?: number;
         minLength?: number;
@@ -73,7 +75,7 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
         as: "code";
         language: CodeLanguage;
     }): StringSchema<Src>;
-    protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedRender;
+    protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src, _scope?: RenderScope): ReifiedRender;
 }
 export declare const string: <T extends string>(options?: Record<string, never>) => StringSchema<T>;
 export {};

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

@@ -1,5 +1,5 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
-import { ReifiedRender } from "../render.js";
+import { ReifiedRender, RenderScope } from "../render.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourceObject } from "../source/index.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
@@ -57,7 +57,7 @@ export declare class UnionSchema<Key extends string | Schema<string>, T extends
     private matchedVariant;
     protected executeSerialize(): SerializedSchema;
     constructor(key: Key, items: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
-    protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedRender;
+    protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src, scope?: RenderScope): ReifiedRender;
 }
 export declare const union: <Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & { [k in Key]: string; } : Key extends Schema<string> ? string : unknown>[]>(key: Key, ...objects: T) => UnionSchema<Key, T, SourceOf<Key, T>>;
 export {};

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

@@ -1,8 +1,15 @@
 import { GenericSelector } from "./index.js";
 import { Source } from "../source/index.js";
-import { ModulePath, SourcePath } from "../val/index.js";
+import { ModuleFilePath, 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 createValPathOfItem(
+/**
+ * `ModuleFilePath` is accepted because the no-separator branch below is
+ * exactly that case: a path with no `?p=` yet gets one, and the key becomes
+ * the first module-path segment. Callers walking a module from its root had
+ * to widen the type themselves, and hand-rolled the concatenation instead.
+ */
+arrayPath: SourcePath | ModulePath | ModuleFilePath | 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/selector/index.d.ts

@@ -4,22 +4,18 @@ import { Selector as NumberSelector } from "./number.js";
 import { Selector as StringSelector } from "./string.js";
 import { Selector as BooleanSelector } from "./boolean.js";
 import { Selector as PrimitiveSelector } from "./primitive.js";
-import { FileSelector } from "./file.js";
 import { SourcePath } from "../val/index.js";
 import { Source, SourceArray, SourceObject, SourcePrimitive } from "../source/index.js";
 import { Schema } from "../schema/index.js";
 import type { A } from "ts-toolbelt";
-import { FileSource } from "../source/file.js";
+import { MediaSource } from "../source/media.js";
 import { AllRichTextOptions, RichTextSource } from "../source/richtext.js";
-import { ImageSelector } from "./image.js";
 import { RichTextSelector } from "./richtext.js";
-import { ImageSource } from "../source/image.js";
-import { RemoteSource } from "../source/remote.js";
 import { JsonSource } from "../source/json.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 JsonSource ? GenericSelector<JsonSource> : 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 Selector<T extends Source> = Source extends T ? GenericSelector<T> : T extends MediaSource ? GenericSelector<T> : T extends JsonSource ? GenericSelector<JsonSource> : 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;
-} | ImageSource | FileSource | RemoteSource | JsonSource | RichTextSource<AllRichTextOptions> | GenericSelector<Source>;
+} | MediaSource | JsonSource | RichTextSource<AllRichTextOptions> | GenericSelector<Source>;
 /**
  * @internal
  */

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

@@ -1,28 +1,10 @@
-import { VAL_EXTENSION } from "./index.js";
-import { ValConfig } from "../initVal.js";
-import { Json } from "../Json.js";
-export declare const FILE_REF_PROP: "_ref";
-export declare const FILE_REF_SUBTYPE_TAG: "_tag";
-export type FileMetadata = {
-    mimeType?: string;
-};
 /**
- * A file source represents the path to a (local) file.
- *
- * It will be resolved into a Asset object.
+ * What Val computes from a file's bytes.
  *
+ * Not part of the source any more — a media source carries these fields
+ * directly — but still the unit the upload and `--fix` pipelines work in:
+ * "here is what reading this file told us".
  */
-export type FileSource<Metadata extends FileMetadata | undefined = FileMetadata | undefined> = {
-    readonly [FILE_REF_PROP]: string;
-    readonly [VAL_EXTENSION]: "file";
-    readonly [FILE_REF_SUBTYPE_TAG]?: string;
-    readonly metadata?: Metadata;
-    readonly patch_id?: string;
-};
-export declare const initFile: (config?: ValConfig) => {
-    <Metadata extends {
-        readonly [key: string]: Json;
-    }>(ref: `${import("../initVal.js").ConfigDirectory}/${string}`, metadata: Metadata): FileSource<Metadata>;
-    (ref: `${import("../initVal.js").ConfigDirectory}/${string}`, metadata?: undefined): FileSource<undefined>;
+export type FileMetadata = {
+    mimeType?: string;
 };
-export declare function isFile(obj: unknown): obj is FileSource;

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

@@ -1,9 +1,7 @@
-import { FileSource } from "./file.js";
-import { ImageSource } from "./image.js";
 import { JsonSource } from "./json.js";
-import { RemoteSource } from "./remote.js";
+import { MediaSource } from "./media.js";
 import { RichTextOptions, RichTextSource } from "./richtext.js";
-export type Source = SourcePrimitive | SourceObject | SourceArray | RemoteSource | FileSource | ImageSource | JsonSource | RichTextSource<RichTextOptions>;
+export type Source = SourcePrimitive | SourceObject | SourceArray | MediaSource | JsonSource | RichTextSource<RichTextOptions>;
 export type SourceObject = {
     [key in string]: Source;
 } & {
@@ -14,8 +12,6 @@ export type SourceObject = {
     /** Reserved name */
     andThen?: never;
     /** Reserved name */
-    _ref?: never;
-    /** Reserved name */
     _type?: never;
     /** Reserved name */
     val?: never;
@@ -25,7 +21,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 | "remote" | "file" | "json" | null | undefined;
+export declare function getValExtension(source: Source): false | "" | 0 | "json" | 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/json.d.ts

@@ -30,7 +30,7 @@ export type JsonImportThunk<T = unknown> = () => Promise<{
  */
 export type JsonSource<T = unknown> = {
     readonly [VAL_EXTENSION]: typeof JSON_VAL_EXTENSION_TAG;
-    /** Set on uncommitted/draft entries (mirrors FileSource/RemoteSource). */
+    /** Set on uncommitted/draft entries (mirrors a media source's). */
     readonly patch_id?: string;
 } & PhantomType<T>;
 export declare function json<T = Json>(importThunk: JsonImportThunk<T>): JsonSource<T>;

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

@@ -0,0 +1,98 @@
+/**
+ * Media — images and files — is a plain object carrying a `path`.
+ *
+ * There is no marker on the value: nothing may decide "this is an image" by
+ * looking at it. The **schema** says so (`type === "image" | "file"`), which is
+ * what lets the same object be written in a `.val.ts` and in a `*.val.json`
+ * entry, where a function call cannot be written at all.
+ *
+ * `path` is a plain `string` rather than a `` `/public/${string}` `` template so
+ * a field can move between local and remote without a type error. Remote-ness
+ * is read off the path: anything not under `/public` is remote.
+ */
+/** What must stay in frame when a page crops an image. */
+export type MediaHotspot = {
+    x: number;
+    y: number;
+};
+/**
+ * The authored fields of a gallery-backed image (`s.image(galleryModule)`):
+ * `width`/`height`/`mimeType` live in the gallery, so they are not repeated
+ * here. One place per fact.
+ */
+export type GalleryImageSource = {
+    readonly path: string;
+    readonly alt?: string;
+    readonly hotspot?: MediaHotspot;
+    /**
+     * Set on a source whose bytes are not committed yet. Injected server-side and
+     * consumed only by {@link mediaUrl} — never written to a `.val.ts`.
+     */
+    readonly patch_id?: string;
+};
+export type ImageSource = GalleryImageSource & {
+    readonly width?: number;
+    readonly height?: number;
+    readonly mimeType?: string;
+};
+export type GalleryFileSource = {
+    readonly path: string;
+    readonly patch_id?: string;
+};
+export type FileSource = GalleryFileSource & {
+    readonly mimeType?: string;
+};
+/**
+ * The structural supertype of every media source.
+ *
+ * It is a named member of the `Source` / `SelectorSource` unions rather than
+ * "just an object" because `SourceObject` is `{[key: string]: Source}` and
+ * `Source` excludes `undefined` — an object with optional properties does not
+ * satisfy it.
+ */
+export type MediaSource = ImageSource;
+/** A path is remote unless it is under `/public`. */
+export declare function isRemoteMediaPath(path: string): boolean;
+/**
+ * Where the bytes of a media source are actually served from.
+ *
+ * Two states, and conflating them is the recurring bug: uncommitted bytes live
+ * in the patch directory and are served by the API with the `patch_id` that put
+ * them there; committed bytes live at the path itself, with `/public` stripped.
+ */
+export declare function mediaUrl(src: {
+    readonly path: string;
+    readonly patch_id?: string;
+}): string;
+/**
+ * A media source plus the URL its bytes are served from.
+ *
+ * `url` is the only generated field: everything else the consumer sees was
+ * either authored or filled in from the gallery.
+ */
+export declare function resolveMedia<S extends {
+    readonly path: string;
+}>(src: S): S & {
+    url: string;
+};
+/**
+ * Fill in what a gallery-backed field does not carry itself.
+ *
+ * `s.image(galleryModule)` stores only `{path, alt?, hotspot?}` — the
+ * dimensions and mime type live in the gallery module, keyed by path. This is
+ * the single implementation of that lookup; core, stega/RSC and the Studio all
+ * call it rather than each rolling their own.
+ *
+ * `alt` is filled in too, because a gallery holds the alt text an editor typed
+ * once for a file used in several places — but only when the field does not
+ * have its own, so a per-image override wins. A gallery whose `alt` schema is a
+ * locale record holds an object rather than a string; that is left alone rather
+ * than copied into a field typed `string`, and making the override
+ * locale-shaped is a separate change.
+ *
+ * The double lookup is load-bearing: a remote gallery keys its entries by the
+ * remote URL while the file itself stays on disk under its local path.
+ */
+export declare function fillFromGallery<S extends {
+    readonly path: string;
+}>(src: S, schema: unknown, getModuleSource: (modulePath: string) => unknown): S;

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

@@ -1,17 +1,3 @@
-import { VAL_EXTENSION } from "./index.js";
-import { ValConfig } from "../initVal.js";
-import { ImageMetadata } from "../schema/image.js";
-import { FILE_REF_PROP, FileMetadata } from "./file.js";
-/**
- * A remote source represents data that is not stored locally.
- */
-export type RemoteSource<Metadata extends FileMetadata | undefined = FileMetadata | undefined> = {
-    readonly [FILE_REF_PROP]: string;
-    readonly [VAL_EXTENSION]: "remote";
-    readonly metadata?: Metadata;
-    readonly patch_id?: string;
-};
-export declare const initRemote: (config?: ValConfig) => <Metadata extends FileMetadata | ImageMetadata>(ref: RemoteRef, metadata?: Metadata) => RemoteSource<Metadata>;
 export type RemoteRef = `${string}/file/p/${string}/b/${string}/v/${string}/h/${string}/f/${string}/p/public/${string}`;
 export declare function createRemoteRef(remoteHost: string, { publicProjectId, coreVersion, validationHash, fileHash, filePath, bucket, }: {
     publicProjectId: string;

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

@@ -1,9 +1,7 @@
-import { ImageMetadata, ImageSchema, SerializedImageSchema } from "../schema/image.js";
+import { ImageSchema, SerializedImageSchema } from "../schema/image.js";
 import { RouteSchema, SerializedRouteSchema } from "../schema/route.js";
 import { StringSchema, SerializedStringSchema } from "../schema/string.js";
-import { FileSource } from "./file.js";
-import { ImageSource } from "./image.js";
-import { RemoteSource } from "./remote.js";
+import { ImageSource } from "./media.js";
 export type RichTextOptions = Partial<{
     style: Partial<{
         bold: boolean;
@@ -22,7 +20,7 @@ export type RichTextOptions = Partial<{
     }>;
     inline: Partial<{
         a: boolean | RouteSchema<string> | StringSchema<string>;
-        img: boolean | ImageSchema<ImageSource> | ImageSchema<RemoteSource<ImageMetadata | undefined>> | ImageSchema<ImageSource | RemoteSource<ImageMetadata | undefined>>;
+        img: boolean | ImageSchema<ImageSource>;
     }>;
 }>;
 export type SerializedRichTextOptions = Partial<{
@@ -92,8 +90,8 @@ 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 | ImageSource ? {
+    src: ImageSource;
+} : NonNullable<O["inline"]>["img"] extends ImageSchema<infer Src> ? Src extends ImageSource ? {
     tag: "img";
     src: Src;
 } : never : never;

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

@@ -4,16 +4,13 @@ import { Val as ArrayVal } from "./array.js";
 import { Val as PrimitiveVal } from "./primitive.js";
 import { Json, JsonArray, JsonObject, JsonPrimitive } from "../Json.js";
 import { Path, Selector } from "../selector/index.js";
-import { RemoteSource } from "../source/remote.js";
-import { FileSource } from "../source/file.js";
+import { MediaSource } from "../source/media.js";
 export type SerializedVal = {
     val: SerializedVal | Json;
     valPath: SourcePath | undefined;
 };
 export declare function isSerializedVal(val: unknown): val is SerializedVal;
-export type JsonOfSource<T extends Source> = Json extends T ? Json : T extends RemoteSource ? {
-    url: string;
-} : T extends FileSource ? {
+export type JsonOfSource<T extends Source> = Json extends T ? Json : T extends MediaSource ? T & {
     url: string;
 } : T extends SourceObject ? {
     [key in keyof T]: JsonOfSource<T[key]>;