@byline/core 4.2.0 → 4.3.0

package/dist/@types/admin-types.d.ts

@@ -270,7 +270,12 @@ export interface CollectionAdminConfig<T = any> {
      */
     layout?: LayoutDefinition;
     /**
-     * Per-field rendering overrides, keyed by field name.
+     * Per-field rendering overrides, keyed by schema path: a top-level field
+     * name (`title`) or a dotted, index-free path through `group` / `array`
+     * structure fields (`files.filesGroup.publicationFile`). Paths address
+     * field *declarations*, never item instances (no `[0]` indices), and never
+     * traverse a `blocks` field — blocks take their overrides from the
+     * blockType-keyed `ClientConfig.blockAdmin` registry instead.
      * Placement is no longer expressed here — see the layout primitives above.
      */
     fields?: Record<string, FieldAdminConfig>;
@@ -405,25 +410,31 @@ export declare function defineAdmin<T = any>(schema: CollectionDefinition, confi
  * collection genuinely needs different presentation for "the same" block,
  * define a second block with a distinct `blockType`.
  *
- * v1 scope: `fields` keys address the block's **top-level** field names only —
- * the same limitation `CollectionAdminConfig.fields` has for collections.
- * Fields nested inside a group/array within the block inherit site-wide
- * defaults.
+ * `fields` keys are **schema paths** relative to the block root: a top-level
+ * field name (`quoteText`) or a dotted path through `group` / `array`
+ * structure fields (`faq.answer`). Schema paths are index-free — they address
+ * field *declarations*, not item instances (`faq.answer`, never
+ * `faq[0].answer`) — the same notation `upload` validation and the upload
+ * executor use. Paths never traverse a nested `blocks` field: an inner block
+ * resolves its own `blockAdmin` registry entry wherever it renders.
  */
 export interface BlockAdminConfig {
     /** Must match the `blockType` of the corresponding `defineBlock()` definition. */
     blockType: string;
     /**
      * Per-field rendering overrides (`components` slots, richtext `editor`),
-     * keyed by the block's top-level field names. Same shape and semantics as
+     * keyed by index-free schema paths relative to the block root (`alt`,
+     * `faq.answer`). Same shape and semantics as
      * `CollectionAdminConfig.fields`.
      */
     fields?: Record<string, FieldAdminConfig>;
 }
 /**
  * Type-safe factory for creating a `BlockAdminConfig` linked to a block
- * schema. Sets `blockType` from the block's `blockType` and constrains the
- * `fields` keys to the block's own top-level field names.
+ * schema. Sets `blockType` from the block's `blockType`. `fields` keys
+ * autocomplete the block's top-level field names; nested declarations are
+ * addressed with dotted, index-free schema paths (`faq.answer`), validated
+ * against the block's field tree at boot (`validateBlockAdminConfigs`).
  *
  * Lives on the admin side of the schema/admin split: block schema files stay
  * React-free and tsx-loadable, while this config may carry React component
@@ -444,5 +455,11 @@ export interface BlockAdminConfig {
  * ```
  */
 export declare function defineBlockAdmin<B extends Block>(block: B, config: {
-    fields?: Partial<Record<Extract<keyof BlockFieldData<B>, string>, FieldAdminConfig>>;
+    /**
+     * Keyed by schema path relative to the block root. Top-level field names
+     * autocomplete; nested fields are addressed with dotted, index-free
+     * paths (`faq.answer`) — accepted as plain strings here and resolved
+     * against the block's field tree at boot.
+     */
+    fields?: Partial<Record<Extract<keyof BlockFieldData<B>, string> | (string & {}), FieldAdminConfig>>;
 }): BlockAdminConfig;

package/dist/@types/admin-types.js

@@ -17,8 +17,10 @@ export function defineAdmin(schema, config) {
 }
 /**
  * Type-safe factory for creating a `BlockAdminConfig` linked to a block
- * schema. Sets `blockType` from the block's `blockType` and constrains the
- * `fields` keys to the block's own top-level field names.
+ * schema. Sets `blockType` from the block's `blockType`. `fields` keys
+ * autocomplete the block's top-level field names; nested declarations are
+ * addressed with dotted, index-free schema paths (`faq.answer`), validated
+ * against the block's field tree at boot (`validateBlockAdminConfigs`).
  *
  * Lives on the admin side of the schema/admin split: block schema files stay
  * React-free and tsx-loadable, while this config may carry React component

package/dist/config/routes.test.node.js

@@ -24,13 +24,7 @@ describe('resolveRoutes', () => {
             signIn: '/sign-in',
         });
     });
-    it.each([
-        '/../cms',
-        '/cms?next=x',
-        '/cms#section',
-        '/cms\\users',
-        '/%63ms',
-    ])('rejects a non-segment admin route of %j', (admin) => {
+    it.each(['/../cms', '/cms?next=x', '/cms#section', '/cms\\users', '/%63ms'])('rejects a non-segment admin route of %j', (admin) => {
         expect(() => resolveRoutes({ admin })).toThrow(/routes\.admin/);
     });
     it('normalizes and validates the API route too', () => {

package/dist/config/validate-admin-configs.d.ts

@@ -22,8 +22,9 @@ import type { BlockAdminConfig, CollectionAdminConfig, CollectionDefinition } fr
  *     are unique within an admin config and don't shadow schema field names.
  *  5. Nesting — `tabSets` only appear in `layout.main`; rows contain only
  *     schema field names; groups exclude tabSets and nested groups.
- *  6. `fields` map sanity — every key in `admin.fields` matches a top-level
- *     schema field name.
+ *  6. `fields` map sanity — every key in `admin.fields` is a dotted,
+ *     index-free schema path resolving to a field declaration (top-level
+ *     name or a path through group/array fields; never through blocks).
  *  7. `defaultSort` sanity — `field` resolves to a top-level schema field
  *     or a document-level column (`createdAt` / `updatedAt` / `path`), the
  *     direction (when given) is `asc` | `desc`, and the option is rejected
@@ -43,9 +44,11 @@ export declare function validateAdminConfigs(admins: readonly CollectionAdminCon
  *     `type: 'blocks'` field across the registered collections (blocks have
  *     no global registry; the collections walk is the source of truth).
  *  2. Uniqueness — no two entries share a `blockType`.
- *  3. `fields` map sanity — every key matches a top-level field name of the
- *     block (when the same `blockType` appears in several collections, the
- *     union of their top-level field names is accepted).
+ *  3. `fields` map sanity — every key is a dotted, index-free schema path
+ *     resolving to a field declaration of the block (top-level name or a
+ *     path through group/array fields; never through a nested blocks field).
+ *     When the same `blockType` appears in several collections, a key is
+ *     accepted if it resolves in any declaration site (union semantics).
  *
  * Throws a plain `Error` for the same reason `validateAdminConfigs` does —
  * this runs at startup, before the logger is necessarily wired up.

package/dist/config/validate-admin-configs.js

@@ -5,6 +5,61 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
+/**
+ * Resolve a dotted schema path (`faq.answer`, `files.filesGroup.publicationFile`)
+ * against a field set. Schema paths address field *declarations*: every
+ * segment names a field, intermediate segments must be `group` / `array`
+ * structure fields, and no segment carries an item index. Returns:
+ *
+ *  - `'ok'`         — the path resolves to a field declaration;
+ *  - `'blocks'`     — the path tries to traverse a `type: 'blocks'` field
+ *                     (blocks resolve their own admin config from the
+ *                     blockType-keyed registry, so this is always an error);
+ *  - `'unresolved'` — a segment doesn't name a field, or a value field
+ *                     appears mid-path.
+ */
+function resolveSchemaPath(fields, path) {
+    const segments = path.split('.');
+    let current = fields;
+    for (let i = 0; i < segments.length; i++) {
+        const name = segments[i];
+        const field = current.find((f) => 'name' in f && f.name === name);
+        if (field == null)
+            return 'unresolved';
+        if (i === segments.length - 1)
+            return 'ok';
+        if (field.type === 'group' || field.type === 'array') {
+            current = field.fields;
+        }
+        else if (field.type === 'blocks') {
+            return 'blocks';
+        }
+        else {
+            return 'unresolved';
+        }
+    }
+    return 'unresolved';
+}
+/**
+ * Shared validation for a `fields{}` override map (collection- or block-level):
+ * keys must be dotted, index-free schema paths that resolve to a field
+ * declaration without traversing a `blocks` field. `subject` names the config
+ * in error messages (`Collection "docs"` / `Block "faqBlock"`).
+ */
+function validateFieldAdminKeys(keys, resolve, fail) {
+    for (const key of keys) {
+        if (key.includes('[')) {
+            fail(`\`fields["${key}"]\` contains an item index. Field override keys are index-free schema paths addressing field declarations (e.g. "faq.answer"), not instance paths (e.g. "faq[0].answer").`);
+        }
+        const resolution = resolve(key);
+        if (resolution === 'blocks') {
+            fail(`\`fields["${key}"]\` traverses a \`type: 'blocks'\` field. Blocks resolve their own overrides from the blockType-keyed \`blockAdmin\` registry — register a block admin config for the inner block instead.`);
+        }
+        if (resolution === 'unresolved') {
+            fail(`\`fields["${key}"]\` does not resolve to a field declaration. Keys are dotted, index-free schema paths whose intermediate segments are \`group\` / \`array\` fields (e.g. "faq.answer").`);
+        }
+    }
+}
 /**
  * Validate every admin config in a configuration.
  *
@@ -21,8 +76,9 @@
  *     are unique within an admin config and don't shadow schema field names.
  *  5. Nesting — `tabSets` only appear in `layout.main`; rows contain only
  *     schema field names; groups exclude tabSets and nested groups.
- *  6. `fields` map sanity — every key in `admin.fields` matches a top-level
- *     schema field name.
+ *  6. `fields` map sanity — every key in `admin.fields` is a dotted,
+ *     index-free schema path resolving to a field declaration (top-level
+ *     name or a path through group/array fields; never through blocks).
  *  7. `defaultSort` sanity — `field` resolves to a top-level schema field
  *     or a document-level column (`createdAt` / `updatedAt` / `path`), the
  *     direction (when given) is `asc` | `desc`, and the option is rejected
@@ -52,9 +108,11 @@ export function validateAdminConfigs(admins, collections) {
  *     `type: 'blocks'` field across the registered collections (blocks have
  *     no global registry; the collections walk is the source of truth).
  *  2. Uniqueness — no two entries share a `blockType`.
- *  3. `fields` map sanity — every key matches a top-level field name of the
- *     block (when the same `blockType` appears in several collections, the
- *     union of their top-level field names is accepted).
+ *  3. `fields` map sanity — every key is a dotted, index-free schema path
+ *     resolving to a field declaration of the block (top-level name or a
+ *     path through group/array fields; never through a nested blocks field).
+ *     When the same `blockType` appears in several collections, a key is
+ *     accepted if it resolves in any declaration site (union semantics).
  *
  * Throws a plain `Error` for the same reason `validateAdminConfigs` does —
  * this runs at startup, before the logger is necessarily wired up.
@@ -62,19 +120,18 @@ export function validateAdminConfigs(admins, collections) {
 export function validateBlockAdminConfigs(blockAdmins, collections) {
     if (blockAdmins == null || blockAdmins.length === 0)
         return;
-    // Collect blockType → union of top-level field names across every
-    // declaration site (including blocks nested inside groups/arrays/blocks).
-    const blockFieldNames = new Map();
+    // Collect blockType → declaration sites across every registered collection
+    // (including blocks nested inside groups/arrays/blocks). Structural drift
+    // between same-blockType declarations is possible, so keys validate against
+    // the union of sites.
+    const blocksByType = new Map();
     const walkBlock = (block) => {
-        let names = blockFieldNames.get(block.blockType);
-        if (names == null) {
-            names = new Set();
-            blockFieldNames.set(block.blockType, names);
-        }
-        for (const field of block.fields) {
-            if ('name' in field)
-                names.add(field.name);
+        let sites = blocksByType.get(block.blockType);
+        if (sites == null) {
+            sites = [];
+            blocksByType.set(block.blockType, sites);
         }
+        sites.push(block);
         walkFields(block.fields);
     };
     const walkFields = (fields) => {
@@ -99,17 +156,28 @@ export function validateBlockAdminConfigs(blockAdmins, collections) {
         }
         seen.add(entry.blockType);
         // Rule 1 — block pairing.
-        const names = blockFieldNames.get(entry.blockType);
-        if (names == null) {
+        const sites = blocksByType.get(entry.blockType);
+        if (sites == null) {
             throw new Error(`Block admin config "${entry.blockType}" has no matching block (no \`type: 'blocks'\` field of any registered collection declares a block with \`blockType: '${entry.blockType}'\`).`);
         }
-        // Rule 3 — `fields` keys must be top-level field names of the block.
+        // Rule 3 — `fields` keys must be schema paths resolving within the block
+        // (union across declaration sites). 'blocks' beats 'unresolved' in the
+        // union so the traversal error surfaces when any site has the nested
+        // blocks field the key tried to walk through.
         if (entry.fields != null) {
-            for (const key of Object.keys(entry.fields)) {
-                if (!names.has(key)) {
-                    throw new Error(`Block "${entry.blockType}": \`fields["${key}"]\` references a name that is not a top-level field of the block. Per-field overrides apply only to the block's top-level fields.`);
+            validateFieldAdminKeys(Object.keys(entry.fields), (key) => {
+                let best = 'unresolved';
+                for (const block of sites) {
+                    const resolution = resolveSchemaPath(block.fields, key);
+                    if (resolution === 'ok')
+                        return 'ok';
+                    if (resolution === 'blocks')
+                        best = 'blocks';
                 }
-            }
+                return best;
+            }, (msg) => {
+                throw new Error(`Block "${entry.blockType}": ${msg}`);
+            });
         }
     }
 }
@@ -272,13 +340,10 @@ function validateOne(admin, collectionsByPath) {
             }
         }
     }
-    // Rule 6 — `fields` map keys must match top-level schema field names.
+    // Rule 6 — `fields` map keys must be schema paths resolving to a field
+    // declaration of the collection.
     if (admin.fields != null) {
-        for (const key of Object.keys(admin.fields)) {
-            if (!topLevelFieldNames.has(key)) {
-                fail(`\`fields["${key}"]\` references a name that is not a top-level schema field. Per-field overrides apply only to top-level schema fields.`);
-            }
-        }
+        validateFieldAdminKeys(Object.keys(admin.fields), (key) => resolveSchemaPath(collection.fields, key), fail);
     }
     // Rule 2 + 3 — layout: name resolution + bookkeeping (every schema field
     // placed exactly once). Skipped when no `layout` is declared (the

package/dist/config/validate-admin-configs.test.node.js

@@ -199,7 +199,63 @@ describe('validateAdminConfigs', () => {
             ...baseAdmin,
             fields: { nonexistent: {} },
         };
-        expect(() => validateAdminConfigs([admin], [collection])).toThrow(/not a top-level schema field/);
+        expect(() => validateAdminConfigs([admin], [collection])).toThrow(/does not resolve to a field declaration/);
+    });
+    // Rule 6 — dotted schema-path keys. A dedicated collection with nested
+    // structure: files (array) → filesGroup (group) → leaf fields, plus a
+    // blocks field to prove traversal through blocks is rejected.
+    const nestedCollection = {
+        path: 'library',
+        labels: { singular: 'Item', plural: 'Items' },
+        useAsPath: 'title',
+        fields: [
+            { name: 'title', label: 'Title', type: 'text' },
+            {
+                name: 'files',
+                label: 'Files',
+                type: 'array',
+                fields: [
+                    {
+                        name: 'filesGroup',
+                        type: 'group',
+                        fields: [
+                            { name: 'publicationFile', label: 'File', type: 'file' },
+                            { name: 'notes', label: 'Notes', type: 'richText' },
+                        ],
+                    },
+                ],
+            },
+            {
+                name: 'sections',
+                label: 'Sections',
+                type: 'blocks',
+                blocks: [
+                    {
+                        blockType: 'proseBlock',
+                        fields: [{ name: 'body', label: 'Body', type: 'richText' }],
+                    },
+                ],
+            },
+        ],
+    };
+    const nestedAdmin = (fields) => ({
+        slug: 'library',
+        fields: fields,
+    });
+    it('accepts a dotted fields key through array and group declarations', () => {
+        expect(() => validateAdminConfigs([nestedAdmin({ 'files.filesGroup.notes': {} })], [nestedCollection])).not.toThrow();
+    });
+    it('rejects a dotted fields key whose leaf does not exist', () => {
+        expect(() => validateAdminConfigs([nestedAdmin({ 'files.filesGroup.missing': {} })], [nestedCollection])).toThrow(/does not resolve to a field declaration/);
+    });
+    it('rejects a dotted fields key that walks through a value field', () => {
+        expect(() => validateAdminConfigs([nestedAdmin({ 'title.anything': {} })], [nestedCollection])).toThrow(/does not resolve to a field declaration/);
+    });
+    it('rejects a fields key carrying an item index', () => {
+        expect(() => validateAdminConfigs([nestedAdmin({ 'files[0].filesGroup.notes': {} })], [nestedCollection])).toThrow(/index-free schema paths/);
+    });
+    it('rejects a fields key that traverses a blocks field', () => {
+        expect(() => validateAdminConfigs([nestedAdmin({ 'sections.body': {} })], [nestedCollection])).toThrow(/blockAdmin/);
     });
     // Rule 7 — defaultSort sanity.
     it('accepts a defaultSort on a schema field', () => {
@@ -345,8 +401,42 @@ describe('validateBlockAdminConfigs', () => {
         expect(() => validateBlockAdminConfigs([{ blockType: 'quoteBlock' }, { blockType: 'quoteBlock' }], [blockCollection])).toThrow(/registered more than once/);
     });
     // Rule 3 — fields map sanity.
-    it('rejects a fields key that is not a top-level field of the block', () => {
-        expect(() => validateBlockAdminConfigs([{ blockType: 'quoteBlock', fields: { doesNotExist: {} } }], [blockCollection])).toThrow(/not a top-level field of the block/);
+    it('rejects a fields key that is not a field of the block', () => {
+        expect(() => validateBlockAdminConfigs([{ blockType: 'quoteBlock', fields: { doesNotExist: {} } }], [blockCollection])).toThrow(/does not resolve to a field declaration/);
+    });
+    // Rule 3 — dotted schema-path keys inside a block (array-in-block, the
+    // FAQBlock shape).
+    const faqBlock = {
+        blockType: 'faqBlock',
+        fields: [
+            {
+                name: 'faq',
+                label: 'Questions',
+                type: 'array',
+                fields: [
+                    { name: 'question', label: 'Question', type: 'text' },
+                    { name: 'answer', label: 'Answer', type: 'richText' },
+                ],
+            },
+        ],
+    };
+    const faqCollection = {
+        path: 'docs',
+        labels: { singular: 'Doc', plural: 'Docs' },
+        useAsPath: 'title',
+        fields: [
+            { name: 'title', label: 'Title', type: 'text' },
+            { name: 'content', label: 'Content', type: 'blocks', blocks: [faqBlock] },
+        ],
+    };
+    it('accepts a dotted fields key addressing a field inside an array in the block', () => {
+        expect(() => validateBlockAdminConfigs([{ blockType: 'faqBlock', fields: { 'faq.answer': {} } }], [faqCollection])).not.toThrow();
+    });
+    it('rejects a dotted fields key whose leaf is not declared in the block', () => {
+        expect(() => validateBlockAdminConfigs([{ blockType: 'faqBlock', fields: { 'faq.missing': {} } }], [faqCollection])).toThrow(/does not resolve to a field declaration/);
+    });
+    it('rejects a block fields key carrying an item index', () => {
+        expect(() => validateBlockAdminConfigs([{ blockType: 'faqBlock', fields: { 'faq[0].answer': {} } }], [faqCollection])).toThrow(/index-free schema paths/);
     });
     it('accepts the union of field names when a blockType appears in several collections', () => {
         const other = {

package/dist/schemas/zod/builder.js

@@ -48,9 +48,33 @@ const _applyDateTimeValidation = (schema, _field) => {
 export const fieldToZodSchema = (field, strict = true) => {
     let schema;
     switch (field.type) {
-        case 'array':
-            schema = z.any().array();
+        case 'array': {
+            // Homogeneous item objects built by recursing into the array's child
+            // fields — the item shape mirrors `createFieldsSchema` one level down,
+            // so requiredness and per-type validation apply inside items exactly
+            // as they do at the top level (threading `strict` keeps reads lenient
+            // for schema-evolved documents). `_id` is the synthetic item identity
+            // (assigned client-side on add, persisted via store_meta) — always
+            // accepted, never required. `.passthrough()` tolerates auxiliary keys
+            // (e.g. legacy seed-data `id` aliases) instead of stripping them.
+            // Group children stay `z.any()` via the `group` case below — the same
+            // depth boundary top-level groups have.
+            const itemShape = {
+                _id: z.string().optional(),
+            };
+            for (const child of field.fields ?? []) {
+                itemShape[child.name] = fieldToZodSchema(child, strict);
+            }
+            let arraySchema = z.array(z.object(itemShape).passthrough());
+            if (field.validation?.minLength != null) {
+                arraySchema = arraySchema.min(field.validation.minLength);
+            }
+            if (field.validation?.maxLength != null) {
+                arraySchema = arraySchema.max(field.validation.maxLength);
+            }
+            schema = arraySchema;
             break;
+        }
         case 'text': {
             let textSchema = z.string();
             textSchema = applyTextValidation(textSchema, field);

package/dist/schemas/zod/builder.test.node.js

@@ -47,3 +47,75 @@ describe('collection Zod schemas', () => {
         expect(result.success).toBe(false);
     });
 });
+// Array items recurse into the child field schemas (the FAQBlock shape:
+// multiple direct value fields per item, plus an optional group child that
+// stays permissive — the same depth boundary top-level groups have).
+const Faqs = defineCollection({
+    path: 'faqs',
+    labels: { singular: 'FAQ', plural: 'FAQs' },
+    fields: [
+        { name: 'title', type: 'text' },
+        {
+            name: 'faq',
+            type: 'array',
+            validation: { minLength: 1 },
+            fields: [
+                { name: 'question', type: 'text' },
+                { name: 'answer', type: 'richText', optional: true },
+                {
+                    name: 'meta',
+                    type: 'group',
+                    optional: true,
+                    fields: [{ name: 'anchor', type: 'text' }],
+                },
+            ],
+        },
+    ],
+});
+const faqItem = { question: 'What is Byline?', answer: { root: {} } };
+describe('array item schemas', () => {
+    const schemas = createCollectionSchemas(Faqs);
+    it('accepts complete items, with or without the synthetic _id', () => {
+        const result = schemas.fields.safeParse({
+            title: 'FAQ page',
+            faq: [faqItem, { ...faqItem, _id: '0198c0de-0000-7000-8000-000000000001' }],
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects an item missing a required child field in the strict schema', () => {
+        const result = schemas.fields.safeParse({
+            title: 'FAQ page',
+            faq: [{ answer: { root: {} } }],
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects a wrongly typed child value in the strict schema', () => {
+        const result = schemas.fields.safeParse({
+            title: 'FAQ page',
+            faq: [{ ...faqItem, question: 42 }],
+        });
+        expect(result.success).toBe(false);
+    });
+    it('enforces the array-level minLength bound', () => {
+        const result = schemas.fields.safeParse({ title: 'FAQ page', faq: [] });
+        expect(result.success).toBe(false);
+    });
+    it('leaves group children permissive inside items', () => {
+        const result = schemas.fields.safeParse({
+            title: 'FAQ page',
+            faq: [{ ...faqItem, meta: { anything: true } }],
+        });
+        expect(result.success).toBe(true);
+    });
+    it('keeps reads lenient — items with missing children still parse in the get schema', () => {
+        const parsed = schemas.get.parse({
+            id: '550e8400-e29b-41d4-a716-446655440000',
+            status: 'draft',
+            createdAt: '2026-07-15T12:00:00.000Z',
+            updatedAt: '2026-07-15T12:00:00.000Z',
+            // A schema-evolved document: item pre-dates the `question` field.
+            fields: { title: 'FAQ page', faq: [{ _id: 'abc', answer: null }] },
+        });
+        expect(parsed.fields.faq).toHaveLength(1);
+    });
+});

package/dist/storage/collection-fingerprint.test.node.js

@@ -152,10 +152,7 @@ describe('fingerprintCollection', () => {
         rel.hasMany = true;
         expect(await fingerprintCollection(b)).not.toBe(a);
     });
-    it.each([
-        'minItems',
-        'maxItems',
-    ])('changes when relation %s changes', async (constraint) => {
+    it.each(['minItems', 'maxItems'])('changes when relation %s changes', async (constraint) => {
         const a = baseCollection();
         const aRel = a.fields.find((f) => f.name === 'category');
         aRel.hasMany = true;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/core",
   "private": false,
   "license": "MPL-2.0",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -81,16 +81,16 @@
     "pino": "^10.3.1",
     "sharp": "^0.35.3",
     "zod": "^4.4.3",
-    "@byline/auth": "4.2.0"
+    "@byline/auth": "4.3.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.2",
-    "@types/node": "^26.1.0",
+    "@biomejs/biome": "2.5.4",
+    "@types/node": "^26.1.1",
     "chokidar": "^5.0.0",
     "chokidar-cli": "^3.0.0",
     "npm-run-all": "^4.1.5",
-    "tsc-alias": "^1.9.0",
-    "tsx": "^4.23.0",
+    "tsc-alias": "^1.9.1",
+    "tsx": "^4.23.1",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },