rimecms 0.33.0 → 1.0.0

package/dist/core/dev/codegen/types/contributions.server.js

@@ -2,11 +2,14 @@ import { isVersioned } from '../../../prototype/shared/versions/enabled.js';
 import { versionsDocType } from '../../../prototype/shared/versions/doc-type.js';
 import { isUpload } from '../../../prototype/collection/upload/enabled.js';
 import { uploadDocType } from '../../../prototype/collection/upload/doc-type.js';
+import { hasUrl } from '../../../prototype/shared/url/enabled.js';
+import { urlDocType } from '../../../prototype/shared/url/doc-type.js';
 /**
  * What each config's generated doc type gains beyond its own fields.
  *
- * Two contributors and they are the whole list: `versions` adds `versionId`, `upload` extends
- * `UploadDoc`, adds its `sizes` member and filters out the fields its image sizes collide with.
+ * Three contributors and they are the whole list: `versions` adds `versionId`, `upload` extends
+ * `UploadDoc`, adds its `sizes` member and filters out the fields its image sizes collide with,
+ * `url` adds the address.
  * The `fields` predicates are **ANDed** — each says which fields it still wants generated, and
  * a field has to survive both.
  *
@@ -14,7 +17,11 @@ import { uploadDocType } from '../../../prototype/collection/upload/doc-type.js'
 export const contributionsFor = (config) => 
 // Upload before versions: the prototype's feature list has upload first, and the members land
 // in that order in the generated type.
-[isUpload(config) ? uploadDocType(config) : null, isVersioned(config) ? versionsDocType() : null]
+[
+    isUpload(config) ? uploadDocType(config) : null,
+    isVersioned(config) ? versionsDocType() : null,
+    hasUrl(config) ? urlDocType(config.type) : null
+]
     .filter((c) => c !== null)
     .reduce((current, contribution) => ({
     extends: [...current.extends, ...(contribution.extends ?? [])],

package/dist/core/dev/vite.server.js

@@ -149,16 +149,17 @@ export function rime() {
         },
         config() {
             return {
+                // `bun:sqlite` only exists at runtime under Bun (adapterSqlite driver 'bun').
                 ssr: {
-                    external: ['sharp']
+                    external: ['sharp', 'bun:sqlite']
                 },
                 optimizeDeps: {
-                    exclude: ['sharp'],
+                    exclude: ['sharp', 'bun:sqlite'],
                     include: ['@lucide/svelte']
                 },
                 build: {
                     rollupOptions: {
-                        external: ['sharp']
+                        external: ['sharp', 'bun:sqlite']
                     },
                     target: 'es2022'
                 },

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

@@ -0,0 +1,21 @@
+import type { FieldBuilder } from './builders/field-builder.js';
+import type { Field } from '../../fields/types.js';
+import type { Dic } from '../../util/types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/** What a field is handed to build its blank value. The event is a default's, and boot has none. */
+export type BlankContext = {
+    event?: RequestEvent;
+};
+/**
+ * A list of fields as a blank object, each field contributing its own members.
+ *
+ * A branch opens an object, a leaf holds its default, and a repeater holds its own — `#` in a
+ * segment means only a document can name the children.
+ *
+ * ```
+ * group('attributes').fields(text('title'))   ->  { attributes: { title: null } }
+ * tabs(tab('meta').fields(text('title')))     ->  { meta: { title: null } }
+ * blocks('layout', [...])                     ->  { layout: [] }
+ * ```
+ */
+export declare const blankFields: (fields: FieldBuilder<Field>[], context?: BlankContext) => Dic;

package/dist/core/fields/blank.js

@@ -0,0 +1,37 @@
+import { isFormField } from './util.js';
+/**
+ * A list of fields as a blank object, each field contributing its own members.
+ *
+ * A branch opens an object, a leaf holds its default, and a repeater holds its own — `#` in a
+ * segment means only a document can name the children.
+ *
+ * ```
+ * group('attributes').fields(text('title'))   ->  { attributes: { title: null } }
+ * tabs(tab('meta').fields(text('title')))     ->  { meta: { title: null } }
+ * blocks('layout', [...])                     ->  { layout: [] }
+ * ```
+ */
+export const blankFields = (fields, context = {}) => {
+    const doc = {};
+    for (const field of fields) {
+        try {
+            const nodes = field.use.nodes();
+            if (!nodes.length || nodes.some((node) => node.segment.includes('#'))) {
+                if (isFormField(field))
+                    doc[field.name] = field.use.defaultValue(context) ?? null;
+                continue;
+            }
+            // Its name opens an object, or it has none and its branches land on this one.
+            const target = field.name ? (doc[field.name] = {}) : doc;
+            for (const node of nodes) {
+                const bucket = node.segment ? (target[node.segment] = {}) : target;
+                Object.assign(bucket, blankFields(node.fields, context));
+            }
+        }
+        catch (err) {
+            console.error(`Building the blank value of ${field.type} field "${field.name}" failed.`);
+            throw err;
+        }
+    }
+    return doc;
+};

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

