@valbuild/core 0.138.2 → 0.139.1

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @valbuild/core
 
+## 0.139.1
+
+### Patch Changes
+
+- [#780](https://github.com/valbuild/val/pull/780) [`db13bed`](https://github.com/valbuild/val/commit/db13bed902f9f9147feb5be07ce47fe8b5b143f9) Thanks [@freekh](https://github.com/freekh)! - When a new version of your site with a changed schema is deployed while Val Studio is open, the Studio now asks you to reload before you keep editing, instead of carrying on with the old schema.
+
+## 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

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

@@ -85,6 +85,20 @@ export declare function computeSourcesSha(entries: readonly {
     path: string;
     source: unknown;
 }[]): string;
+/**
+ * The `schemaSha` fold on its own: path and serialized schema, in `val.modules`
+ * order.
+ *
+ * Separate for the same reason as {@link computeSourcesSha}: the Studio folds
+ * the schemas of the bundle it is running and compares the answer with the
+ * `schemaSha` on `/stat`, which is how it learns that a new schema has been
+ * deployed under it. One implementation, so that comparison is between two
+ * runs of the same code.
+ */
+export declare function computeSchemaSha(entries: readonly {
+    path: string;
+    serializedSchema: unknown;
+}[]): string;
 export declare function computeValModuleShas(config: ValModules["config"], entries: readonly ValModuleShaEntry[], moduleErrors: readonly ExtractedModuleError[]): ValModuleShas;
 /**
  * Extracts schemas and sources from a ValModules registry and computes the

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

@@ -1,6 +1,6 @@
 export { initVal, type ConfigDirectory } from "./initVal.js";
 export { modules, type ValModules } from "./modules.js";
-export { extractValModules, computeValModuleShas, computeSourcesSha, type ExtractedValModules, type ValModuleShaEntry, type ValModuleShas, type ExtractedModuleError, } from "./extractValModules.js";
+export { extractValModules, computeValModuleShas, computeSourcesSha, computeSchemaSha, type ExtractedValModules, type ValModuleShaEntry, type ValModuleShas, type ExtractedModuleError, } from "./extractValModules.js";
 export type { InitVal, ValConfig, ValConstructor, ContentConstructor, } from "./initVal.js";
 export { Schema, type SerializedSchema, type SelectorOfSchema } from "./schema/index.js";
 export { hasRemoteFileSchema, hasMediaSchema, } from "./schema/hasRemoteFileSchema.js";

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