alinea 2.0.0-preview.9 → 2.0.0-rc2

package/dist/core/Root.js

@@ -3,11 +3,12 @@ import {
   boolean,
   object,
   string
-} from "../chunks/chunk-UPY2RUZF.js";
+} from "../chunks/chunk-TWBREZWC.js";
 import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Root.ts
 import { getRoot, hasRoot, internalRoot } from "./Internal.js";
+import { Overview } from "./Overview.js";
 import { Schema } from "./Schema.js";
 import { Type } from "./Type.js";
 var Root;
@@ -24,10 +25,10 @@ var Root;
     return getRoot(root2);
   }
   Root2.data = data;
-  function mediaI18n(root2) {
-    return root2._media?.i18n;
+  function fieldI18n(root2) {
+    return root2.fieldI18n;
   }
-  Root2.mediaI18n = mediaI18n;
+  Root2.fieldI18n = fieldI18n;
   function preview(root2) {
     return getRoot(root2).preview;
   }
@@ -36,6 +37,10 @@ var Root;
     return getRoot(root2).i18n?.locales[0];
   }
   Root2.defaultLocale = defaultLocale;
+  function childrenOrder(root2) {
+    return root2.overview?.sort ?? root2.orderChildrenBy;
+  }
+  Root2.childrenOrder = childrenOrder;
   function isRoot(value) {
     return Boolean(value && hasRoot(value));
   }
@@ -81,15 +86,20 @@ var Root;
   }
   Root2.validate = validate;
   function referencedViews(root2) {
-    const { view } = data(root2);
-    return typeof view === "string" ? [view] : [];
+    const { view, overview } = data(root2);
+    return [
+      ...typeof view === "string" ? [view] : [],
+      ...Overview.referencedViews(overview)
+    ];
   }
   Root2.referencedViews = referencedViews;
 })(Root || (Root = {}));
 function root(label, config = {}) {
+  const { i18n } = config;
+  const data = i18n?.translate === "fields" ? { ...config, label, i18n: void 0, fieldI18n: i18n } : { ...config, label };
   const instance = {
     ...config.children,
-    [internalRoot]: { ...config, label }
+    [internalRoot]: data
   };
   return instance;
 }

package/dist/core/Schema.js

@@ -1,7 +1,7 @@
 import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Schema.ts
-import { getType } from "./Internal.js";
+import { getReplaced, getType } from "./Internal.js";
 import { Type } from "./Type.js";
 import { isValidIdentifier } from "./util/Identifiers.js";
 import { entries, values } from "./util/Objects.js";
