rimecms 0.29.0 → 0.30.1

package/dist/core/fields/builders/field-builder.js

@@ -3,10 +3,14 @@ export class FieldBuilder {
     _metaUrl;
     constructor(type) {
         this.field = {
+            name: '',
             type,
             live: true
         };
     }
+    get name() {
+        return this.field.name;
+    }
     className(str) {
         this.field.className = str;
         return this;
@@ -25,8 +29,35 @@ export class FieldBuilder {
     get type() {
         return this.field.type;
     }
-    get raw() {
-        return this.field;
+    /**
+     * Raw field data, plus the couple of properties that a bare `this.field`
+     * read can't give you: `localized`/`root` default to `false` here since
+     * only FormFieldBuilder fields ever set them — container fields like Tabs
+     * answer `false` rather than making every caller check
+     * `instanceof FormFieldBuilder` first just to ask this one question.
+     * Everything else on `T` (Tabs' `tabs`, Blocks' `blocks`, ...) comes
+     * through unchanged via the spread — no per-subclass override needed.
+     */
+    get get() {
+        return { ...this.field, localized: false, root: false };
+    }
+    /** Behavior the builder runs on your behalf (invoking a stored function) —
+     *  see `.get` for plain data reads. Fields without an access concept
+     *  (Tabs) default every check to allowed, matching how the field-less case
+     *  already behaved. Params are unused here but must match FormFieldBuilder's
+     *  override signature — TS checks generic-constraint satisfaction
+     *  (`T extends FieldBuilder<any>`) strictly, not with the bivariant
+     *  leniency normal overrides get, so a param-less base signature breaks
+     *  assignability everywhere. */
+    get run() {
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            canRead: (..._args) => true,
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            canCreate: (..._args) => true,
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            canUpdate: (..._args) => true
+        };
     }
     get component() {
         return null;

package/dist/core/fields/builders/form-field-builder.d.ts

@@ -1,16 +1,54 @@
 import type { FieldPanelTableConfig } from '../../../types.js';
 import type { Dic } from '../../../util/types.js';
-import type { FieldAccess, FieldHook, FieldHookClient, FieldHookShared, FieldValidationFunc, FieldWidth, FormField } from '../../../fields/types.js';
-import { FieldBuilder } from './field-builder.js';
-type GenerateSchemaFn = (args: {
-    camel: string;
-    snake: string;
-    suffix: string;
-}) => string;
-export declare class FormFieldBuilder<T extends FormField> extends FieldBuilder<T> {
-    _generateSchema: null | GenerateSchemaFn;
+import type { RequestEvent } from '@sveltejs/kit';
+import type { FieldAccess, FieldHook, FieldHookClient, FieldHookContext, FieldHookShared, FieldValidationFunc, FieldWidth, FormField } from '../../../fields/types.js';
+import { FieldBuilder, type FieldRun } from './field-builder.js';
+/** Adapter-agnostic storage primitive — column syntax only, not default-value semantics. */
+export type DataType = 'text' | 'boolean' | 'number' | 'timestamp' | 'json';
+/** Method-syntax, same reasoning as `FieldRun` — keeps `run`'s params
+ *  bivariant across concrete field types so e.g. `SlugFieldBuilder` still
+ *  satisfies a prop typed `FormFieldBuilder<FormField>`. */
+export type FormFieldRun<T extends FormField> = FieldRun & {
+    isEmpty(value: unknown): boolean;
+    validate(value: unknown, context: Parameters<FieldValidationFunc<T>>[1]): true | string;
+    condition(doc: Dic, siblings: Dic): boolean;
+    onChange(value: unknown, context: Parameters<FieldHookClient>[1]): void;
+    beforeRead(value: unknown, context: Omit<FieldHookContext<T>, 'config'>): Promise<any>;
+    beforeSave(value: unknown, context: FieldHookContext<T>): Promise<any>;
+    beforeValidate(value: unknown, context: Parameters<FieldHookShared>[1]): Promise<any>;
+    /** Resolves `field.defaultValue` — calling it if it's a `DefaultValueFn`,
+     *  returning it as-is otherwise. Every field type stores `defaultValue` as
+     *  plain data (never a fluent-setter name collision on `.field` itself),
+     *  but several concrete builders (Select, Link, Slug, Relation) *do* expose
+     *  a `.defaultValue(...)` fluent setter — bare `config.defaultValue` on
+     *  those would silently return that setter, not the stored value. */
+    defaultValue(context?: {
+        event?: RequestEvent;
+    }): unknown;
+};
+export type ReferentialAction = 'cascade' | 'set null' | 'restrict' | 'no action';
+export type FieldReferenceOptions = {
+    onDelete?: ReferentialAction;
+    onUpdate?: ReferentialAction;
+    /** Referenced table is this field's own table (self-FK); adapters need this
+     *  to emit a `(): any =>` accessor and avoid a TS circular-declaration error. */
+    selfReferencing?: boolean;
+};
+export type FieldReference = FieldReferenceOptions & {
+    table: string;
+};
+export declare class FormFieldBuilder<T extends FormField = FormField> extends FieldBuilder<T> {
+    /** Every concrete leaf field builder is expected to implement a
+     *  `get dataType(): DataType` accessor (see e.g. `$lib/fields/text/index.ts`).
+     *  Not declared here — TS doesn't allow `declare` on accessors in this
+     *  project's config, and a plain base field would conflict with subclasses
+     *  that need a computed getter (e.g. `select`, whose dataType depends on
+     *  `many`). Container builders (Group/Tabs/Blocks/Tree) never get asked,
+     *  since the adapter's tree-walker special-cases them before reaching the
+     *  generic column-rendering branch; `column.server.ts` reads `.dataType`
+     *  via a narrow cast for the same reason it already casts `unique`. */
+    _references: FieldReference | null;
     constructor(name: string, type: string);
-    get name(): string;
     label(label: string): this;
     hidden(): this;
     localized(): this;
@@ -19,17 +57,38 @@ export declare class FormFieldBuilder<T extends FormField> extends FieldBuilder<
     table(params?: FieldPanelTableConfig | number): this;
     width(value: FieldWidth): this;
     required(bool?: boolean): this;
+    /**
+     * Force the field to be on the root table — usefull for fields that
+     * should not be versioned (ex: _parent for nested structures should
+     * always be on the root table to prevent different versions from having
+     * different parents).
+     */
+    _root(): this;
+    /** `label`/`localized`/`root`/`required` are the only properties that need
+     *  anything beyond a plain `this.field` read (a fallback default, or a
+     *  boolean coercion) — everything else a concrete field type adds
+     *  (Group's `fields`, Relation's `relationTo`, Select's `options`, ...)
+     *  comes through unchanged via the spread, no per-subclass override needed. */
+    get get(): T & {
+        localized: boolean;
+        root: boolean;
+        label: string;
+        required: boolean;
+    };
     access(access: {
         create?: FieldAccess;
         read?: FieldAccess;
         update?: FieldAccess;
     }): this;
     onChange(hook: FieldHookClient): this;
+    /** Behavior the builder runs on your behalf — invoking a stored function or
+     *  hook list, not a data read (see `.get` for that). */
+    get run(): FormFieldRun<T>;
     hint(hint: string): this;
     clone(): typeof this;
-    $generateSchema(fn: GenerateSchemaFn): this;
+    /** Server-side schema concern, same family as $beforeRead/$beforeSave. */
+    $references(table: string, options?: FieldReferenceOptions): this;
     $beforeRead(hook: FieldHook<T>): this;
     $beforeSave(hook: FieldHook<T>): this;
     beforeValidate(hook: FieldHookShared): this;
 }
-export {};

package/dist/core/fields/builders/form-field-builder.js

@@ -1,7 +1,17 @@
+import { capitalize } from '../../../util/string.js';
 import cloneDeep from 'clone-deep';
 import { FieldBuilder } from './field-builder.js';
 export class FormFieldBuilder extends FieldBuilder {
-    _generateSchema = null;
+    /** Every concrete leaf field builder is expected to implement a
+     *  `get dataType(): DataType` accessor (see e.g. `$lib/fields/text/index.ts`).
+     *  Not declared here — TS doesn't allow `declare` on accessors in this
+     *  project's config, and a plain base field would conflict with subclasses
+     *  that need a computed getter (e.g. `select`, whose dataType depends on
+     *  `many`). Container builders (Group/Tabs/Blocks/Tree) never get asked,
+     *  since the adapter's tree-walker special-cases them before reaching the
+     *  generic column-rendering branch; `column.server.ts` reads `.dataType`
+     *  via a narrow cast for the same reason it already casts `unique`. */
+    _references = null;
     constructor(name, type) {
         super(type);
         this.field.name = name;
@@ -15,9 +25,6 @@ export class FormFieldBuilder extends FieldBuilder {
         };
         return this;
     }
-    get name() {
-        return this.field.name;
-    }
     label(label) {
         this.field.label = label;
         return this;
@@ -58,6 +65,30 @@ export class FormFieldBuilder extends FieldBuilder {
         this.field.required = typeof bool === 'undefined' ? true : bool;
         return this;
     }
+    /**
+     * Force the field to be on the root table — usefull for fields that
+     * should not be versioned (ex: _parent for nested structures should
+     * always be on the root table to prevent different versions from having
+     * different parents).
+     */
+    _root() {
+        this.field._root = true;
+        return this;
+    }
+    /** `label`/`localized`/`root`/`required` are the only properties that need
+     *  anything beyond a plain `this.field` read (a fallback default, or a
+     *  boolean coercion) — everything else a concrete field type adds
+     *  (Group's `fields`, Relation's `relationTo`, Select's `options`, ...)
+     *  comes through unchanged via the spread, no per-subclass override needed. */
+    get get() {
+        return {
+            ...this.field,
+            localized: !!this.field.localized,
+            root: !!this.field._root,
+            label: this.field.label || capitalize(this.field.name),
+            required: !!this.field.required
+        };
+    }
     access(access) {
         this.field.access = { ...this.field.access, ...access };
         return this;
@@ -67,6 +98,64 @@ export class FormFieldBuilder extends FieldBuilder {
         this.field.hooks.onChange.push(hook);
         return this;
     }
+    /** Behavior the builder runs on your behalf — invoking a stored function or
+     *  hook list, not a data read (see `.get` for that). */
+    get run() {
+        return {
+            isEmpty: (value) => this.field.isEmpty(value),
+            validate: (value, context) => {
+                if (this.field.validate) {
+                    return this.field.validate(value, { ...context, config: this.field });
+                }
+                return true;
+            },
+            condition: (doc, siblings) => {
+                if (this.field.condition) {
+                    try {
+                        return this.field.condition(doc, siblings);
+                    }
+                    catch (err) {
+                        console.error(err.message);
+                        return false;
+                    }
+                }
+                return true;
+            },
+            canRead: (...args) => !!this.field.access?.read?.(...args),
+            canCreate: (...args) => !!this.field.access?.create?.(...args),
+            canUpdate: (...args) => !!this.field.access?.update?.(...args),
+            onChange: (value, context) => {
+                for (const hook of this.field.hooks?.onChange ?? []) {
+                    hook(value, context);
+                }
+            },
+            beforeRead: async (value, context) => {
+                let result = value;
+                for (const hook of this.field.hooks?.beforeRead ?? []) {
+                    result = await hook(result, { ...context, config: this.field });
+                }
+                return result;
+            },
+            beforeSave: async (value, context) => {
+                let result = value;
+                for (const hook of this.field.hooks?.beforeSave ?? []) {
+                    result = await hook(result, { ...context, config: this.field });
+                }
+                return result;
+            },
+            beforeValidate: async (value, context) => {
+                let result = value;
+                for (const hook of this.field.hooks?.beforeValidate ?? []) {
+                    result = await hook(result, { ...context, config: this.field });
+                }
+                return result;
+            },
+            defaultValue: (context = {}) => {
+                const value = this.field.defaultValue;
+                return typeof value === 'function' ? value(context) : value;
+            }
+        };
+    }
     hint(hint) {
         this.field.hint = hint;
         return this;
@@ -83,8 +172,9 @@ export class FormFieldBuilder extends FieldBuilder {
         clone.field = cloneDeep(this.field);
         return clone;
     }
-    $generateSchema(fn) {
-        this._generateSchema = fn;
+    /** Server-side schema concern, same family as $beforeRead/$beforeSave. */
+    $references(table, options) {
+        this._references = { table, ...options };
         return this;
     }
     $beforeRead(hook) {

package/dist/core/fields/builders/select-builder.d.ts

@@ -1,9 +1,11 @@
+import type { DataType } from './form-field-builder.js';
 import { FormFieldBuilder } from './form-field-builder.js';
-import type { DefaultValueFn, FormField, Option } from '../../../fields/types.js';
+import type { DefaultValueFn, FieldValidationFunc, FormField, Option } from '../../../fields/types.js';
 type FieldWithOptions = FormField & {
     options: Option[];
     defaultValue?: (string | DefaultValueFn<string>) | (string[] | DefaultValueFn<string[]>);
     many?: boolean;
+    validate?: FieldValidationFunc<FieldWithOptions>;
 };
 declare class PickFieldBuilder<T extends FieldWithOptions = FieldWithOptions> extends FormFieldBuilder<T> {
     constructor(name: string, type: string);
@@ -17,6 +19,7 @@ declare class PickFieldBuilder<T extends FieldWithOptions = FieldWithOptions> ex
 }
 export declare class PickOneFieldBuilder<T extends FieldWithOptions = FieldWithOptions> extends PickFieldBuilder<T> {
     defaultValue(value: string | DefaultValueFn<string>): this;
+    get dataType(): DataType;
 }
 export declare class PickManyFieldBuilder<T extends FieldWithOptions = FieldWithOptions> extends PickFieldBuilder<T> {
     defaultValue(value: string[] | DefaultValueFn<string[]>): this;

package/dist/core/fields/builders/select-builder.js

@@ -61,6 +61,9 @@ export class PickOneFieldBuilder extends PickFieldBuilder {
         this.field.defaultValue = value;
         return this;
     }
+    get dataType() {
+        return 'text';
+    }
 }
 export class PickManyFieldBuilder extends PickFieldBuilder {
     defaultValue(value) {

package/dist/core/fields/util.d.ts

@@ -1,5 +1,6 @@
 import type { Field, FormField, SeparatorField } from '../../fields/types.js';
 import type { Dic } from '../../util/types.js';
+import type { FormFieldBuilder } from './builders/form-field-builder.js';
 import type { FieldBuilder } from './builders/index.js';
 /**
  * Checks if a field is a presentative field (currently only separator fields).
@@ -10,24 +11,15 @@ export declare const isPresentative: (field: Field) => field is SeparatorField;
  * Checks if a field is a form field (has a name property).
  * Form fields are fields that can store data in documents.
  */
-export declare const isFormField: (field: Field) => field is FormField;
+export declare const isFormField: <T extends Field>(field: FieldBuilder<T>) => field is FormFieldBuilder<T & FormField>;
 /**
  * Checks if a form field is not hidden.
  */
-export declare const isNotHidden: (field: FormField) => boolean;
+export declare const isNotHidden: <T extends FormField>(field: FormFieldBuilder<T>) => boolean;
 /**
  * Checks if a field has live updates enabled.
  */
 export declare const isLiveField: (field: Field) => boolean | undefined;
-/**
- * Flattens a nested field structure into an array of form fields.
- * Handles special field types like tabs, tree, and blocks.
- *
- * @example
- * // Flattens a tabs field into its constituent form fields
- * const fields = [tabsField].reduce(toFormFields, []);
- */
-export declare function toFormFields(prev: any[], curr: any): any;
 /**
  * Creates an object with empty values based on field configurations.
  * Uses defaultValue if specified, otherwise undefined.
@@ -43,7 +35,7 @@ export declare function toFormFields(prev: any[], curr: any): any;
  *   ]}
  * ]);
  */
-export declare const emptyValuesFromFieldConfig: <T extends FormField>(arr: T[]) => Dic;
+export declare const emptyValuesFromFieldConfig: <T extends FormFieldBuilder>(arr: T[]) => Dic;
 /**
  * Converts a path with numeric indices to a regex pattern
  * Numbers between dots or between dot and colon are converted to \d+
@@ -59,13 +51,13 @@ export declare function pathToRegex(path: string): RegExp;
  * Retrieves a field configuration by its dot-notation path
  * @example
  * // Get the title field in the attributes group
- * const titleField = getFieldConfigByPath('attributes.title', collection.fields);
+ * const titleField = getFieldAtPath('attributes.title', collection.fields);
  *
  * // Get the title field in a specific block
- * const titleField = getFieldConfigByPath('attributes.layout.2:blockType.title', collection.fields);
+ * const titleField = getFieldAtPath('attributes.layout.2:blockType.title', collection.fields);
  *
  */
-export declare const getFieldConfigByPath: (path: string, fields: Field[]) => FormField | undefined;
+export declare const getFieldAtPath: (path: string, fields: FieldBuilder[]) => FormFieldBuilder<FormField> | undefined;
 /**
  * Traverses a FieldBuilder[] tree and returns the subset of builders to pass to
  * RenderFields, along with the path prefix those builders should be rendered at.
@@ -74,7 +66,7 @@ export declare const getFieldConfigByPath: (path: string, fields: Field[]) => Fo
  * Blocks are treated as endpoints — the blocks builder itself is returned
  * regardless of any index:blockType suffix in the path.
  */
-export declare function getFieldBuildersAtPath(fieldPath: string, builders: FieldBuilder[], parentPath?: string): {
+export declare function getFieldListAtPath(fieldPath: string, fields: FieldBuilder[], parentPath?: string): {
     fields: FieldBuilder[];
     path: string;
 };

package/dist/core/fields/util.js

@@ -1,7 +1,7 @@
-import { BlocksBuilder, isBlocksFieldRaw } from '../../fields/blocks/index.js';
-import { GroupFieldBuilder, isGroupFieldRaw } from '../../fields/group/index.js';
-import { isTabsFieldRaw, TabsBuilder } from '../../fields/tabs/index.js';
-import { isTreeFieldRaw, TreeBuilder } from '../../fields/tree/index.js';
+import { BlocksBuilder } from '../../fields/blocks/index.js';
+import { GroupFieldBuilder } from '../../fields/group/index.js';
+import { TabsBuilder } from '../../fields/tabs/index.js';
+import { TreeBuilder } from '../../fields/tree/index.js';
 import { normalizeFieldPath } from '../../util/doc.js';
 /**
  * Checks if a field is a presentative field (currently only separator fields).
@@ -12,48 +12,15 @@ export const isPresentative = (field) => ['separator'].includes(field.type);
  * Checks if a field is a form field (has a name property).
  * Form fields are fields that can store data in documents.
  */
-export const isFormField = (field) => 'name' in field;
+export const isFormField = (field) => field.name !== '';
 /**
  * Checks if a form field is not hidden.
  */
-export const isNotHidden = (field) => !field.hidden;
+export const isNotHidden = (field) => !field.get.hidden;
 /**
  * Checks if a field has live updates enabled.
  */
 export const isLiveField = (field) => field.live;
-/**
- * Flattens a nested field structure into an array of form fields.
- * Handles special field types like tabs, tree, and blocks.
- *
- * @example
- * // Flattens a tabs field into its constituent form fields
- * const fields = [tabsField].reduce(toFormFields, []);
- */
-export function toFormFields(prev, curr) {
-    if (curr.type === 'tabs') {
-        return curr.tabs.reduce(toFormFields, prev);
-    }
-    else if (curr.type === 'tree') {
-        curr = {
-            ...curr,
-            fields: curr.fields.reduce(toFormFields, [])
-        };
-    }
-    else if (curr.type === 'blocks') {
-        curr = {
-            ...curr,
-            blocks: curr.blocks.map((b) => ({
-                ...b,
-                fields: b.fields.reduce(toFormFields, [])
-            }))
-        };
-    }
-    else if ('fields' in curr) {
-        return curr.fields.reduce(toFormFields, prev);
-    }
-    prev.push(curr);
-    return prev;
-}
 /**
  * Creates an object with empty values based on field configurations.
  * Uses defaultValue if specified, otherwise undefined.
@@ -73,24 +40,23 @@ export const emptyValuesFromFieldConfig = (arr) => {
     return Object.fromEntries(arr.map((config) => {
         let emptyValue;
         // Handle group fields - create nested object structure
-        if (isGroupFieldRaw(config)) {
-            emptyValue = emptyValuesFromFieldConfig(config.fields.filter(isFormField));
+        if (config instanceof GroupFieldBuilder) {
+            emptyValue = emptyValuesFromFieldConfig(config.get.fields.filter(isFormField));
         }
         // Handle tabs fields - create nested object structure for each tab
-        else if (isTabsFieldRaw(config)) {
+        else if (config instanceof TabsBuilder) {
             const tabsValue = {};
-            const tabs = config.tabs;
+            const tabs = config.get.tabs;
             for (const tab of tabs) {
                 if ('fields' in tab) {
-                    tabsValue[tab.name] = emptyValuesFromFieldConfig(tab.fields.filter(isFormField));
+                    tabsValue[tab.name] = emptyValuesFromFieldConfig(tab.get.fields.filter(isFormField));
                 }
             }
             emptyValue = tabsValue;
         }
         // Handle default values
-        else if ('defaultValue' in config) {
-            emptyValue =
-                typeof config.defaultValue === 'function' ? config.defaultValue() : config.defaultValue;
+        else {
+            emptyValue = config.run.defaultValue();
         }
         return [config.name, emptyValue];
     }));
@@ -118,13 +84,13 @@ export function pathToRegex(path) {
  * Retrieves a field configuration by its dot-notation path
  * @example
  * // Get the title field in the attributes group
- * const titleField = getFieldConfigByPath('attributes.title', collection.fields);
+ * const titleField = getFieldAtPath('attributes.title', collection.fields);
  *
  * // Get the title field in a specific block
- * const titleField = getFieldConfigByPath('attributes.layout.2:blockType.title', collection.fields);
+ * const titleField = getFieldAtPath('attributes.layout.2:blockType.title', collection.fields);
  *
  */
-export const getFieldConfigByPath = (path, fields) => {
+export const getFieldAtPath = (path, fields) => {
     const parts = path.split('.');
     const findInFields = (currentFields, remainingParts) => {
         if (remainingParts.length === 0)
@@ -132,10 +98,10 @@ export const getFieldConfigByPath = (path, fields) => {
         const currentPart = remainingParts[0];
         for (const field of currentFields) {
             // Handle tabs
-            if (isTabsFieldRaw(field)) {
-                const tab = field.tabs.find((t) => t.name === currentPart);
+            if (field instanceof TabsBuilder) {
+                const tab = field.get.tabs.find((t) => t.name === currentPart);
                 if (tab) {
-                    return findInFields(tab.fields, remainingParts.slice(1));
+                    return findInFields(tab.get.fields, remainingParts.slice(1));
                 }
                 continue;
             }
@@ -145,22 +111,22 @@ export const getFieldConfigByPath = (path, fields) => {
                     if (remainingParts.length === 1) {
                         return field;
                     }
-                    if (isGroupFieldRaw(field)) {
-                        return findInFields(field.fields, remainingParts.slice(1));
+                    if (field instanceof GroupFieldBuilder) {
+                        return findInFields(field.get.fields, remainingParts.slice(1));
                     }
                     // Handle blocks
-                    if (isBlocksFieldRaw(field) && remainingParts.length > 1) {
+                    if (field instanceof BlocksBuilder && remainingParts.length > 1) {
                         // const blockPartPattern = /:[a-zA-Z0-9]+/
                         const blockType = remainingParts[1].split(':')[1];
                         if (blockType) {
-                            const block = field.blocks.find((b) => b.name === blockType);
+                            const block = field.get.blocks.find((b) => b.name === blockType);
                             if (block) {
-                                return findInFields(block.fields, remainingParts.slice(2));
+                                return findInFields(block.get.fields, remainingParts.slice(2));
                             }
                         }
                     }
-                    if (isTreeFieldRaw(field)) {
-                        return findInFields(field.fields, remainingParts.slice(2));
+                    if (field instanceof TreeBuilder) {
+                        return findInFields(field.get.fields, remainingParts.slice(2));
                     }
                 }
             }
@@ -177,67 +143,67 @@ export const getFieldConfigByPath = (path, fields) => {
  * Blocks are treated as endpoints — the blocks builder itself is returned
  * regardless of any index:blockType suffix in the path.
  */
-export function getFieldBuildersAtPath(fieldPath, builders, parentPath = '') {
+export function getFieldListAtPath(fieldPath, fields, parentPath = '') {
     if (!fieldPath)
-        return { fields: builders, path: parentPath };
+        return { fields, path: parentPath };
     const dotIndex = fieldPath.indexOf('.');
     const head = dotIndex === -1 ? fieldPath : fieldPath.slice(0, dotIndex);
     const tail = dotIndex === -1 ? '' : fieldPath.slice(dotIndex + 1);
     const isEndpoint = fieldPath.split('.').length === 1;
     const nextParentPath = normalizeFieldPath(`${parentPath}${parentPath ? '.' : ''}${head}`);
-    for (const builder of builders) {
+    for (const field of fields) {
         // ── Tabs container: navigate into the matching tab
-        if (builder instanceof TabsBuilder) {
-            const tab = builder.field.tabs.find((t) => t.name === head);
+        if (field instanceof TabsBuilder) {
+            const tab = field.field.tabs.find((t) => t.name === head);
             if (!tab)
                 continue;
             if (isEndpoint) {
                 // Path targets the tab → return all its inner fields
-                return { fields: tab.raw.fields, path: nextParentPath };
+                return { fields: tab.get.fields, path: nextParentPath };
             }
-            return getFieldBuildersAtPath(tail, tab.raw.fields, nextParentPath);
+            return getFieldListAtPath(tail, tab.get.fields, nextParentPath);
         }
-        if (!isFormField(builder.raw))
+        if (!isFormField(field))
             continue;
         // ── Group field: navigate into children
-        if (builder instanceof GroupFieldBuilder && builder.raw.name === head) {
-            const children = builder.field.fields;
+        if (field instanceof GroupFieldBuilder && field.name === head) {
+            const children = field.get.fields;
             if (isEndpoint)
                 return { fields: children, path: nextParentPath };
-            return getFieldBuildersAtPath(tail, children, nextParentPath);
+            return getFieldListAtPath(tail, children, nextParentPath);
         }
         // —— Blocks
-        if (builder instanceof BlocksBuilder && builder.raw.name === head) {
+        if (field instanceof BlocksBuilder && field.name === head) {
             const blockType = tail.split('.')[0]?.split(':')[1];
             const isInnerBlockLookup = tail.split('.').length > 1;
             const nextParentPathWithBlockIndex = `${nextParentPath}.${tail.split('.')[0]}`;
             if (blockType) {
-                const block = builder.raw.blocks.find((b) => b.name === blockType);
-                if (!isInnerBlockLookup && block?.raw.fields) {
+                const block = field.get.blocks.find((b) => b.name === blockType);
+                if (!isInnerBlockLookup && block?.get.fields) {
                     return {
-                        fields: block?.raw.fields,
+                        fields: block.get.fields,
                         path: normalizeFieldPath(nextParentPathWithBlockIndex)
                     };
                 }
                 if (block) {
-                    return getFieldBuildersAtPath(tail.split('.').slice(1).join('.'), block?.raw.fields, normalizeFieldPath(nextParentPathWithBlockIndex));
+                    return getFieldListAtPath(tail.split('.').slice(1).join('.'), block.get.fields, normalizeFieldPath(nextParentPathWithBlockIndex));
                 }
             }
-            return { fields: [builder], path: parentPath };
+            return { fields: [field], path: parentPath };
         }
         // Tree
-        if (builder instanceof TreeBuilder && builder.raw.name === head) {
-            const children = builder.raw.fields;
+        if (field instanceof TreeBuilder && field.name === head) {
+            const children = field.get.fields;
             const nextParentPathWithIndex = `${nextParentPath}.${tail.split('.')[0]}`;
             if (isEndpoint)
                 return { fields: children, path: nextParentPath };
-            return getFieldBuildersAtPath(tail.split('.').slice(1).join('.'), children, nextParentPathWithIndex);
+            return getFieldListAtPath(tail.split('.').slice(1).join('.'), children, nextParentPathWithIndex);
         }
         // Direct unique field match
-        if (isEndpoint && isFormField(builder.raw) && builder.raw.name === fieldPath) {
-            return { fields: [builder], path: parentPath };
+        if (isEndpoint && isFormField(field) && field.name === fieldPath) {
+            return { fields: [field], path: parentPath };
         }
     }
     console.warn(`[LiveEditPanel] fieldPath "${fieldPath}" not found in config fields`);
-    return { fields: builders, path: parentPath };
+    return { fields, path: parentPath };
 }