@valbuild/core 0.138.0 → 0.139.0

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @valbuild/core
 
+## 0.139.0
+
+### Minor Changes
+
+- [#776](https://github.com/valbuild/val/pull/776) [`3eb5031`](https://github.com/valbuild/val/commit/3eb503167ae466ee586303c95efcc14665129481) Thanks [@freekh](https://github.com/freekh)! - **Breaking:** `.render({ as: "inline" })` now goes on the list, not on its items.
+
+  You now write `s.array(item).render({ as: "inline" })` and `s.record(item).render({ as: "inline" })`. Each item is then edited in its own row instead of in a preview row you click into. The list decides. The item schema stays reusable, and a page builder made of tagged blocks needs nothing on each block:
+
+  ```ts
+  // before
+  s.array(
+    s.discriminatedUnion(
+      "type",
+      hero.render({ as: "inline" }),
+      text.render({ as: "inline" }),
+    ),
+  );
+
+  // after
+  s.array(s.discriminatedUnion("type", hero, text)).render({ as: "inline" });
+  ```
+
+  What changed:
+
+  - Only `s.array()`, `s.record()` and `s.keyOf()` have `.render(...)` now. On every other schema the method is gone, so the old placement shows up as a type error. Move the render out one level.
+  - The render only affects the list's own items. A list nested inside one of those items keeps its default unless it has its own `.render`.
+  - `s.router()`, `s.imageset()` and `s.fileset()` throw if you give them a render, because pages and media have their own editors.
+  - `s.keyOf(...).render({ as: "inline" })` means the same as before: the selected entry's content is shown below the dropdown.
+
+  **Watch for one case that still compiles:** an array or record that is itself the item of another list. `s.record(s.array(s.string()).render({ as: "inline" }))` used to show the record's arrays inline. Now it shows each array's strings inline. To keep the old layout, write `s.record(s.array(s.string())).render({ as: "inline" })`.
+
+## 0.138.2
+
+### Patch Changes
+
+- [#760](https://github.com/valbuild/val/pull/760) [`cf3bbc8`](https://github.com/valbuild/val/commit/cf3bbc8fc89ff349aac5ab101d0b4f28164583e6) Thanks [@freekh](https://github.com/freekh)! - Files and images can now be renamed in the Studio, for local files and remote ones.
+
+  - **Rename a file in a gallery** from its properties: click the pencil next to the file name. Every field that uses the file is updated to the new name in the same step, including images inside rich text, and the dialog says how many places will change before you save.
+  - **Rename the file of an image or file field** with the new **Rename** button. A field that picks its file from a gallery sends you to the gallery instead, because other fields may use the same file.
+  - **You choose the name, Val keeps the rest.** The short hash at the end of the name (`_a1b2c`) and the file extension stay as they are, so two different files can never end up with the same name. The name is cleaned up the same way an upload's is: lower case, and characters that do not belong in a URL are dropped.
+  - **Renaming a local file moves it.** The file is saved under the new name and the old file is deleted when you publish, so nothing is left behind to clean up. If another field uses the same file without going through a gallery, pick the file again in that field.
+  - **Renaming a remote file is instant.** Remote files are stored by their content, so a published remote file only gets a new address and nothing is uploaded again.
+  - **Gallery images used in rich text now count as references.** A gallery file used only inside rich text could be deleted, which left the text pointing at nothing. It is now listed under the file's references and blocks the delete like any other use.
+
 ## 0.138.0
 
 ### Minor Changes

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

@@ -39,6 +39,7 @@ import { isJson, getJsonImport, resolveJsonValues } from "./source/json.js";
 import { isExternal, hasInlineExternalEntries } from "./source/external.js";
 import { createExternalFileRef, splitExternalFileRef, isExternalFileRef } from "./source/externalRef.js";
 import { createRemoteRef } from "./source/remote.js";
+import { createRenamedFilename } from "./source/filename.js";
 import { getValidationBasis, getValidationHash } from "./remote/validationBasis.js";
 import { getFileHash, hashToRemoteFileHash } from "./remote/fileHash.js";
 import { splitRemoteRef } from "./remote/splitRemoteRef.js";
@@ -233,5 +234,6 @@ declare const Internal: {
     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;
+    createRenamedFilename: typeof createRenamedFilename;
 };
 export { Internal };

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

@@ -26,9 +26,19 @@ import type { SerializedSchema } from "./schema/index.js";
  * description still previews as `#3` until someone writes the preview.
  */
 /**
- * A RENDER is how the FIELD ITSELF is laid out in the editor, and it applies
- * only when you are looking at the field: `.render({ as: "inline" })` on an
- * array/record item.
+ * A RENDER is how a field is laid out in the editor, and it applies only when
+ * you are looking at the field. It is declared by a CONTAINER about its
+ * children, never by a child about itself: `s.array(item).render({ as: "inline" })`
+ * and `s.record(item).render({ as: "inline" })`. The one other schema that takes
+ * a render is `s.keyOf(...)`, where it means something of its own (see
+ * `KeyOfSchema.render`).
+ *
+ * Why the container: inline is a property of the LIST — "my items are edited in
+ * their rows" — and the item schema is the wrong place to say it. An item can be
+ * reused in a list that wants preview rows and one that wants forms; a tagged
+ * union had to be declared inline on every variant (or on any one of them,
+ * which was worse); and a schema that was not an item carried a setting that
+ * did nothing. Putting it on the container makes all three go away.
  *
  * It is deliberately the ONE thing a render can say. What a string looks like
  * when it holds more than a line is the schema's own business — `.multiline()`
@@ -45,7 +55,7 @@ import type { SerializedSchema } from "./schema/index.js";
  *
  * A render is static configuration - plain data, with no closure behind it and
  * no dependency on source - which is why it lives in the SERIALIZED schema
- * (`SerializedStringSchema.render`) and is read straight off it where the field
+ * (`SerializedArraySchema.render`) and is read straight off it where the field
  * is drawn. There is no render pipeline, no store and no host round-trip.
  *
  * That "static" is an ASSUMPTION we are taking deliberately, for simplicity,
@@ -56,49 +66,42 @@ import type { SerializedSchema } from "./schema/index.js";
  * conflating them is what this file was split up to undo.
  */
 /**
- * `{ as: "inline" }` on a field that is the ITEM of an array or record: the
- * container renders the field itself inside each (sortable) row, instead of a
- * clickable preview row that navigates to it. This is what a page-builder list
- * is made of: `s.array(s.object({...}).render({ as: "inline" }))`.
+ * `{ as: "inline" }` on an array or record: the container renders each of its
+ * DIRECT items' own editor inside its (sortable) row, instead of a clickable
+ * preview row that navigates to it. This is what a page-builder list is made
+ * of: `s.array(s.discriminatedUnion("type", hero, text)).render({ as: "inline" })`.
+ *
+ * It reaches one level down and no further: in
+ * `s.array(s.object({ tags: s.array(s.string()) })).render({ as: "inline" })`
+ * the objects are inline and `tags` keeps its own default.
  *
- * On a field that is not directly under an array or record it is inert — an
- * object's fields are already laid out in place.
+ * Not available on `s.router(...)`, `s.imageset(...)` or `s.fileset(...)`:
+ * pages and media have UIs of their own, and `RecordSchema.render` throws there.
  *
- * Like every render it is static configuration (see the top of this file): it
- * travels whole in the serialized schema and the editor reads it straight off
- * the item schema it already has.
+ * On `s.keyOf(...)` the same value means something else: the selected entry's
+ * content is shown below the selector. That is the keyOf field's own layout,
+ * and is not read by any list.
  */
 export type InlineRender = {
     as: "inline";
 };
 /**
- * What `.render(...)` takes on every field, and what the serialized schema
- * carries verbatim.
+ * What `.render(...)` takes, and what the serialized schema carries verbatim.
  */
 export type FieldRender = InlineRender;
 /**
- * Is this item schema edited INSIDE its list row, rather than behind a
- * clickable preview row that navigates to it?
+ * Does this CONTAINER edit its items inside their list rows, rather than behind
+ * clickable preview rows that navigate to them?
+ *
+ * Pass the array or record — never the item. Anything else answers `false`,
+ * `s.keyOf` included: its render is about the keyOf field, not about a list.
  *
  * The one answer, so that the list rows, the nav-stop rule (`getNavPath`) and
  * the add buttons cannot drift apart — they are three readings of the same
  * question, and a disagreement between them is a row you can edit in place but
  * that "add" navigates away from.
  *
- * A discriminated union counts as inline when the union itself declares it OR
- * when ANY of its variants does. A page-builder list is
- * `s.array(s.discriminatedUnion("type", block, block, ...))` and the natural
- * place to write the render is on the blocks, one per block type — the union
- * is a dispatch, not something the
- * author thinks of as the field. `some` rather than `every` because the row
- * draws the union's own editor (the tag selector plus the matched variant's
- * fields), which handles every variant either way: with `every`, adding one
- * variant and forgetting its `.render` would silently turn the whole list back
- * into preview rows.
- *
- * This is the ONLY place a render is allowed to be read from anywhere but the
- * schema it was declared on. It stays static (see the top of this file): the
- * answer is a function of the serialized schema alone, never of the value the
- * row happens to hold.
+ * It stays static (see the top of this file): the answer is a function of the
+ * serialized schema alone, never of the value the row happens to hold.
  */
-export declare function isInlineRender(schema: SerializedSchema): boolean;
+export declare function isInlineRender(container: SerializedSchema): boolean;

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

@@ -6,7 +6,10 @@ import { ModuleFilePath, SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedArraySchema = {
     type: "array";
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
+    /**
+     * How this array lays out its ITEMS: `{ as: "inline" }` edits each one in
+     * its row. Static config, carried whole — see `render.ts`.
+     */
     render?: FieldRender;
     item: SerializedSchema;
     opt: boolean;
@@ -124,17 +127,19 @@ export declare class ArraySchema<T extends Schema<SelectorSource>, Src extends S
      */
     preview(select: ItemPreviewInput<Src>): ArraySchema<T, 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 array lays out its ITEMS in the editor: `{ as: "inline" }` draws
+     * each item's own editor inside its (sortable) row, instead of a preview row
+     * that navigates to it. It reaches the direct items only.
      *
      * Static configuration, not a callback — see `render.ts`.
      *
      * @example
-     * const schema = s.record(s.array(s.string()).render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, {
-     *   "a-post": ["news", "release"],
-     * });
+     * const schema = s
+     *   .array(s.object({ title: s.string(), body: s.string() }))
+     *   .render({ as: "inline" });
+     * export default c.define("/example.val.ts", schema, [
+     *   { title: "Hello", body: "World" },
+     * ]);
      */
     render(input: FieldRender): ArraySchema<T, Src>;
 }

package/dist/declarations/src/schema/boolean.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 SerializedBooleanSchema = {
     type: "boolean";
-    /** 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;
@@ -21,9 +18,8 @@ export declare class BooleanSchema<Src extends boolean | null> extends Schema<Sr
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -69,18 +65,6 @@ export declare class BooleanSchema<Src extends boolean | null> extends Schema<Sr
     readonly(isReadonly?: boolean): BooleanSchema<Src>;
     hidden(isHidden?: boolean): BooleanSchema<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.boolean().render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, [true, false]);
-     */
-    render(input: FieldRender): BooleanSchema<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/code.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 { RawString } from "./string.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
@@ -26,8 +25,6 @@ export type CodeOptions = {
 };
 export type SerializedCodeSchema = {
     type: "code";
-    /** 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?: CodeOptions;
@@ -52,9 +49,8 @@ export declare class CodeSchema<Src extends string | null> extends Schema<Src> {
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(options?: CodeOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(options?: CodeOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -111,22 +107,6 @@ export declare class CodeSchema<Src extends string | null> extends Schema<Src> {
     nullable(): CodeSchema<Src | null>;
     readonly(isReadonly?: boolean): CodeSchema<Src>;
     hidden(isHidden?: boolean): CodeSchema<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`.
-     *
-     * @example
-     * const schema = s.array(
-     *   s.code({ language: "css" }).render({ as: "inline" }),
-     * );
-     * export default c.define("/example.val.ts", schema, [
-     *   ".hero { color: red; }",
-     * ]);
-     */
-    render(input: FieldRender): CodeSchema<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/color.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 { ColorFormat } from "./colorFormat.js";
 import { RawString } from "./string.js";
@@ -29,8 +28,6 @@ export type ColorOptions = {
 };
 export type SerializedColorSchema = {
     type: "color";
-    /** 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?: ColorOptions;
@@ -47,9 +44,8 @@ export declare class ColorSchema<Src extends string | null> extends Schema<Src>
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(options?: ColorOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(options?: ColorOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -101,20 +97,6 @@ export declare class ColorSchema<Src extends string | null> extends Schema<Src>
     nullable(): ColorSchema<Src | null>;
     readonly(isReadonly?: boolean): ColorSchema<Src>;
     hidden(isHidden?: boolean): ColorSchema<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`.
-     *
-     * @example
-     * const schema = s.array(s.color().render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, [
-     *   "hsl(217.22 91.22% 59.8%)",
-     * ]);
-     */
-    render(input: FieldRender): ColorSchema<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/date.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 { RawString } from "./string.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
@@ -22,8 +21,6 @@ type DateOptions = {
 };
 export type SerializedDateSchema = {
     type: "date";
-    /** 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?: DateOptions;
@@ -40,9 +37,8 @@ export declare class DateSchema<Src extends string | null> extends Schema<Src> {
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(options?: DateOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(options?: DateOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -108,18 +104,6 @@ export declare class DateSchema<Src extends string | null> extends Schema<Src> {
     readonly(isReadonly?: boolean): DateSchema<Src>;
     hidden(isHidden?: boolean): DateSchema<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.date().render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, ["2025-06-01"]);
-     */
-    render(input: FieldRender): DateSchema<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/datetime.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 { RawString } from "./string.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
@@ -26,8 +25,6 @@ type DateTimeOptions = {
 };
 export type SerializedDateTimeSchema = {
     type: "dateTime";
-    /** 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?: DateTimeOptions;
@@ -44,9 +41,8 @@ export declare class DateTimeSchema<Src extends string | null> extends Schema<Sr
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(options?: DateTimeOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(options?: DateTimeOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -131,20 +127,6 @@ export declare class DateTimeSchema<Src extends string | null> extends Schema<Sr
     readonly(isReadonly?: boolean): DateTimeSchema<Src>;
     hidden(isHidden?: boolean): DateTimeSchema<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.datetime().render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, [
-     *   "2025-06-01T09:00:00.000Z",
-     * ]);
-     */
-    render(input: FieldRender): DateTimeSchema<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/discriminatedUnion.d.ts

@@ -1,6 +1,5 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult } from "./index.js";
 import { ItemPreviewInput, PreviewItem, ReifiedPreview, PreviewScope } from "../preview.js";
-import { FieldRender } from "../render.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourceObject } from "../source/index.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
@@ -8,8 +7,6 @@ import { SerializedObjectSchema } from "./object.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedDiscriminatedUnionSchema = {
     type: "discriminated-union";
-    /** 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;
     /** The name of the field every variant tags itself with. */
@@ -56,9 +53,8 @@ export declare class DiscriminatedUnionSchema<Key extends string, T extends Disc
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(key: Key, items: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(key: Key, items: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -127,24 +123,6 @@ export declare class DiscriminatedUnionSchema<Key extends string, T extends Disc
      * them — a structural error `executeValidate` already reports.
      */
     private matchedVariant;
-    /**
-     * 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: the row draws the tag selector and the matched
-     * // variant's fields.
-     * const hero = s.object({ type: s.literal("hero"), title: s.string() });
-     * const text = s.object({ type: s.literal("text"), body: s.string() });
-     * const block = s.discriminatedUnion("type", hero, text).render({ as: "inline" });
-     * export default c.define("/example.val.ts", s.array(block), [
-     *   { type: "hero", title: "Hello" },
-     * ]);
-     */
-    render(input: FieldRender): DiscriminatedUnionSchema<Key, T, 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/enum.d.ts

@@ -1,12 +1,9 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult } 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 SerializedEnumSchema = {
     type: "enum";
-    /** 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;
     /**
@@ -36,7 +33,6 @@ export declare class EnumSchema<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.
@@ -47,7 +43,7 @@ export declare class EnumSchema<Src extends string | null> extends Schema<Src> {
      * cannot be a record key at all. See `LocaleSchema`.
      */
     readonly __declaresRecordKeys: true;
-    constructor(values: readonly string[], opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(values: readonly string[], opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -94,20 +90,6 @@ export declare class EnumSchema<Src extends string | null> extends Schema<Src> {
     readonly(isReadonly?: boolean): EnumSchema<Src>;
     hidden(isHidden?: boolean): EnumSchema<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.enum("draft", "published").render({ as: "inline" }),
-     * );
-     * export default c.define("/example.val.ts", schema, ["draft"]);
-     */
-    render(input: FieldRender): EnumSchema<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/file.d.ts

@@ -5,15 +5,12 @@ 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 { FilesetEntryMetadata } from "./fileset.js";
 export type FileOptions = {
     accept?: string;
 };
 export type SerializedFileSchema = {
     type: "file";
-    /** 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?: FileOptions;
@@ -34,9 +31,8 @@ export declare class FileSchema<Src extends FileSource | null> extends Schema<Sr
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    private readonly renderInput;
     private readonly previewInput;
-    constructor(options?: FileOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, FilesetEntryMetadata>>, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(options?: FileOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, FilesetEntryMetadata>>, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -117,20 +113,6 @@ export declare class FileSchema<Src extends FileSource | null> extends Schema<Sr
     readonly(isReadonly?: boolean): FileSchema<Src>;
     hidden(isHidden?: boolean): FileSchema<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.file().render({ as: "inline" }));
-     * export default c.define("/example.val.ts", schema, [
-     *   { path: "/public/val/example.pdf", mimeType: "application/pdf" },
-     * ]);
-     */
-    render(input: FieldRender): FileSchema<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