@@ -47,7 +47,12 @@ var Schema;
   }
   Schema2.validate = validate;
   function typeNames(schema2) {
-    return new Map(entries(schema2).map(([key, type]) => [type, key]));
+    const names = new Map(entries(schema2).map(([key, type]) => [type, key]));
+    for (const [key, type] of entries(schema2)) {
+      const replaced = getReplaced(type);
+      if (replaced && !names.has(replaced)) names.set(replaced, key);
+    }
+    return names;
   }
   Schema2.typeNames = typeNames;
   function contained(schema2, contains) {

package/dist/core/Scope.d.ts

@@ -21,11 +21,25 @@ export declare class Scope {
     constructor(config: Config);
     workspaceOf(root: HasRoot): HasWorkspace;
     keyOf(entity: Entity): string;
+    /** The type of a field and its path in there, such as `seo.title` */
+    fieldOf(field: Field): [type: string, path: string] | undefined;
     locationOf(entity: Entity): string[] | undefined;
     nameOf(entity: Entity): string | undefined;
+    /**
+     * Where a field stores its value in the entry data, eg. `['seo', 'title']`
+     * for a field of an object field
+     */
+    dataPathOf(field: Field): Array<string> | undefined;
     /** Configured spellings of a locale, matched case-insensitively. */
     locales(locale: string): Array<string>;
     stringify(input: any): string;
     parse<Result>(input: string): Result;
+    /**
+     * Recognize the entities of a previous build of this config by their key.
+     * The dev server replaces the config of its database when the schema
+     * changes, while the handler of the previous config still answers queries
+     * that name its own types and fields.
+     */
+    adopt(previous: Scope): void;
 }
 export declare function getScope(config: Config): Scope;

package/dist/core/Scope.js

@@ -4,10 +4,13 @@ import "../chunks/chunk-CQ52GEHY.js";
 import { Expr } from "./Expr.js";
 import {
   getExpr,
+  getReplaced,
   getRoot,
-  hasExpr
+  getType,
+  hasExpr,
+  hasType
 } from "./Internal.js";
-import { entries } from "./util/Objects.js";
+import { entries, values } from "./util/Objects.js";
 var scopes = /* @__PURE__ */ new WeakMap();
 var ENTITY_KEY = "@alinea.Entity";
 var EXPR_KEY = "@alinea.Expr";
@@ -38,6 +41,10 @@ var Scope = class {
   #keys = /* @__PURE__ */ new Map();
   #paths = /* @__PURE__ */ new Map();
   #locales = /* @__PURE__ */ new Map();
+  #nested = /* @__PURE__ */ new Map();
+  #nestedKeys = /* @__PURE__ */ new Map();
+  #shared = /* @__PURE__ */ new Set();
+  #adopted = /* @__PURE__ */ new WeakMap();
   constructor(config) {
     for (const [workspaceName, workspace] of entries(config.workspaces)) {
       this.#insert(workspace, ScopeKey.workspace(workspaceName));
@@ -60,31 +67,84 @@ var Scope = class {
         this.#insert(field, ScopeKey.field(typeName, fieldName));
       }
     }
+    for (const [typeName, type] of entries(config.schema))
+      for (const [fieldName, field] of entries(type))
+        this.#insertNested(field, ["Field", typeName, fieldName]);
+    for (const type of values(config.schema)) {
+      const replaced = getReplaced(type);
+      if (replaced) this.#adopted.set(replaced, type);
+    }
+    for (const [field, path] of this.#nested)
+      this.#nestedKeys.set(path.join("."), field);
+  }
+  // Fields of object fields get a key, eg. Field.Type.object.field, so roles
+  // can target them and queries can select them. They are kept apart from the
+  // other entities, which have a name. A field instance used in more than one
+  // place has no single key, so it can't be targeted.
+  #insertNested(field, path) {
+    if (!hasType(field)) return;
+    for (const [name, inner] of entries(getType(field).allFields)) {
+      const location = [...path, name];
+      if (this.#nested.has(inner)) {
+        this.#nested.delete(inner);
+        this.#shared.add(inner);
+      } else if (!this.#paths.has(inner) && !this.#shared.has(inner)) {
+        this.#nested.set(inner, location);
+      }
+      this.#insertNested(inner, location);
+    }
   }
   workspaceOf(root) {
-    const path = this.#paths.get(root);
+    const path = this.#paths.get(this.#current(root));
     if (!path) throw new Error(`Root not found in scope: ${root}`);
     return this.#keys.get(path[0]);
   }
   keyOf(entity) {
-    const path = this.#paths.get(entity);
+    entity = this.#current(entity);
+    if (this.#shared.has(entity))
+      throw new Error(
+        "Field is used in more than one place, target the field containing it"
+      );
+    const path = this.#paths.get(entity) ?? this.#nested.get(entity);
     if (!path) throw new Error(`Entity not found in scope: ${entity}`);
     return path.join(".");
   }
+  /** The type of a field and its path in there, such as `seo.title` */
+  fieldOf(field) {
+    field = this.#current(field);
+    const path = this.#paths.get(field) ?? this.#nested.get(field);
+    if (path?.[0] !== "Field") return;
+    return [path[1], path.slice(2).join(".")];
+  }
   locationOf(entity) {
-    return this.#paths.get(entity)?.slice(1);
+    return this.#paths.get(this.#current(entity))?.slice(1);
   }
   nameOf(entity) {
-    return this.#paths.get(entity)?.at(-1);
+    return this.#paths.get(this.#current(entity))?.at(-1);
+  }
+  /**
+   * Where a field stores its value in the entry data, eg. `['seo', 'title']`
+   * for a field of an object field
+   */
+  dataPathOf(field) {
+    field = this.#current(field);
+    if (this.#shared.has(field))
+      throw new Error(
+        "Field is used in more than one place, select the field containing it"
+      );
+    const path = this.#paths.get(field) ?? this.#nested.get(field);
+    if (path?.[0] !== "Field") return;
+    return path.slice(2);
   }
   /** Configured spellings of a locale, matched case-insensitively. */
   locales(locale) {
     return this.#locales.get(locale.toLowerCase()) ?? [locale];
   }
   stringify(input) {
-    const result = JSON.stringify(input, (key, value) => {
-      if (this.#paths.has(value))
-        return { [ENTITY_KEY]: this.#paths.get(value)?.join(".") };
+    const result = JSON.stringify(input, (key, raw) => {
+      const value = this.#current(raw);
+      const path = this.#paths.get(value) ?? this.#nested.get(value);
+      if (path) return { [ENTITY_KEY]: path.join(".") };
       if (value && typeof value === "object" && hasExpr(value))
         return { [EXPR_KEY]: getExpr(value) };
       return value;
@@ -97,7 +157,8 @@ var Scope = class {
         const props = Object.keys(value);
         if (props.length === 1) {
           const [key2] = props;
-          if (key2 === ENTITY_KEY) return this.#keys.get(value[key2]);
+          if (key2 === ENTITY_KEY)
+            return this.#keys.get(value[key2]) ?? this.#nestedKeys.get(value[key2]);
           if (key2 === EXPR_KEY) return new Expr(value[key2]);
         }
       }
@@ -105,6 +166,23 @@ var Scope = class {
     });
     return result;
   }
+  /**
+   * Recognize the entities of a previous build of this config by their key.
+   * The dev server replaces the config of its database when the schema
+   * changes, while the handler of the previous config still answers queries
+   * that name its own types and fields.
+   */
+  adopt(previous) {
+    for (const [key, entity] of [...previous.#keys, ...previous.#nestedKeys]) {
+      const current = this.#keys.get(key) ?? this.#nestedKeys.get(key);
+      if (current && current !== entity) this.#adopted.set(entity, current);
+    }
+  }
+  /** The entity of this config for an entity of an adopted build */
+  #current(entity) {
+    if (!entity || typeof entity !== "object") return entity;
+    return this.#adopted.get(entity) ?? entity;
+  }
   #insert(entity, key) {
     const exists = this.#paths.get(entity);
     const segments = key.split(".");

package/dist/core/TextDoc.d.ts

@@ -1,4 +1,12 @@
-export type TextDoc<T = {}> = Array<Node>;
+declare const blocks: unique symbol;
+/**
+ * Rich text content. `Blocks` is the schema of the blocks that can appear in
+ * the document, so rich text views such as `<RichText />` can infer which
+ * block components they accept. It only exists at the type level.
+ */
+export type TextDoc<Blocks = {}> = Array<Node> & {
+    [blocks]?(schema: Blocks): void;
+};
 export type Node = TextNode | ElementNode | BlockNode;
 export declare namespace Node {
     const type = "_type";
@@ -62,7 +70,12 @@ export interface ImageNode extends ElementNode {
 export interface BlockNode {
     _id: string;
     _type: string;
+    /** A label editors give the block, its anchor follows it by default */
+    _label?: string;
+    /** Lets links point to the block, unique within the entry */
+    _anchor?: string;
 }
 export declare namespace BlockNode {
     const id = "_id";
 }
+export {};

package/dist/core/Type.d.ts

@@ -1,17 +1,19 @@
+import type { EntryActionProps } from './DashboardEntry.js';
 import type { ComponentType } from 'react';
 import type { Config } from './Config.js';
 import type { EntryStatus } from './Entry.js';
 import type { Expr } from './Expr.js';
-import { Field, type EntryAnchorTarget, type FieldAnchorContext, type FieldLocalizeContext, type FieldBeforeSaveContext } from './Field.js';
+import { Field, type EntryAnchorTarget, type FieldAnchorContext, type FieldInitialContext, type FieldLocalizeContext, type FieldBeforeSaveContext } from './Field.js';
 import { type HasType } from './Internal.js';
 import type { Label } from './Label.js';
 import type { OrderBy } from './OrderBy.js';
+import { type OverviewOptions } from './Overview.js';
 import type { Preview } from './Preview.js';
 import { Section } from './Section.js';
 import type { View } from './View.js';
 import type { EntryReferenceTarget } from './db/EntryReference.js';
 import type { SummaryProps } from './media/Summary.js';
-import type { Expand } from './util/Types.js';
+import type { Expand, UnionToIntersection } from './util/Types.js';
 export interface EntryUrlInput {
     config: Config;
     data: Record<string, unknown>;
@@ -35,18 +37,25 @@ export declare namespace Type {
     function label(type: Type): Label;
     function contains(type: Type): Array<string | Type>;
     function insertOrder(type: Type): 'first' | 'last' | 'free';
+    function overview(type: Type): OverviewOptions | undefined;
+    /** The default order of children: `overview.sort`, or `orderChildrenBy` */
+    function childrenOrder(type: Type): OrderBy | Array<OrderBy> | undefined;
     function isHidden(type: Type): boolean;
+    function isCollapsed(type: Type): boolean;
+    function expands(type: Type): boolean;
     function searchableText(type: Type, value: any): string;
-    function anchors(type: Type, value: Record<string, unknown>, path?: Array<string>): Array<EntryAnchorTarget>;
-    function references(type: Type, value: Record<string, unknown>, path?: Array<string>): Array<EntryReferenceTarget>;
+    function anchors(type: Type, value: Record<string, unknown>, path?: Array<string>, labels?: Array<string>): Array<EntryAnchorTarget>;
+    function references(type: Type, value: Record<string, unknown>, path?: Array<string>, labels?: Array<string>): Array<EntryReferenceTarget>;
     function fields(type: Type): Record<string, Field>;
     function sections(type: Type): Section[];
+    /** The tabs of the type, see `TypeConfig.tabs` */
+    function tabs(type: Type): Record<string, Type> | undefined;
     function isContainer(type: Type): boolean;
     function field(type: Type, name: string): Field | undefined;
     function isType(type: any): type is Type;
     function sharedData(type: Type, entryData: Record<string, unknown>): Record<string, unknown> | undefined;
     function initialValue(type: Type): Record<string, unknown>;
-    function withInitialValue(type: Type, value: Record<string, unknown>): Record<string, unknown>;
+    function withInitialValue(type: Type, value: Record<string, unknown>, context?: FieldInitialContext): Record<string, unknown>;
     function normalizeAnchors(type: Type, value: Record<string, unknown>, context?: FieldAnchorContext): Record<string, unknown>;
     function localizeLinks(type: Type, value: Record<string, unknown>, context: FieldLocalizeContext): Record<string, unknown>;
     function beforeSave(type: Type, value: Record<string, unknown>, context: Omit<FieldBeforeSaveContext<unknown>, 'value'>): Record<string, unknown>;
@@ -61,35 +70,86 @@ export interface FieldsDefinition {
 }
 export interface TypeConfig<Definition> {
     fields: Definition;
+    /**
+     * Tabs next to the fields, eg.
+     * `{analytics: Field.tab('Analytics', {view: '@/views/Analytics'})}`.
+     * Entries show them in the entry editor, list rows and rich text blocks in
+     * their settings sheet. The fields of a tab are stored and queried like the
+     * other fields.
+     */
+    tabs?: Record<string, Type>;
     /** Accepts entries of these types as children */
     contains?: Array<string | Type>;
-    /** Order children entries in the sidebar content tree */
+    /** How the dashboard lists the children of entries of this type */
+    overview?: OverviewOptions;
+    /**
+     * Components rendered in the header of the entry editor, next to the
+     * publish button, eg. a button that exports or sends the entry. They can
+     * read the fields of the entry with the hooks of `alinea/cms`.
+     */
+    actions?: Array<View<EntryActionProps>>;
+    /**
+     * Order children entries in the sidebar content tree
+     * @deprecated Use `overview.sort`
+     */
     orderChildrenBy?: OrderBy | Array<OrderBy>;
     /** Entries do not show up in the sidebar content tree */
     hidden?: true;
+    /**
+     * How entries show their children in the sidebar content tree. By default
+     * they expand when the entry is opened. With `true` they stay collapsed
+     * until the arrow is clicked, useful for entries with many children that
+     * are browsed in their overview instead. With `false` they are expanded
+     * from the start.
+     */
+    collapsed?: boolean;
     /** An icon (React component) to represent this type in the dashboard */
     icon?: ComponentType;
-    /** A React component used to view an entry of this type in the dashboard */
+    /**
+     * A React component, or a path to one, that replaces the form of entries of
+     * this type below the entry header. It edits the fields of the entry with
+     * the hooks of `alinea/cms`.
+     */
     view?: View<{
         type: Type;
     }>;
     /** The default dashboard view for entries of this type */
     defaultView?: EntryDefaultView;
-    /** A React component used to view a row of this type in the dashboard */
+    /**
+     * A React component used to view a row of this type in the dashboard
+     * @deprecated Not used by the dashboard, configure the columns of the
+     * parent's overview with `overview.columns`
+     */
     summaryRow?: View<SummaryProps>;
-    /** A React component used to view a thumbnail of this type in the dashboard */
+    /**
+     * A React component used to view a thumbnail of this type in the dashboard
+     * @deprecated Not used by the dashboard, configure the card image of the
+     * parent's overview with `overview.thumbnail`
+     */
     summaryThumb?: View<SummaryProps>;
     /** The position where new children will be inserted */
     insertOrder?: 'first' | 'last' | 'free';
     entryUrl?: (meta: EntryUrlMeta) => string;
     preview?: Preview;
 }
+/** Types that only hold children can leave out their fields */
+export interface ContainerTypeConfig<Definition> extends Omit<TypeConfig<Definition>, 'fields' | 'contains'> {
+    fields?: Definition;
+    /** Accepts entries of these types as children */
+    contains: Array<string | Type>;
+}
 export interface TypeInternal extends TypeConfig<FieldsDefinition> {
     label: string;
     allFields: Record<string, Field>;
     sections: Array<Section>;
 }
+/** The fields of the tabs of a type, see `TypeConfig.tabs` */
+export type TabFields<Tabs> = [keyof Tabs] extends [never] ? {} : UnionToIntersection<{
+    [K in keyof Tabs]: Tabs[K] extends Type<infer F> ? F : never;
+}[keyof Tabs]>;
 /** Create a new type */
-export declare function type<Fields extends FieldsDefinition>(label: string, config: TypeConfig<Fields>): Type<Fields>;
-export declare function createType<Fields extends FieldsDefinition>(label: string, config: TypeConfig<Fields>): Type<Fields>;
+export declare function type<Fields extends FieldsDefinition = {}, Tabs extends Record<string, Type> = {}>(label: string, config: (TypeConfig<Fields> | ContainerTypeConfig<Fields>) & {
+    tabs?: Tabs;
+}): Type<Fields & TabFields<Tabs>>;
+export declare function createType<Fields extends FieldsDefinition = {}>(label: string, { fields: definition, ...config }: TypeConfig<Fields> | ContainerTypeConfig<Fields>): Type<Fields>;
 export {};

package/dist/core/Type.js

@@ -1,7 +1,9 @@
 import {
+  instance,
   object,
-  string
-} from "../chunks/chunk-UPY2RUZF.js";
+  string,
+  union
+} from "../chunks/chunk-TWBREZWC.js";
 import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Type.ts
@@ -9,6 +11,7 @@ import {
   Field
 } from "./Field.js";
 import { getType, hasType, internalType } from "./Internal.js";
+import { Overview } from "./Overview.js";
 import { Section, section } from "./Section.js";
 import { isValidIdentifier } from "./util/Identifiers.js";
 import { entries, fromEntries, isRecord, keys, values } from "./util/Objects.js";
@@ -26,10 +29,27 @@ var Type;
     return getType(type2).insertOrder ?? "free";
   }
   Type2.insertOrder = insertOrder;
+  function overview(type2) {
+    return getType(type2).overview;
+  }
+  Type2.overview = overview;
+  function childrenOrder(type2) {
+    const { overview: overview2, orderChildrenBy } = getType(type2);
+    return overview2?.sort ?? orderChildrenBy;
+  }
+  Type2.childrenOrder = childrenOrder;
   function isHidden(type2) {
     return Boolean(getType(type2).hidden);
   }
   Type2.isHidden = isHidden;
+  function isCollapsed(type2) {
+    return getType(type2).collapsed === true;
+  }
+  Type2.isCollapsed = isCollapsed;
+  function expands(type2) {
+    return getType(type2).collapsed === false;
+  }
+  Type2.expands = expands;
   function searchableText(type2, value) {
     const self = value || {};
     let res = "";
@@ -39,22 +59,26 @@ var Type;
     return res.trim();
   }
   Type2.searchableText = searchableText;
-  function anchors(type2, value, path = []) {
+  function anchors(type2, value, path = [], labels = []) {
     const self = value || {};
     return entries(fields(type2)).flatMap(([key, field2]) => {
+      const label2 = Field.label(field2);
       return Field.anchors(field2, self[key], {
         path: [...path, key],
-        label: Field.label(field2)
+        label: label2,
+        labels: [...labels, label2]
       });
     });
   }
   Type2.anchors = anchors;
-  function references(type2, value, path = []) {
+  function references(type2, value, path = [], labels = []) {
     const self = value || {};
     return entries(fields(type2)).flatMap(([key, field2]) => {
+      const label2 = Field.label(field2);
       return Field.references(field2, self[key], {
         path: [...path, key],
-        label: Field.label(field2)
+        label: label2,
+        labels: [...labels, label2]
       });
     });
   }
@@ -67,6 +91,11 @@ var Type;
     return getType(type2).sections;
   }
   Type2.sections = sections;
+  function tabs(type2) {
+    const { tabs: tabs2 } = getType(type2);
+    return tabs2 && keys(tabs2).length > 0 ? tabs2 : void 0;
+  }
+  Type2.tabs = tabs;
   function isContainer(type2) {
     return Boolean(getType(type2).contains);
   }
@@ -96,12 +125,12 @@ var Type;
     return res;
   }
   Type2.initialValue = initialValue;
-  function withInitialValue(type2, value) {
+  function withInitialValue(type2, value, context) {
     const merged = mergeInitialValue(value, initialValue(type2));
     let next = merged;
     for (const [key, field2] of entries(fields(type2))) {
       const before = merged[key];
-      const after = Field.withInitialValue(field2, before);
+      const after = Field.withInitialValue(field2, before, context);
       if (after === before) continue;
       if (next === merged) next = { ...merged };
       next[key] = after;
@@ -164,7 +193,7 @@ var Type;
   Type2.defaultView = defaultView;
   const TypeOptions = object({
     defaultView: string.optional,
-    view: string.optional,
+    view: union(string, instance(Function)).optional,
     summaryRow: string.optional,
     summaryThumb: string.optional
   });
@@ -181,12 +210,16 @@ var Type;
   }
   Type2.validate = validate;
   function referencedViews(type2) {
-    const { view, summaryRow, summaryThumb } = getType(type2);
+    const { view, summaryRow, summaryThumb, overview: overview2, actions } = getType(type2);
     return [
       view,
       summaryRow,
       summaryThumb,
-      ...viewsOfDefinition(getType(type2).fields)
+      ...actions ?? [],
+      ...Overview.referencedViews(overview2),
+      ...viewsOfDefinition(getType(type2).fields),
+      // Tabs are left out of the fields, their views are bundled too
+      ...values(getType(type2).tabs ?? {}).flatMap(referencedViews)
     ].filter((v) => typeof v === "string");
   }
   Type2.referencedViews = referencedViews;
@@ -219,11 +252,14 @@ function viewsOfDefinition(definition) {
   });
 }
 function type(label, config) {
-  const instance = createType(label, config);
-  Type.validate(instance);
-  return instance;
+  const instance2 = createType(label, config);
+  Type.validate(instance2);
+  return instance2;
 }
-function createType(label, config) {
+function createType(label, {
+  fields: definition = {},
+  ...config
+}) {
   const sections = [];
   let current = {};
   const addCurrent = () => {
@@ -231,10 +267,10 @@ function createType(label, config) {
     current = {};
   };
   const fields = [];
-  if (typeof config.fields !== "object") {
+  if (typeof definition !== "object") {
     throw new Error("Type fields must be an object");
   }
-  for (const [key, value] of entries(config.fields)) {
+  for (const [key, value] of entries(definition)) {
     if (Field.isField(value)) {
       current[key] = value;
       fields.push([key, value]);
@@ -247,11 +283,25 @@ function createType(label, config) {
     }
   }
   addCurrent();
+  const taken = new Set(fields.map(([key]) => key));
+  const tabFields = values(config.tabs ?? {}).flatMap(
+    (tab) => entries(Type.fields(tab))
+  );
+  for (const [key, value] of tabFields) {
+    const own = Section.isSection(value) ? entries(Section.fields(value)) : Field.isField(value) ? [[key, value]] : [];
+    for (const [name, field] of own) {
+      if (taken.has(name))
+        throw new Error(`Field "${name}" is defined twice in Type "${label}"`);
+      taken.add(name);
+      fields.push([name, field]);
+    }
+  }
   const allFields = fromEntries(fields);
   return {
     ...allFields,
     [internalType]: {
       ...config,
+      fields: definition,
       allFields,
       sections,
       label