@@ -23,6 +23,53 @@ export type FieldUse = {
     accessCreate(...args: Parameters<FieldAccess>): boolean;
     accessUpdate(...args: Parameters<FieldAccess>): boolean;
     generateType(): string;
+    /** Every branch this field can produce, from the config alone. */
+    nodes(): FieldNode[];
+    /** The branches this particular value has. */
+    nodesFor(value: unknown): ValueNode[];
+};
+/**
+ * One branch below a field: what it adds to the path, and the fields under it.
+ *
+ * ```
+ * group('attributes')  ->  { segment: '',        fields: [ text('title') ] }
+ * tabs(tab('meta'))    ->  { segment: 'meta',    fields: [ text('title') ] }
+ * blocks('layout')     ->  { segment: '#:hero',  fields: [ text('title') ] }
+ * tree('nav')          ->  { segment: '#', repeatVia: '_children', fields: [ text('label') ] }
+ * ```
+ */
+export type FieldNode = {
+    /**
+     * The segment this branch contributes below the field's own name. `''` when it contributes
+     * nothing — Group, whose own name is already the segment. `#` stands for an index that only a
+     * document can supply.
+     */
+    segment: string;
+    /**
+     * When set, the branch nests into itself through this segment, so `nav.0`, `nav.0._children.1`
+     * and deeper are all this same branch. Read when resolving a path; a value walk flattens the
+     * recursion itself.
+     */
+    repeatVia?: string;
+    fields: FieldBuilder[];
+    /**
+     * The branch is stored as rows of its own, in a child table of the owner, not as its columns.
+     * `kind` is the table's marker on disk; `name` is what follows it.
+     *
+     * ```
+     * blocks('layout', [block('hero')])   { kind: 'blocks', name: 'hero' }    pages__$blocks_hero
+     * tree('nav')                         { kind: 'tree', name: 'nav' }       pages__$tree_nav
+     * ```
+     */
+    storage?: NodeStorage;
+};
+export type NodeStorage = {
+    kind: 'blocks' | 'tree';
+    name: string;
+};
+/** A branch a real value has: a concrete segment, no `#`, and the data under it. */
+export type ValueNode = FieldNode & {
+    value: unknown;
 };
 export declare class FieldBuilder<T extends Field = Field> {
     field: T;
@@ -68,4 +115,10 @@ export declare class FieldBuilder<T extends Field = Field> {
      *  compile error), while staying a real overridable method so every concrete field can
      *  provide its own, unlike a private `#field` which can't be polymorphically overridden. */
     protected generateType(): string;
+    /** The branches below this field, from the config alone. A leaf has none.
+     *  `protected` and reached through `.use.nodes()`, same as `generateType`. */
+    protected nodes(): FieldNode[];
+    /** The branches below this field for one value. A leaf has none.
+     *  `protected` and reached through `.use.nodesFor()`, same as `generateType`. */
+    protected nodesFor(_value: unknown): ValueNode[];
 }

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

