@valbuild/core 0.138.0 → 0.139.0

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

@@ -4,7 +4,6 @@ import { ModulePath, SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 import { ValModule } from "../index.js";
 import { ItemPreviewInput, PreviewItem } from "../preview.js";
-import { FieldRender } from "../render.js";
 import { AltSource, ImagesetEntryMetadata } from "./imageset.js";
 /**
  * How an uploaded image is re-encoded in the browser, before it is uploaded.
@@ -47,8 +46,6 @@ export type ImageOptions = {
 };
 export type SerializedImageSchema = {
     type: "image";
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
-    render?: FieldRender;
     /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
     preview?: true;
     options?: ImageOptions;
@@ -79,9 +76,8 @@ export declare class ImageSchema<Src extends ImageSource | null> extends Schema<
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(options?: ImageOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, ImagesetEntryMetadata<AltSource>>>, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(options?: ImageOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, ImagesetEntryMetadata<AltSource>>>, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -177,25 +173,6 @@ export declare class ImageSchema<Src extends ImageSource | null> extends Schema<
     readonly(isReadonly?: boolean): ImageSchema<Src>;
     hidden(isHidden?: boolean): ImageSchema<Src>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
-    /**
-     * How this field is laid out in the editor when it is the item of an array
-     * or record: `{ as: "inline" }` renders the field itself inside each row,
-     * instead of a preview row that navigates to it.
-     *
-     * Static configuration, not a callback — see `render.ts`.
-     *
-     * @example
-     * const schema = s.array(s.image().render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, [
-     *   {
-     *     path: "/public/val/example.png",
-     *     width: 100,
-     *     height: 100,
-     *     mimeType: "image/png",
-     *   },
-     * ]);
-     */
-    render(input: FieldRender): ImageSchema<Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field

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

@@ -9,7 +9,10 @@ import { ItemPreviewInput, PreviewItem } from "../preview.js";
 import { FieldRender } from "../render.js";
 export type SerializedKeyOfSchema = {
     type: "keyOf";
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
+    /**
+     * `{ as: "inline" }` shows the selected entry's content below the selector.
+     * About this field alone; no list reads it. See `render.ts`.
+     */
     render?: FieldRender;
     /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
     preview?: true;
@@ -92,16 +95,21 @@ export declare class KeyOfSchema<Sel extends GenericSelector<SourceObject>, Src
     hidden(isHidden?: boolean): KeyOfSchema<Sel, Src>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
     /**
-     * How this field is laid out in the editor when it is the item of an array
-     * or record: `{ as: "inline" }` renders the field itself inside each row,
-     * instead of a preview row that navigates to it.
+     * How this reference is laid out in the editor: `{ as: "inline" }` shows the
+     * selected entry's content below the selector, so it can be read (and
+     * reached) without leaving the field.
+     *
+     * This is about the keyOf field alone. Whether a LIST of references draws
+     * its rows inline is the list's own `.render(...)` — see `render.ts`.
      *
      * Static configuration, not a callback — see `render.ts`.
      *
      * @example
      * import authorsVal from "./authors.val"; // a record module
-     * const schema = s.array(s.keyOf(authorsVal).render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, ["ada"]);
+     * const schema = s.object({
+     *   author: s.keyOf(authorsVal).render({ as: "inline" }),
+     * });
+     * export default c.define("/example.val.ts", schema, { author: "ada" });
      */
     render(input: FieldRender): KeyOfSchema<Sel, Src>;
     /**

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

@@ -1,12 +1,9 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ItemPreviewInput, PreviewItem } from "../preview.js";
-import { FieldRender } from "../render.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedLiteralSchema = {
     type: "literal";
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
-    render?: FieldRender;
     /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
     preview?: true;
     value: string;
@@ -23,11 +20,10 @@ export declare class LiteralSchema<Src extends string | null> extends Schema<Src
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
     /** Type-only marker: as a record key, this declares the key set. See `LocaleSchema`. */
     readonly __declaresRecordKeys: true;
-    constructor(value: string, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(value: string, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -75,18 +71,6 @@ export declare class LiteralSchema<Src extends string | null> extends Schema<Src
     readonly(isReadonly?: boolean): LiteralSchema<Src>;
     hidden(isHidden?: boolean): LiteralSchema<Src>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
-    /**
-     * How this field is laid out in the editor when it is the item of an array
-     * or record: `{ as: "inline" }` renders the field itself inside each row,
-     * instead of a preview row that navigates to it.
-     *
-     * Static configuration, not a callback — see `render.ts`.
-     *
-     * @example
-     * const schema = s.array(s.literal("hero").render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, ["hero"]);
-     */
-    render(input: FieldRender): LiteralSchema<Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field

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

@@ -1,12 +1,9 @@
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ItemPreviewInput, PreviewItem } from "../preview.js";
-import { FieldRender } from "../render.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedLocaleSchema = {
     type: "locale";
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
-    render?: FieldRender;
     /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
     preview?: true;
     opt: boolean;
@@ -35,7 +32,6 @@ export declare class LocaleSchema<Src extends string | null> extends Schema<Src>
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
     /**
      * Type-only marker: as a record key, this schema DECLARES the key set.
@@ -47,7 +43,7 @@ export declare class LocaleSchema<Src extends string | null> extends Schema<Src>
      * `RecordSrcOf`.
      */
     readonly __declaresRecordKeys: true;
-    constructor(opt?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(opt?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * A note to whoever edits this field, shown under it in the Studio.
      *
@@ -92,15 +88,6 @@ export declare class LocaleSchema<Src extends string | null> extends Schema<Src>
     hidden(): LocaleSchema<Src>;
     protected isLocaleField(): boolean;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
-    /**
-     * How this field is laid out where it is the item of an array or a record.
-     * Static configuration, not a callback — see `render.ts`.
-     *
-     * @example
-     * const schema = s.array(s.locale().render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, ["nb-NO", "en-US"]);
-     */
-    render(input: FieldRender): LocaleSchema<Src>;
     /**
      * How this VALUE is shown where a preview of it is needed. Never how the field
      * itself is edited (that is `render`). See `preview.ts`.

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

@@ -1,6 +1,5 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ItemPreviewInput, PreviewItem } from "../preview.js";
-import { FieldRender } from "../render.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 type NumberOptions = {
@@ -9,8 +8,6 @@ type NumberOptions = {
 };
 export type SerializedNumberSchema = {
     type: "number";
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
-    render?: FieldRender;
     /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
     preview?: true;
     options?: NumberOptions;
@@ -27,9 +24,8 @@ export declare class NumberSchema<Src extends number | null> extends Schema<Src>
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(options?: NumberOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(options?: NumberOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -91,18 +87,6 @@ export declare class NumberSchema<Src extends number | null> extends Schema<Src>
      */
     min(min: number): NumberSchema<Src>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
-    /**
-     * How this field is laid out in the editor when it is the item of an array
-     * or record: `{ as: "inline" }` renders the field itself inside each row,
-     * instead of a preview row that navigates to it.
-     *
-     * Static configuration, not a callback — see `render.ts`.
-     *
-     * @example
-     * const schema = s.array(s.number().render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, [1, 2]);
-     */
-    render(input: FieldRender): NumberSchema<Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field

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

@@ -1,13 +1,10 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { ItemPreviewInput, PreviewItem, ReifiedPreview, PreviewScope } from "../preview.js";
-import { FieldRender } from "../render.js";
 import { SelectorSource } from "../selector/index.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedObjectSchema = {
     type: "object";
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
-    render?: FieldRender;
     /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
     preview?: true;
     items: Record<string, SerializedSchema>;
@@ -57,9 +54,8 @@ export declare class ObjectSchema<Props extends ObjectSchemaProps, Src extends O
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(items: Props, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(items: Props, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -123,24 +119,6 @@ export declare class ObjectSchema<Props extends ObjectSchemaProps, Src extends O
         schema: Schema<SelectorSource>;
     }[];
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
-    /**
-     * How this field is laid out in the editor when it is the item of an array
-     * or record: `{ as: "inline" }` renders the field itself inside each row,
-     * instead of a preview row that navigates to it.
-     *
-     * Static configuration, not a callback — see `render.ts`.
-     *
-     * @example
-     * // A page builder: each row edits the object in place, instead of
-     * // navigating to it.
-     * const block = s
-     *   .object({ heading: s.string(), body: s.string() })
-     *   .render({ as: "inline" });
-     * export default c.define("/example.val.ts", s.array(block), [
-     *   { heading: "Hello", body: "World" },
-     * ]);
-     */
-    render(input: FieldRender): ObjectSchema<Props, Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field

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

@@ -28,7 +28,10 @@ export type SerializedRecordSchema = {
      * schema. See `SerializedArraySchema`.
      */
     preview?: true;
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
+    /**
+     * How this record lays out its ENTRIES: `{ as: "inline" }` edits each one
+     * in place. Static config, carried whole — see `render.ts`.
+     */
     render?: FieldRender;
     router?: string;
     /**
@@ -375,15 +378,18 @@ RO extends boolean = false> extends Schema<Src> {
      */
     preview(select: ItemPreviewInput<Src>): RecordSchema<T, K, Src>;
     /**
-     * How this field is laid out in the editor when it is the item of an array
-     * or record: `{ as: "inline" }` renders the field itself inside each row,
-     * instead of a preview row that navigates to it.
+     * How this record lays out its ENTRIES in the editor: `{ as: "inline" }`
+     * draws each entry's own editor in place, labelled by its key, instead of a
+     * preview row that navigates to it. It reaches the direct entries only.
+     *
+     * Not for `s.router(...)`, `s.imageset(...)` or `s.fileset(...)`: pages and
+     * media have UIs of their own, so this throws on them.
      *
      * Static configuration, not a callback — see `render.ts`.
      *
      * @example
-     * const schema = s.array(s.record(s.string()).render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, [{ en: "Read more" }]);
+     * const schema = s.record(s.string()).render({ as: "inline" });
+     * export default c.define("/example.val.ts", schema, { en: "Read more" });
      */
     render(input: FieldRender): RecordSchema<T, K, Src>;
 }

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

@@ -1,6 +1,5 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ItemPreviewInput, PreviewItem } from "../preview.js";
-import { FieldRender } from "../render.js";
 import { RichTextSource, RichTextOptions, SerializedRichTextOptions } from "../source/richtext.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
@@ -10,8 +9,6 @@ type ValidationOptions = {
 };
 export type SerializedRichTextSchema = {
     type: "richtext";
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
-    render?: FieldRender;
     /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
     preview?: true;
     opt: boolean;
@@ -28,9 +25,8 @@ export declare class RichTextSchema<O extends RichTextOptions, Src extends RichT
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(options: O & ValidationOptions, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(options: O & ValidationOptions, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -108,20 +104,6 @@ export declare class RichTextSchema<O extends RichTextOptions, Src extends RichT
     readonly(isReadonly?: boolean): RichTextSchema<O, Src>;
     hidden(isHidden?: boolean): RichTextSchema<O, Src>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
-    /**
-     * How this field is laid out in the editor when it is the item of an array
-     * or record: `{ as: "inline" }` renders the field itself inside each row,
-     * instead of a preview row that navigates to it.
-     *
-     * Static configuration, not a callback — see `render.ts`.
-     *
-     * @example
-     * const schema = s.array(s.richtext().render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, [
-     *   [{ tag: "p", children: ["Hello"] }],
-     * ]);
-     */
-    render(input: FieldRender): RichTextSchema<O, Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field

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

@@ -1,7 +1,6 @@
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
 import { ItemPreviewInput, PreviewItem } from "../preview.js";
-import { FieldRender } from "../render.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 type RouteOptions = {
     include?: RegExp;
@@ -9,8 +8,6 @@ type RouteOptions = {
 };
 export type SerializedRouteSchema = {
     type: "route";
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
-    render?: FieldRender;
     /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
     preview?: true;
     options?: {
@@ -37,9 +34,8 @@ export declare class RouteSchema<Src extends string | null> extends Schema<Src>
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(options?: RouteOptions | undefined, opt?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(options?: RouteOptions | undefined, opt?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -111,18 +107,6 @@ export declare class RouteSchema<Src extends string | null> extends Schema<Src>
     readonly(isReadonly?: boolean): RouteSchema<Src>;
     hidden(isHidden?: boolean): RouteSchema<Src>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
-    /**
-     * How this field is laid out in the editor when it is the item of an array
-     * or record: `{ as: "inline" }` renders the field itself inside each row,
-     * instead of a preview row that navigates to it.
-     *
-     * Static configuration, not a callback — see `render.ts`.
-     *
-     * @example
-     * const schema = s.array(s.route().render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, ["/a-page-slug"]);
-     */
-    render(input: FieldRender): RouteSchema<Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field

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

@@ -1,6 +1,5 @@
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { PreviewScope, ReifiedPreview } from "../preview.js";
-import { FieldRender } from "../render.js";
 import { SelectorSource } from "../selector/index.js";
 import { SettingsSource } from "../source/settings.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
@@ -20,19 +19,16 @@ export type SerializedSettingsSchema = {
     /**
      * Present in the shape, never set by `s.settings()`.
      *
-     * `render` and `preview` say how a value is drawn where it is an ITEM of an
-     * array or a record, and `customValidate` marks a user's `validate` closure. A
-     * settings module is not an item, and `s.settings()` takes no arguments to
-     * declare any of the three with — so nothing writes them.
+     * `preview` says how a value is drawn where it is an ITEM of an array or a
+     * record, and `customValidate` marks a user's `validate` closure. A settings
+     * module is not an item, and `s.settings()` takes no arguments to declare
+     * either with — so nothing writes them.
      *
-     * They are declared anyway, and with their real types rather than `never`, for
-     * two reasons: reading `schema.render` off a `SerializedSchema` has to stay
-     * legal (`isInlineRender` does exactly that), and a `?: never` member is typed
-     * `undefined`, which makes the whole `SerializedSchema` union stop being
-     * assignable to `Json` — and serialized schemas travel to the Studio and to
-     * the MCP tools as JSON.
+     * They are declared anyway, and with their real types rather than `never`,
+     * because a `?: never` member is typed `undefined`, which makes the whole
+     * `SerializedSchema` union stop being assignable to `Json` — and serialized
+     * schemas travel to the Studio and to the MCP tools as JSON.
      */
-    render?: FieldRender;
     preview?: true;
     customValidate?: boolean;
     readonly?: boolean;

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

@@ -1,6 +1,5 @@
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ItemPreviewInput, PreviewItem } from "../preview.js";
-import { FieldRender } from "../render.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 type StringOptions = {
@@ -11,16 +10,6 @@ type StringOptions = {
 };
 export type SerializedStringSchema = {
     type: "string";
-    /**
-     * How this field is laid out in the editor, carried WHOLE rather than as a
-     * marker.
-     *
-     * A render is static configuration — no closure, no dependency on source — so
-     * unlike a `preview` it serializes in full, and the editor reads it straight
-     * off the schema it already has. See `render.ts` for what that assumption
-     * buys, and what to do if a render ever needs to stop being static.
-     */
-    render?: FieldRender;
     /**
      * Set by `.multiline()`: the field is a growing text box rather than a
      * single-line input.
@@ -59,13 +48,12 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
     private readonly opt;
     private readonly isRaw;
     private readonly customValidateFunctions;
-    private readonly renderInput;
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
     private readonly previewInput;
     private readonly isMultiline;
-    constructor(options?: StringOptions | undefined, opt?: boolean, isRaw?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], renderInput?: FieldRender | null, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null, isMultiline?: boolean);
+    constructor(options?: StringOptions | undefined, opt?: boolean, isRaw?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null, isMultiline?: boolean);
     /**
      * Describe this field.
      *
@@ -192,19 +180,6 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
      * export default c.define("/example.val.ts", schema, "Line one\nLine two");
      */
     multiline(): StringSchema<Src>;
-    /**
-     * How this field is laid out in the editor when it is the item of an array or
-     * record: `{ as: "inline" }` renders the field itself inside each row,
-     * instead of a preview row that navigates to it.
-     *
-     * Static configuration, not a callback — see `render.ts`. What a CONTAINER
-     * shows for its items is a `preview`, which is a different thing entirely.
-     *
-     * @example
-     * const schema = s.array(s.string().render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, ["First", "Second"]);
-     */
-    render(input: FieldRender): StringSchema<Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field

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

@@ -1,7 +1,6 @@
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import type { ModuleIdOf, ValModuleBrand } from "../module.js";
 import { ReifiedPreview } from "../preview.js";
-import { FieldRender } from "../render.js";
 import { GenericSelector } from "../selector/index.js";
 import { Source } from "../source/index.js";
 import { ValViewSource } from "../source/view.js";
@@ -9,7 +8,6 @@ import { ModuleFilePath, SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedValViewSchema = {
     type: "view";
-    render?: FieldRender;
     /** Never set: a view has no value of its own to preview. Carried for shape parity. */
     preview?: true;
     /** Always false: a view points at a module, and `null` is not a module. */
@@ -57,7 +55,6 @@ export declare class ValViewSchema<Id extends string = string, T = unknown> exte
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     constructor(moduleFilePath: Id, 
     /**
      * The module this points at, as an object.
@@ -68,7 +65,7 @@ export declare class ValViewSchema<Id extends string = string, T = unknown> exte
      * optional). Absent on a schema that came off the wire, which is fine: the
      * Studio navigates to a view, it does not resolve one.
      */
-    valModule?: unknown, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null);
+    valModule?: unknown, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
     /**
      * Describe this field.
      *
@@ -154,22 +151,6 @@ export declare class ValViewSchema<Id extends string = string, T = unknown> exte
      * });
      */
     hidden(isHidden?: boolean): ValViewSchema<Id, T>;
-    /**
-     * How this field is laid out in the editor. Static configuration, not a
-     * callback — see `render.ts`.
-     *
-     * @example
-     * import otherVal from "./other.val"; // another module
-     * const schema = s.object({
-     *   shared: s.view(otherVal).render({ as: "inline" }),
-     *   title: s.string(),
-     * });
-     * export default c.define("/example.val.ts", schema, {
-     *   shared: { view: "/other.val.ts" },
-     *   title: "Hello",
-     * });
-     */
-    render(input: FieldRender): ValViewSchema<Id, T>;
     protected executeSerialize(): SerializedSchema;
     protected executePreview(): ReifiedPreview;
 }

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

@@ -0,0 +1,37 @@
+/**
+ * How Val names a media file: a cleaned-up base name, the first five hex of the
+ * content's SHA-256, and the extension — `hero-mountains_a1b2c.jpg`.
+ *
+ * Two producers need this and must agree: an upload (`createFilename`, which
+ * has the bytes) and a rename (`createRenamedFilename`, which keeps the bytes
+ * and only changes what is in front of the hash). If they disagreed, renaming a
+ * file to the name it was uploaded with would give it a different name.
+ */
+/** The `_a1b2c` a Val filename ends in, before the extension. */
+export declare const FILENAME_HASH_SUFFIX_LENGTH = 5;
+/**
+ * The part of a filename a person chose, made safe for a URL path.
+ *
+ * Lower case, with everything `encodeURIComponent` would escape dropped rather
+ * than escaped — a path segment that needs decoding is a path segment that gets
+ * decoded twice somewhere. Can return the empty string, for a name made only of
+ * such characters; a caller that needs a name has to refuse that.
+ */
+export declare function sanitizeFilenameBase(base: string): string;
+/**
+ * `base` with a trailing `_<hashPrefix>` removed, so a name that already carries
+ * the hash does not get it twice (`photo_a1b2c` + `a1b2c` → `photo_a1b2c`, not
+ * `photo_a1b2c_a1b2c`).
+ */
+export declare function stripHashSuffix(base: string, hashPrefix: string): string;
+/**
+ * The name a file gets when it is renamed to `newBase`.
+ *
+ * The hash and the extension are not the editor's to change: the hash keeps two
+ * different files from ever sharing a name, and the extension is part of a
+ * remote file's validation hash and of how its bytes are served. So they are
+ * passed in, and only the base comes from the person.
+ *
+ * Returns `null` when nothing usable is left of `newBase` after cleaning it.
+ */
+export declare function createRenamedFilename(newBase: string, sha256: string, ext: string): string | null;