@@ -56,7 +56,9 @@ export class FieldBuilder {
             accessCreate: (..._args) => true,
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
             accessUpdate: (..._args) => true,
-            generateType: () => this.generateType()
+            generateType: () => this.generateType(),
+            nodes: () => this.nodes(),
+            nodesFor: (value) => this.nodesFor(value)
         };
     }
     get component() {
@@ -72,4 +74,15 @@ export class FieldBuilder {
     generateType() {
         return '';
     }
+    /** The branches below this field, from the config alone. A leaf has none.
+     *  `protected` and reached through `.use.nodes()`, same as `generateType`. */
+    nodes() {
+        return [];
+    }
+    /** The branches below this field for one value. A leaf has none.
+     *  `protected` and reached through `.use.nodesFor()`, same as `generateType`. */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    nodesFor(_value) {
+        return [];
+    }
 }

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

@@ -67,6 +67,14 @@ export declare class FormFieldBuilder<T extends FormField = FormField> extends F
      * `_parent` on a nested collection is the typical case: the site tree must not fork per version.
      */
     $root(): this;
+    /**
+     * Indexes the field's column, for a field a list is filtered or sorted by.
+     *
+     * ```ts
+     * text('sku').$index()   // where[sku][equals]=… reads the index, not every row
+     * ```
+     */
+    $index(): 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

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

@@ -69,6 +69,17 @@ export class FormFieldBuilder extends FieldBuilder {
         this.field.root = true;
         return this;
     }
+    /**
+     * Indexes the field's column, for a field a list is filtered or sorted by.
+     *
+     * ```ts
+     * text('sku').$index()   // where[sku][equals]=… reads the index, not every row
+     * ```
+     */
+    $index() {
+        this.field.index = 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
@@ -148,7 +159,9 @@ export class FormFieldBuilder extends FieldBuilder {
                 const value = this.field.defaultValue;
                 return typeof value === 'function' ? value(context) : value;
             },
-            generateType: () => this._references?.resolve ? this.resolvedReferenceType() : this.generateType()
+            generateType: () => this._references?.resolve ? this.resolvedReferenceType() : this.generateType(),
+            nodes: () => this.nodes(),
+            nodesFor: (value) => this.nodesFor(value)
         };
     }
     /** The document a resolved reference reads as, whatever the field's own type says. */

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

@@ -1,4 +1,4 @@
-import type { Field, FormField, SeparatorField } from '../../fields/types.js';
+import type { Field, FieldAccess, 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';
@@ -35,7 +35,7 @@ export declare const isLiveField: (field: Field) => boolean | undefined;
  *   ]}
  * ]);
  */
-export declare const emptyValuesFromFieldConfig: <T extends FormFieldBuilder>(arr: T[]) => Dic;
+export declare const emptyValuesFromFieldConfig: (fields: FieldBuilder[]) => Dic;
 /**
  * Converts a path with numeric indices to a regex pattern
  * Numbers between dots or between dot and colon are converted to \d+
@@ -85,6 +85,8 @@ export declare const baseFieldNames: (config: {
     fields: FieldBuilder[];
 }) => string[];
 export type ResolvedReference = {
+    /** The field itself, for whoever must ask it something — who may read it, for one. */
+    field: FormFieldBuilder<FormField>;
     /** The document path: `meta.owner`. */
     path: string;
     /** The column it is stored in: `meta__owner`. */
@@ -109,6 +111,11 @@ export type ResolvedReference = {
  * Walks tabs and groups, whose columns sit on the owner's row. Blocks and tree rows are their
  * own tables and are not walked.
  */
+/**
+ * The resolved references a reader may see, by path — what a read asks the adapter to join. A
+ * reference the pipeline would drop for this reader is not joined for nothing.
+ */
+export declare const readableReferences: (fields: FieldBuilder[], user: Parameters<FieldAccess>[0]) => string[];
 export declare const resolvedReferencesOf: (fields: FieldBuilder[], parentPath?: string) => ResolvedReference[];
 /**
  * Splits a write into the half that belongs on the base row and the half that belongs on the

package/dist/core/fields/util.js

@@ -1,8 +1,5 @@
-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/path.js';
+import { normalizeFieldPath } from '../../util/string.js';
+import { matchesSegment, walkFields } from './walk.js';
 /**
  * Checks if a field is a presentative field (currently only separator fields).
  * Presentative fields are used for UI organization and don't store data.
@@ -36,31 +33,20 @@ export const isLiveField = (field) => field.live;
  *   ]}
  * ]);
  */
-export const emptyValuesFromFieldConfig = (arr) => {
-    return Object.fromEntries(arr.map((config) => {
-        let emptyValue;
-        // Handle group fields - create nested object structure
-        if (config instanceof GroupFieldBuilder) {
-            emptyValue = emptyValuesFromFieldConfig(config.get.fields.filter(isFormField));
-        }
-        // Handle tabs fields - create nested object structure for each tab
-        else if (config instanceof TabsBuilder) {
-            const tabsValue = {};
-            const tabs = config.get.tabs;
-            for (const tab of tabs) {
-                if ('fields' in tab) {
-                    tabsValue[tab.name] = emptyValuesFromFieldConfig(tab.get.fields.filter(isFormField));
-                }
-            }
-            emptyValue = tabsValue;
-        }
-        // Handle default values
-        else {
-            emptyValue = config.use.defaultValue();
-        }
-        return [config.name, emptyValue];
-    }));
-};
+export const emptyValuesFromFieldConfig = (fields) => Object.fromEntries(fields.filter(isFormField).map((config) => {
+    const nodes = config.use.nodes();
+    // A leaf, and a repeater with it: `#` means only a document can name the children, so an
+    // empty one holds the field's own default.
+    if (!nodes.length || nodes.some((node) => node.segment.includes('#'))) {
+        return [config.name, config.use.defaultValue()];
+    }
+    const value = {};
+    for (const node of nodes) {
+        const bucket = node.segment ? (value[node.segment] = {}) : value;
+        Object.assign(bucket, emptyValuesFromFieldConfig(node.fields));
+    }
+    return [config.name, value];
+}));
 /**
  * Converts a path with numeric indices to a regex pattern
  * Numbers between dots or between dot and colon are converted to \d+
@@ -91,49 +77,53 @@ export function pathToRegex(path) {
  *
  */
 export const getFieldAtPath = (path, fields) => {
-    const parts = path.split('.');
-    const findInFields = (currentFields, remainingParts) => {
-        if (remainingParts.length === 0)
+    const findInFields = (currentFields, parts) => {
+        if (!parts.length)
             return undefined;
-        const currentPart = remainingParts[0];
         for (const field of currentFields) {
-            // Handle tabs
-            if (field instanceof TabsBuilder) {
-                const tab = field.get.tabs.find((t) => t.name === currentPart);
-                if (tab) {
-                    return findInFields(tab.get.fields, remainingParts.slice(1));
+            const nodes = field.use.nodes();
+            // A container with no name of its own: its branches are the segment (tabs).
+            if (!field.name) {
+                for (const node of nodes) {
+                    if (!matchesSegment(node.segment, parts[0]))
+                        continue;
+                    const found = findInFields(node.fields, parts.slice(1));
+                    if (found)
+                        return found;
                 }
                 continue;
             }
-            // Handle regular fields
-            if (isFormField(field)) {
-                if (field.name === currentPart) {
-                    if (remainingParts.length === 1) {
-                        return field;
-                    }
-                    if (field instanceof GroupFieldBuilder) {
-                        return findInFields(field.get.fields, remainingParts.slice(1));
-                    }
-                    // Handle blocks
-                    if (field instanceof BlocksBuilder && remainingParts.length > 1) {
-                        // const blockPartPattern = /:[a-zA-Z0-9]+/
-                        const blockType = remainingParts[1].split(':')[1];
-                        if (blockType) {
-                            const block = field.get.blocks.find((b) => b.name === blockType);
-                            if (block) {
-                                return findInFields(block.get.fields, remainingParts.slice(2));
-                            }
-                        }
-                    }
-                    if (field instanceof TreeBuilder) {
-                        return findInFields(field.get.fields, remainingParts.slice(2));
-                    }
+            if (field.name !== parts[0])
+                continue;
+            if (parts.length === 1)
+                return field;
+            for (const node of nodes) {
+                // A branch that adds no segment: the rest of the path is already inside it.
+                if (!node.segment) {
+                    const found = findInFields(node.fields, parts.slice(1));
+                    if (found)
+                        return found;
+                    continue;
+                }
+                if (!matchesSegment(node.segment, parts[1]))
+                    continue;
+                // A repeating branch stays itself through `_children.<index>`, however deep.
+                let rest = parts.slice(2);
+                while (node.repeatVia &&
+                    rest[0] === node.repeatVia &&
+                    rest[1] !== undefined &&
+                    matchesSegment(node.segment, rest[1])) {
+                    rest = rest.slice(2);
                 }
+                const found = findInFields(node.fields, rest);
+                if (found)
+                    return found;
             }
+            return undefined;
         }
         return undefined;
     };
-    return findInFields(fields, parts);
+    return findInFields(fields, path.split('.'));
 };
 /**
  * Traverses a FieldBuilder[] tree and returns the subset of builders to pass to
@@ -149,60 +139,53 @@ export function getFieldListAtPath(fieldPath, fields, 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}`);
+    const isEndpoint = !tail;
+    const below = (path, segment) => normalizeFieldPath(path ? `${path}.${segment}` : segment);
     for (const field of fields) {
-        // ── Tabs container: navigate into the matching tab
-        if (field instanceof TabsBuilder) {
-            const tab = field.field.tabs.find((t) => t.name === head);
-            if (!tab)
+        const nodes = field.use.nodes();
+        // A container with no name of its own: its branches are the segment (tabs).
+        if (!field.name) {
+            const node = nodes.find((candidate) => matchesSegment(candidate.segment, head));
+            if (!node)
                 continue;
-            if (isEndpoint) {
-                // Path targets the tab → return all its inner fields
-                return { fields: tab.get.fields, path: nextParentPath };
-            }
-            return getFieldListAtPath(tail, tab.get.fields, nextParentPath);
+            const path = below(parentPath, head);
+            return isEndpoint
+                ? { fields: node.fields, path }
+                : getFieldListAtPath(tail, node.fields, path);
         }
-        if (!isFormField(field))
+        if (field.name !== head)
             continue;
-        // ── Group field: navigate into children
-        if (field instanceof GroupFieldBuilder && field.name === head) {
-            const children = field.get.fields;
-            if (isEndpoint)
-                return { fields: children, path: nextParentPath };
-            return getFieldListAtPath(tail, children, nextParentPath);
+        const own = below(parentPath, head);
+        // A branch that adds no segment: the rest of the path is already inside it (group).
+        const transparent = nodes.find((node) => !node.segment);
+        if (transparent) {
+            return isEndpoint
+                ? { fields: transparent.fields, path: own }
+                : getFieldListAtPath(tail, transparent.fields, own);
         }
-        // —— Blocks
-        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 = field.get.blocks.find((b) => b.name === blockType);
-                if (!isInnerBlockLookup && block?.get.fields) {
-                    return {
-                        fields: block.get.fields,
-                        path: normalizeFieldPath(nextParentPathWithBlockIndex)
-                    };
-                }
-                if (block) {
-                    return getFieldListAtPath(tail.split('.').slice(1).join('.'), block.get.fields, normalizeFieldPath(nextParentPathWithBlockIndex));
-                }
-            }
-            return { fields: [field], path: parentPath };
-        }
-        // Tree
-        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 getFieldListAtPath(tail.split('.').slice(1).join('.'), children, nextParentPathWithIndex);
+        if (isEndpoint) {
+            // Nothing left to pick a branch with. One unnamed branch is still the answer — a tree row;
+            // several named ones are not — a blocks field answers with itself.
+            const only = nodes.length === 1 && !nodes[0].segment.includes(':') ? nodes[0] : undefined;
+            return only ? { fields: only.fields, path: own } : { fields: [field], path: parentPath };
         }
-        // Direct unique field match
-        if (isEndpoint && isFormField(field) && field.name === fieldPath) {
+        const parts = tail.split('.');
+        const node = nodes.find((candidate) => matchesSegment(candidate.segment, parts[0]));
+        if (!node)
             return { fields: [field], path: parentPath };
+        // A repeating branch stays itself through `_children.<index>`, however deep.
+        let rest = parts.slice(1);
+        let path = below(own, parts[0]);
+        while (node.repeatVia &&
+            rest[0] === node.repeatVia &&
+            rest[1] !== undefined &&
+            matchesSegment(node.segment, rest[1])) {
+            path = `${path}.${rest[0]}.${rest[1]}`;
+            rest = rest.slice(2);
         }
+        return rest.length
+            ? getFieldListAtPath(rest.join('.'), node.fields, path)
+            : { fields: node.fields, path };
     }
     console.warn(`[LiveEditPanel] fieldPath "${fieldPath}" not found in config fields`);
     return { fields, path: parentPath };
@@ -218,10 +201,7 @@ export function getFieldListAtPath(fieldPath, fields, parentPath = '') {
  *
  * Top-level only, matching the generator: a nested field cannot be split off its parent.
  */
-export const baseFieldNames = (config) => config.fields
-    .filter(isFormField)
-    .filter((field) => field.get.root)
-    .map((field) => field.name);
+export const baseFieldNames = (config) => config.fields.filter((field) => field.get.root).map((field) => field.name);
 /**
  * The fields a read resolves into the document they reference, with the column each one is
  * stored in. A field opts in with `$references(slug, { resolve: true })`.
@@ -237,31 +217,39 @@ export const baseFieldNames = (config) => config.fields
  * Walks tabs and groups, whose columns sit on the owner's row. Blocks and tree rows are their
  * own tables and are not walked.
  */
+/**
+ * The resolved references a reader may see, by path — what a read asks the adapter to join. A
+ * reference the pipeline would drop for this reader is not joined for nothing.
+ */
+export const readableReferences = (fields, user) => resolvedReferencesOf(fields)
+    .filter((reference) => reference.field.use.accessRead(user))
+    .map((reference) => reference.path);
+const resolvedReferencesMemo = new WeakMap();
 export const resolvedReferencesOf = (fields, parentPath = '') => {
-    const prefix = parentPath ? `${parentPath}.` : '';
-    const found = [];
-    for (const field of fields) {
-        if (field instanceof TabsBuilder) {
-            for (const tab of field.get.tabs) {
-                found.push(...resolvedReferencesOf(tab.get.fields, `${prefix}${tab.name}`));
-            }
-            continue;
+    // A config's fields do not change once built, and this is asked once per query and once per
+    // document read: answered once per list of fields.
+    if (!parentPath) {
+        let found = resolvedReferencesMemo.get(fields);
+        if (!found) {
+            found = collectResolvedReferences(fields, '');
+            resolvedReferencesMemo.set(fields, found);
         }
-        if (!isFormField(field))
-            continue;
-        if (field instanceof GroupFieldBuilder) {
-            found.push(...resolvedReferencesOf(field.get.fields, `${prefix}${field.name}`));
+        return found;
+    }
+    return collectResolvedReferences(fields, parentPath);
+};
+const collectResolvedReferences = (fields, parentPath) => {
+    const found = [];
+    for (const { field, path } of walkFields(fields, { path: parentPath, determinate: true })) {
+        if (!isFormField(field) || !field._references?.resolve)
             continue;
-        }
-        if (field._references?.resolve) {
-            const path = `${prefix}${field.name}`;
-            found.push({
-                path,
-                column: path.replace(/\./g, '__'),
-                root: field.get.root,
-                to: field._references.table
-            });
-        }
+        found.push({
+            field,
+            path,
+            column: path.replace(/\./g, '__'),
+            root: field.get.root,
+            to: field._references.table
+        });
     }
     return found;
 };

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

@@ -0,0 +1,44 @@
+import type { FieldBuilder } from './builders/field-builder.js';
+/** A field the walk reached, the path it sits at, and the data there when the walk has data. */
+export type Visit = {
+    field: FieldBuilder;
+    path: string;
+    value: unknown;
+};
+/** The document grammar's join. A joiner is never handed an empty part — a branch that
+ *  contributes no segment keeps its parent's path — so it only guards the empty parent. */
+export declare const joinPath: (parent: string, part: string) => string;
+export type WalkOptions = {
+    path?: string;
+    /** The schema generator joins with `__`. */
+    join?: (parent: string, part: string) => string;
+    /** Skip branches whose segment holds a `#` — a path no config alone can name. */
+    determinate?: boolean;
+};
+/**
+ * Every field the config declares, parents before children, siblings in declaration order.
+ *
+ * ```
+ * tabs(tab('meta').fields(group('seo').fields(text('title'))))
+ *   ->  meta.seo  ·  meta.seo.title
+ * ```
+ */
+export declare function walkFields(fields: FieldBuilder[], { path, join, determinate }?: WalkOptions): Generator<Visit>;
+/**
+ * Every field a document actually carries, at the path its value sits at. A named field the data
+ * does not hold contributes nothing.
+ *
+ * ```
+ * blocks('layout', [block('hero').fields(text('title'))])
+ *   { layout: [ { type: 'hero', title: 'x' } ] }  ->  layout  ·  layout.0:hero.title
+ * ```
+ */
+export declare function walkValues(fields: FieldBuilder[], data: unknown, { path, join }?: WalkOptions): Generator<Visit>;
+/**
+ * Whether one concrete segment is the branch a declared segment stands for.
+ *
+ * ```
+ * '#:hero' matches '0:hero'  ·  '#' matches '7'  ·  'meta' matches only 'meta'
+ * ```
+ */
+export declare const matchesSegment: (pattern: string, segment: string) => boolean;