@byline/core 3.17.0 → 3.18.0

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

@@ -141,9 +141,9 @@ export interface UploadConfig {
  *
  *   `[draft, ...customStatuses, published, archived]`
  */
-export declare const WORKFLOW_STATUS_DRAFT: "draft";
-export declare const WORKFLOW_STATUS_PUBLISHED: "published";
-export declare const WORKFLOW_STATUS_ARCHIVED: "archived";
+export declare const WORKFLOW_STATUS_DRAFT: 'draft';
+export declare const WORKFLOW_STATUS_PUBLISHED: 'published';
+export declare const WORKFLOW_STATUS_ARCHIVED: 'archived';
 export declare const REQUIRED_WORKFLOW_STATUSES: readonly ["draft", "published", "archived"];
 export type RequiredWorkflowStatusName = (typeof REQUIRED_WORKFLOW_STATUSES)[number];
 /**

package/dist/@types/site-config.d.ts

@@ -144,6 +144,24 @@ export type TranslationBundleShape = Readonly<{
 export interface ClientConfig extends BaseConfig {
     /** Admin UI configuration for collections (client-side only). */
     admin?: CollectionAdminConfig[];
+    /**
+     * Installation-wide slugifier — the **client-side** copy, used by the
+     * admin path-widget to render the live `path` preview (create-mode
+     * placeholder and the "Regenerate" target) as the editor types.
+     *
+     * Must be the *same* pure, synchronous function registered on
+     * `ServerConfig.slugifier`: the server derivation is authoritative, and a
+     * divergent client copy would show a preview that disagrees with what is
+     * persisted (and could let "Regenerate" overwrite a correct path). Falls
+     * back to the default `slugify` from `@byline/core` when not set — so
+     * installations that keep the default slugifier need not set this at all.
+     *
+     * Lives on `ClientConfig` rather than `BaseConfig` because it is a function
+     * (not serialisable), and `BaseConfig` is contractually serialisable.
+     *
+     * @see ServerConfig.slugifier
+     */
+    slugifier?: SlugifierFn;
     /**
      * Site-wide field-level UI defaults. Currently surfaces the richtext
      * editor adapter slot — additional field-level defaults (custom
@@ -214,6 +232,11 @@ export interface ServerConfig<TAdminStore = unknown> extends BaseConfig {
      * Falls back to the default `slugify` from `@byline/core` when not set.
      * Must be pure and synchronous — it runs server-side at write time and
      * client-side for live form preview, and the two must agree on output.
+     *
+     * This is the **server-side** copy (the authoritative one — its output is
+     * what gets persisted). For the admin path-widget's live preview to match,
+     * register the *same* function on `ClientConfig.slugifier` via
+     * `defineClientConfig`. See {@link ClientConfig.slugifier}.
      */
     slugifier?: SlugifierFn;
     /**

package/dist/auth/register-collection-abilities.d.ts

@@ -36,7 +36,7 @@ import type { CollectionDefinition } from '../@types/index.js';
  */
 export declare function registerCollectionAbilities(registry: AbilityRegistry, definition: CollectionDefinition): void;
 /** The ability suffixes that every collection contributes. Exposed for contract tests. */
-export declare const COLLECTION_ABILITY_VERBS: readonly ["read", "create", "update", "delete", "publish", "changeStatus", "reindex"];
+export declare const COLLECTION_ABILITY_VERBS: readonly ['read', 'create', 'update', 'delete', 'publish', 'changeStatus', 'reindex'];
 export type CollectionAbilityVerb = (typeof COLLECTION_ABILITY_VERBS)[number];
 /** Compute the full ability key for a collection path and verb. */
 export declare function collectionAbilityKey(path: string, verb: CollectionAbilityVerb): string;

package/dist/config/config.js

@@ -90,6 +90,10 @@ export function getClientConfig() {
             routes: serverConfig.routes,
             collections: serverConfig.collections,
             admin: [],
+            // Carry the slugifier through the SSR fallback so a form rendered
+            // server-side derives the same path preview as the hydrated client
+            // (both configs are meant to register the same function).
+            slugifier: serverConfig.slugifier,
         };
     }
     throw new Error('Byline has not been configured yet. Please call defineClientConfig in byline.config.ts first.');

package/dist/config/validate-collections.d.ts

@@ -23,7 +23,8 @@ export declare const RESERVED_FIELD_NAMES: ReadonlySet<string>;
  *    into derived paths via `useAsPath`.
  *  - When `useAsPath` is set, the referenced field must exist at the
  *    top level of the collection and be of a type the slugifier can
- *    sensibly consume (text-like or date-like).
+ *    sensibly consume (text-like, date-like, or a numeric identity
+ *    field — `integer` / `counter`).
  *  - No field may be named `availableLocales`; collections opt into the
  *    editorial available-locales control via `advertiseLocales: true`.
  *  - When `advertiseLocales` is `true`, the collection must have at least

package/dist/config/validate-collections.js

@@ -28,6 +28,14 @@ const USE_AS_PATH_SOURCE_TYPES = new Set([
     'date',
     'datetime',
     'time',
+    // Numeric identity fields. `derivePath` stringifies the value before
+    // slugifying, so an integer or an allocator-assigned `counter` becomes a
+    // clean numeric slug (e.g. `1`, `42`). A replacement slugifier can branch
+    // on `collectionPath` to reshape it further — e.g. zero-padding a serial
+    // number to a fixed width. `float` / `decimal` are deliberately excluded:
+    // their string form carries a `.` which does not belong in a path segment.
+    'integer',
+    'counter',
 ]);
 /**
  * True when any field in the tree (at any nesting depth) is `localized`.
@@ -65,7 +73,8 @@ function walkFields(fields, visit) {
  *    into derived paths via `useAsPath`.
  *  - When `useAsPath` is set, the referenced field must exist at the
  *    top level of the collection and be of a type the slugifier can
- *    sensibly consume (text-like or date-like).
+ *    sensibly consume (text-like, date-like, or a numeric identity
+ *    field — `integer` / `counter`).
  *  - No field may be named `availableLocales`; collections opt into the
  *    editorial available-locales control via `advertiseLocales: true`.
  *  - When `advertiseLocales` is `true`, the collection must have at least

package/dist/config/validate-collections.test.node.js

@@ -87,6 +87,28 @@ describe('validateCollections', () => {
         };
         expect(() => validateCollections([collection])).not.toThrow();
     });
+    it('accepts useAsPath pointing at a counter field', () => {
+        const collection = {
+            ...baseCollection,
+            fields: [
+                { name: 'title', label: 'Title', type: 'text' },
+                { name: 'serialNumber', label: 'Serial Number', type: 'counter', group: 'serials' },
+            ],
+            useAsPath: 'serialNumber',
+        };
+        expect(() => validateCollections([collection])).not.toThrow();
+    });
+    it('accepts useAsPath pointing at an integer field', () => {
+        const collection = {
+            ...baseCollection,
+            fields: [
+                { name: 'title', label: 'Title', type: 'text' },
+                { name: 'issue', label: 'Issue', type: 'integer' },
+            ],
+            useAsPath: 'issue',
+        };
+        expect(() => validateCollections([collection])).not.toThrow();
+    });
     // useAsPath deliberately resolves against top-level fields only. A
     // nested source (inside a group, array, or block) isn't addressable
     // in the derivation cascade — path is a singular identity anchor, not

package/dist/lib/errors.d.ts

@@ -76,17 +76,17 @@ export declare class BylineError extends Error {
  */
 export declare const createErrorType: (code: string, logLevel?: LogLevel) => (opts: BylineErrorOptions, errorConstructor?: any) => BylineError;
 export declare const ErrorCodes: {
-    readonly UNHANDLED: "ERR_UNHANDLED";
-    readonly NOT_FOUND: "ERR_NOT_FOUND";
-    readonly CONFLICT: "ERR_CONFLICT";
-    readonly VALIDATION: "ERR_VALIDATION";
-    readonly INVALID_TRANSITION: "ERR_INVALID_TRANSITION";
-    readonly PATCH_FAILED: "ERR_PATCH_FAILED";
-    readonly DATABASE: "ERR_DATABASE";
-    readonly STORAGE: "ERR_STORAGE";
-    readonly READ_BUDGET_EXCEEDED: "ERR_READ_BUDGET_EXCEEDED";
-    readonly PATH_CONFLICT: "ERR_PATH_CONFLICT";
-    readonly AUDIT_UNSUPPORTED: "ERR_AUDIT_UNSUPPORTED";
+    readonly UNHANDLED: 'ERR_UNHANDLED';
+    readonly NOT_FOUND: 'ERR_NOT_FOUND';
+    readonly CONFLICT: 'ERR_CONFLICT';
+    readonly VALIDATION: 'ERR_VALIDATION';
+    readonly INVALID_TRANSITION: 'ERR_INVALID_TRANSITION';
+    readonly PATCH_FAILED: 'ERR_PATCH_FAILED';
+    readonly DATABASE: 'ERR_DATABASE';
+    readonly STORAGE: 'ERR_STORAGE';
+    readonly READ_BUDGET_EXCEEDED: 'ERR_READ_BUDGET_EXCEEDED';
+    readonly PATH_CONFLICT: 'ERR_PATH_CONFLICT';
+    readonly AUDIT_UNSUPPORTED: 'ERR_AUDIT_UNSUPPORTED';
 };
 export declare const ERR_UNHANDLED: (opts: BylineErrorOptions, errorConstructor?: any) => BylineError;
 export declare const ERR_NOT_FOUND: (opts: BylineErrorOptions, errorConstructor?: any) => BylineError;

package/dist/patches/apply-patches.js

@@ -46,7 +46,7 @@ export function resolveFieldForPath(definition, path) {
     if (segments.length === 0)
         return null;
     const [first, ...rest] = segments;
-    if (!first || first.kind !== 'field')
+    if (first?.kind !== 'field')
         return null;
     let current = definition.fields.find((f) => f.name === first.key);
     if (!current)

package/dist/schemas/zod/builder.d.ts

@@ -53,9 +53,6 @@ export declare const createCollectionSchemasForPath: (path: string) => {
         [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
     }, z.core.$strip>;
     full: z.ZodObject<{
-        fields: z.ZodObject<{
-            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-        }, z.core.$strip>;
         id: z.ZodUUID;
         versionId: z.ZodOptional<z.ZodUUID>;
         path: z.ZodOptional<z.ZodString>;
@@ -68,12 +65,12 @@ export declare const createCollectionSchemasForPath: (path: string) => {
         updatedAt: z.ZodISODateTime;
         createdBy: z.ZodOptional<z.ZodUUID>;
         eventType: z.ZodOptional<z.ZodString>;
+        fields: z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>;
     }, z.core.$strip>;
     list: z.ZodObject<{
         docs: z.ZodArray<z.ZodObject<{
-            fields: z.ZodObject<{
-                [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-            }, z.core.$strip>;
             id: z.ZodUUID;
             versionId: z.ZodOptional<z.ZodUUID>;
             path: z.ZodOptional<z.ZodString>;
@@ -86,6 +83,9 @@ export declare const createCollectionSchemasForPath: (path: string) => {
             updatedAt: z.ZodISODateTime;
             createdBy: z.ZodOptional<z.ZodUUID>;
             eventType: z.ZodOptional<z.ZodString>;
+            fields: z.ZodObject<{
+                [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+            }, z.core.$strip>;
         }, z.core.$strip>>;
         meta: z.ZodObject<{
             page: z.ZodNumber;
@@ -108,9 +108,6 @@ export declare const createCollectionSchemasForPath: (path: string) => {
     }, z.core.$strip>;
     history: z.ZodObject<{
         docs: z.ZodArray<z.ZodObject<{
-            fields: z.ZodObject<{
-                [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-            }, z.core.$strip>;
             id: z.ZodUUID;
             versionId: z.ZodOptional<z.ZodUUID>;
             path: z.ZodOptional<z.ZodString>;
@@ -123,6 +120,9 @@ export declare const createCollectionSchemasForPath: (path: string) => {
             updatedAt: z.ZodISODateTime;
             createdBy: z.ZodOptional<z.ZodUUID>;
             eventType: z.ZodOptional<z.ZodString>;
+            fields: z.ZodObject<{
+                [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+            }, z.core.$strip>;
         }, z.core.$strip>>;
         meta: z.ZodObject<{
             page: z.ZodNumber;
@@ -137,9 +137,6 @@ export declare const createCollectionSchemasForPath: (path: string) => {
         [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
     }, z.core.$strip>;
     get: z.ZodObject<{
-        fields: z.ZodObject<{
-            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-        }, z.core.$strip>;
         id: z.ZodUUID;
         versionId: z.ZodOptional<z.ZodUUID>;
         path: z.ZodOptional<z.ZodString>;
@@ -152,6 +149,9 @@ export declare const createCollectionSchemasForPath: (path: string) => {
         updatedAt: z.ZodISODateTime;
         createdBy: z.ZodOptional<z.ZodUUID>;
         eventType: z.ZodOptional<z.ZodString>;
+        fields: z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>;
     }, z.core.$strip>;
     update: z.ZodObject<{
         [x: string]: z.ZodOptional<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
@@ -176,93 +176,6 @@ export declare const createCollectionSchemas: (collection: CollectionDefinition)
         [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
     }, z.core.$strip>;
     full: z.ZodObject<{
-        fields: z.ZodObject<{
-            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-        }, z.core.$strip>;
-        id: z.ZodUUID;
-        versionId: z.ZodOptional<z.ZodUUID>;
-        path: z.ZodOptional<z.ZodString>;
-        sourceLocale: z.ZodOptional<z.ZodString>;
-        status: z.ZodEnum<{
-            [x: string]: string;
-        }>;
-        hasPublishedVersion: z.ZodOptional<z.ZodBoolean>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        createdBy: z.ZodOptional<z.ZodUUID>;
-        eventType: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    list: z.ZodObject<{
-        docs: z.ZodArray<z.ZodObject<{
-            fields: z.ZodObject<{
-                [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-            }, z.core.$strip>;
-            id: z.ZodUUID;
-            versionId: z.ZodOptional<z.ZodUUID>;
-            path: z.ZodOptional<z.ZodString>;
-            sourceLocale: z.ZodOptional<z.ZodString>;
-            status: z.ZodEnum<{
-                [x: string]: string;
-            }>;
-            hasPublishedVersion: z.ZodOptional<z.ZodBoolean>;
-            createdAt: z.ZodISODateTime;
-            updatedAt: z.ZodISODateTime;
-            createdBy: z.ZodOptional<z.ZodUUID>;
-            eventType: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        meta: z.ZodObject<{
-            page: z.ZodNumber;
-            pageSize: z.ZodNumber;
-            total: z.ZodNumber;
-            totalPages: z.ZodNumber;
-            order: z.ZodOptional<z.ZodString>;
-            desc: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>;
-        included: z.ZodObject<{
-            collection: z.ZodObject<{
-                id: z.ZodString;
-                labels: z.ZodObject<{
-                    singular: z.ZodString;
-                    plural: z.ZodString;
-                }, z.core.$strip>;
-                path: z.ZodLiteral<string>;
-            }, z.core.$strip>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    history: z.ZodObject<{
-        docs: z.ZodArray<z.ZodObject<{
-            fields: z.ZodObject<{
-                [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-            }, z.core.$strip>;
-            id: z.ZodUUID;
-            versionId: z.ZodOptional<z.ZodUUID>;
-            path: z.ZodOptional<z.ZodString>;
-            sourceLocale: z.ZodOptional<z.ZodString>;
-            status: z.ZodEnum<{
-                [x: string]: string;
-            }>;
-            hasPublishedVersion: z.ZodOptional<z.ZodBoolean>;
-            createdAt: z.ZodISODateTime;
-            updatedAt: z.ZodISODateTime;
-            createdBy: z.ZodOptional<z.ZodUUID>;
-            eventType: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        meta: z.ZodObject<{
-            page: z.ZodNumber;
-            pageSize: z.ZodNumber;
-            total: z.ZodNumber;
-            totalPages: z.ZodNumber;
-            order: z.ZodOptional<z.ZodString>;
-            desc: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    create: z.ZodObject<{
-        [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-    }, z.core.$strip>;
-    get: z.ZodObject<{
-        fields: z.ZodObject<{
-            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-        }, z.core.$strip>;
         id: z.ZodUUID;
         versionId: z.ZodOptional<z.ZodUUID>;
         path: z.ZodOptional<z.ZodString>;
@@ -275,88 +188,12 @@ export declare const createCollectionSchemas: (collection: CollectionDefinition)
         updatedAt: z.ZodISODateTime;
         createdBy: z.ZodOptional<z.ZodUUID>;
         eventType: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    update: z.ZodObject<{
-        [x: string]: z.ZodOptional<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
-    }, z.core.$strip>;
-};
-export declare const createTypedCollectionSchemas: (collection: CollectionDefinition) => {
-    base: z.ZodObject<{
-        id: z.ZodUUID;
-        versionId: z.ZodOptional<z.ZodUUID>;
-        path: z.ZodOptional<z.ZodString>;
-        sourceLocale: z.ZodOptional<z.ZodString>;
-        status: z.ZodEnum<{
-            [x: string]: string;
-        }>;
-        hasPublishedVersion: z.ZodOptional<z.ZodBoolean>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        createdBy: z.ZodOptional<z.ZodUUID>;
-        eventType: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    fields: z.ZodObject<{
-        [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-    }, z.core.$strip>;
-    full: z.ZodObject<{
         fields: z.ZodObject<{
             [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
         }, z.core.$strip>;
-        id: z.ZodUUID;
-        versionId: z.ZodOptional<z.ZodUUID>;
-        path: z.ZodOptional<z.ZodString>;
-        sourceLocale: z.ZodOptional<z.ZodString>;
-        status: z.ZodEnum<{
-            [x: string]: string;
-        }>;
-        hasPublishedVersion: z.ZodOptional<z.ZodBoolean>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        createdBy: z.ZodOptional<z.ZodUUID>;
-        eventType: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     list: z.ZodObject<{
         docs: z.ZodArray<z.ZodObject<{
-            fields: z.ZodObject<{
-                [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-            }, z.core.$strip>;
-            id: z.ZodUUID;
-            versionId: z.ZodOptional<z.ZodUUID>;
-            path: z.ZodOptional<z.ZodString>;
-            sourceLocale: z.ZodOptional<z.ZodString>;
-            status: z.ZodEnum<{
-                [x: string]: string;
-            }>;
-            hasPublishedVersion: z.ZodOptional<z.ZodBoolean>;
-            createdAt: z.ZodISODateTime;
-            updatedAt: z.ZodISODateTime;
-            createdBy: z.ZodOptional<z.ZodUUID>;
-            eventType: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        meta: z.ZodObject<{
-            page: z.ZodNumber;
-            pageSize: z.ZodNumber;
-            total: z.ZodNumber;
-            totalPages: z.ZodNumber;
-            order: z.ZodOptional<z.ZodString>;
-            desc: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>;
-        included: z.ZodObject<{
-            collection: z.ZodObject<{
-                id: z.ZodString;
-                labels: z.ZodObject<{
-                    singular: z.ZodString;
-                    plural: z.ZodString;
-                }, z.core.$strip>;
-                path: z.ZodLiteral<string>;
-            }, z.core.$strip>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    history: z.ZodObject<{
-        docs: z.ZodArray<z.ZodObject<{
-            fields: z.ZodObject<{
-                [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-            }, z.core.$strip>;
             id: z.ZodUUID;
             versionId: z.ZodOptional<z.ZodUUID>;
             path: z.ZodOptional<z.ZodString>;
@@ -369,92 +206,9 @@ export declare const createTypedCollectionSchemas: (collection: CollectionDefini
             updatedAt: z.ZodISODateTime;
             createdBy: z.ZodOptional<z.ZodUUID>;
             eventType: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        meta: z.ZodObject<{
-            page: z.ZodNumber;
-            pageSize: z.ZodNumber;
-            total: z.ZodNumber;
-            totalPages: z.ZodNumber;
-            order: z.ZodOptional<z.ZodString>;
-            desc: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    create: z.ZodObject<{
-        [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-    }, z.core.$strip>;
-    get: z.ZodObject<{
-        fields: z.ZodObject<{
-            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-        }, z.core.$strip>;
-        id: z.ZodUUID;
-        versionId: z.ZodOptional<z.ZodUUID>;
-        path: z.ZodOptional<z.ZodString>;
-        sourceLocale: z.ZodOptional<z.ZodString>;
-        status: z.ZodEnum<{
-            [x: string]: string;
-        }>;
-        hasPublishedVersion: z.ZodOptional<z.ZodBoolean>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        createdBy: z.ZodOptional<z.ZodUUID>;
-        eventType: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    update: z.ZodObject<{
-        [x: string]: z.ZodOptional<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
-    }, z.core.$strip>;
-};
-export declare const createTypedCollectionSchemasForPath: (path: string) => {
-    base: z.ZodObject<{
-        id: z.ZodUUID;
-        versionId: z.ZodOptional<z.ZodUUID>;
-        path: z.ZodOptional<z.ZodString>;
-        sourceLocale: z.ZodOptional<z.ZodString>;
-        status: z.ZodEnum<{
-            [x: string]: string;
-        }>;
-        hasPublishedVersion: z.ZodOptional<z.ZodBoolean>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        createdBy: z.ZodOptional<z.ZodUUID>;
-        eventType: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    fields: z.ZodObject<{
-        [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-    }, z.core.$strip>;
-    full: z.ZodObject<{
-        fields: z.ZodObject<{
-            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-        }, z.core.$strip>;
-        id: z.ZodUUID;
-        versionId: z.ZodOptional<z.ZodUUID>;
-        path: z.ZodOptional<z.ZodString>;
-        sourceLocale: z.ZodOptional<z.ZodString>;
-        status: z.ZodEnum<{
-            [x: string]: string;
-        }>;
-        hasPublishedVersion: z.ZodOptional<z.ZodBoolean>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        createdBy: z.ZodOptional<z.ZodUUID>;
-        eventType: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    list: z.ZodObject<{
-        docs: z.ZodArray<z.ZodObject<{
             fields: z.ZodObject<{
                 [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
             }, z.core.$strip>;
-            id: z.ZodUUID;
-            versionId: z.ZodOptional<z.ZodUUID>;
-            path: z.ZodOptional<z.ZodString>;
-            sourceLocale: z.ZodOptional<z.ZodString>;
-            status: z.ZodEnum<{
-                [x: string]: string;
-            }>;
-            hasPublishedVersion: z.ZodOptional<z.ZodBoolean>;
-            createdAt: z.ZodISODateTime;
-            updatedAt: z.ZodISODateTime;
-            createdBy: z.ZodOptional<z.ZodUUID>;
-            eventType: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         meta: z.ZodObject<{
             page: z.ZodNumber;
@@ -477,9 +231,6 @@ export declare const createTypedCollectionSchemasForPath: (path: string) => {
     }, z.core.$strip>;
     history: z.ZodObject<{
         docs: z.ZodArray<z.ZodObject<{
-            fields: z.ZodObject<{
-                [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-            }, z.core.$strip>;
             id: z.ZodUUID;
             versionId: z.ZodOptional<z.ZodUUID>;
             path: z.ZodOptional<z.ZodString>;
@@ -492,6 +243,9 @@ export declare const createTypedCollectionSchemasForPath: (path: string) => {
             updatedAt: z.ZodISODateTime;
             createdBy: z.ZodOptional<z.ZodUUID>;
             eventType: z.ZodOptional<z.ZodString>;
+            fields: z.ZodObject<{
+                [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+            }, z.core.$strip>;
         }, z.core.$strip>>;
         meta: z.ZodObject<{
             page: z.ZodNumber;
@@ -506,9 +260,6 @@ export declare const createTypedCollectionSchemasForPath: (path: string) => {
         [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
     }, z.core.$strip>;
     get: z.ZodObject<{
-        fields: z.ZodObject<{
-            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-        }, z.core.$strip>;
         id: z.ZodUUID;
         versionId: z.ZodOptional<z.ZodUUID>;
         path: z.ZodOptional<z.ZodString>;
@@ -521,8 +272,13 @@ export declare const createTypedCollectionSchemasForPath: (path: string) => {
         updatedAt: z.ZodISODateTime;
         createdBy: z.ZodOptional<z.ZodUUID>;
         eventType: z.ZodOptional<z.ZodString>;
+        fields: z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>;
     }, z.core.$strip>;
     update: z.ZodObject<{
         [x: string]: z.ZodOptional<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
     }, z.core.$strip>;
 };
+export declare const createTypedCollectionSchemas: typeof createCollectionSchemas;
+export declare const createTypedCollectionSchemasForPath: typeof createCollectionSchemasForPath;

package/dist/schemas/zod/cache.d.ts

@@ -3,8 +3,8 @@ import type { CollectionDefinition } from '../../@types/index.js';
 type TypedSchemaSet = ReturnType<typeof createTypedCollectionSchemas>;
 export declare const getCollectionSchemasForPath: (path: string) => TypedSchemaSet;
 export declare const getCollectionSchemas: (collection: CollectionDefinition) => TypedSchemaSet;
-export declare const getTypedCollectionSchemasForPath: (path: string) => TypedSchemaSet;
-export declare const getTypedCollectionSchemas: (collection: CollectionDefinition) => TypedSchemaSet;
+export declare const getTypedCollectionSchemasForPath: typeof getCollectionSchemasForPath;
+export declare const getTypedCollectionSchemas: typeof getCollectionSchemas;
 export declare const clearSchemaCache: (collectionPath?: string) => void;
 export declare const getCacheStats: () => {
     size: number;

package/dist/services/document-lifecycle/audit.d.ts

@@ -9,10 +9,10 @@ import type { AuditActorRealm, AuditLogAppendInput, IDbAdapter } from '../../@ty
 import type { DocumentLifecycleContext } from './context.js';
 /** Namespaced audit actions for document-grain changes. */
 export declare const AUDIT_ACTIONS: {
-    readonly pathChanged: "document.path.changed";
-    readonly localesChanged: "document.locales.changed";
-    readonly statusChanged: "document.status.changed";
-    readonly deleted: "document.deleted";
+    readonly pathChanged: 'document.path.changed';
+    readonly localesChanged: 'document.locales.changed';
+    readonly statusChanged: 'document.status.changed';
+    readonly deleted: 'document.deleted';
 };
 /**
  * The actor id + realm for an audit-log row. Mirrors `actorId()`: a real

package/dist/services/document-lifecycle/delete.js

@@ -9,7 +9,8 @@ import { resolveHooks } from '../../@types/index.js';
 import { assertActorCanPerform } from '../../auth/assert-actor-can-perform.js';
 import { ERR_NOT_FOUND } from '../../lib/errors.js';
 import { withLogContext } from '../../lib/logger.js';
-import { getUploadFields } from '../../utils/storage-utils.js';
+import { hasUploadField, isUploadField } from '../../utils/storage-utils.js';
+import { walkFieldTree } from '../walk-field-tree.js';
 import { AUDIT_ACTIONS, auditActor, requireAuditCapability } from './audit.js';
 import { invokeHook } from './internals.js';
 import { promoteChildrenAndRemove } from './tree.js';
@@ -46,8 +47,7 @@ export async function deleteDocument(ctx, params) {
         //    AND a storage provider, fetch with reconstruct: true so we
         //    can read the stored file paths (and persisted variant paths)
         //    from the field values before the DB rows are deleted.
-        const uploadFieldNames = getUploadFields(definition).map((f) => f.name);
-        const isUploadCollection = uploadFieldNames.length > 0 && ctx.storage != null;
+        const isUploadCollection = hasUploadField(definition) && ctx.storage != null;
         const latest = await db.queries.documents.getDocumentById({
             collection_id: ctx.collectionId,
             document_id: params.documentId,
@@ -60,21 +60,27 @@ export async function deleteDocument(ctx, params) {
             }).log(ctx.logger);
         }
         // Collect storage paths for every upload-capable field on the doc:
-        // the original file plus every persisted variant. Reading the
+        // the original file plus every persisted variant. The schema/data
+        // walk descends into `group` / `array` / `blocks`, so upload fields
+        // nested in repeating structures are cleaned up too. Reading the
         // variants from the field value (rather than re-deriving from
         // `upload.sizes`) keeps cleanup correct even when the size set
         // changes between upload and delete.
         const storagePathsToDelete = [];
         if (isUploadCollection) {
-            for (const fieldName of uploadFieldNames) {
-                const fieldValue = latest?.fields?.[fieldName];
+            const data = latest?.fields;
+            for (const leaf of walkFieldTree(definition.fields, data)) {
+                if (!isUploadField(leaf.field))
+                    continue;
+                const fieldValue = leaf.value;
                 if (!fieldValue || typeof fieldValue !== 'object')
                     continue;
-                if (typeof fieldValue.storagePath === 'string') {
-                    storagePathsToDelete.push(fieldValue.storagePath);
+                const stored = fieldValue;
+                if (typeof stored.storagePath === 'string') {
+                    storagePathsToDelete.push(stored.storagePath);
                 }
-                if (Array.isArray(fieldValue.variants)) {
-                    for (const variant of fieldValue.variants) {
+                if (Array.isArray(stored.variants)) {
+                    for (const variant of stored.variants) {
                         if (variant && typeof variant.storagePath === 'string') {
                             storagePathsToDelete.push(variant.storagePath);
                         }

package/dist/services/document-lifecycle.test.node.js

@@ -926,6 +926,58 @@ describe('Document lifecycle service', () => {
                 action: 'document.deleted',
             }));
         });
+        it('cleans up stored files for upload fields at any nesting depth', async () => {
+            const { db, getDocumentById } = createMockDb();
+            const upload = { mimeTypes: ['application/pdf'], maxFileSize: 1024 };
+            const definition = {
+                ...minimalCollection,
+                fields: [
+                    { name: 'cover', label: 'Cover', type: 'image', upload },
+                    {
+                        name: 'files',
+                        label: 'Files',
+                        type: 'array',
+                        fields: [
+                            {
+                                name: 'filesGroup',
+                                type: 'group',
+                                fields: [{ name: 'publicationFile', label: 'File', type: 'file', upload }],
+                            },
+                        ],
+                    },
+                ],
+            };
+            getDocumentById.mockResolvedValue({
+                document_version_id: 'ver-1',
+                document_id: 'doc-1',
+                path: 'doc-to-delete',
+                fields: {
+                    cover: {
+                        storagePath: 'covers/original.jpg',
+                        variants: [{ storagePath: 'covers/thumb.avif' }],
+                    },
+                    files: [
+                        { filesGroup: { publicationFile: { storagePath: 'files/a.pdf' } } },
+                        { filesGroup: { publicationFile: null } },
+                        { filesGroup: { publicationFile: { storagePath: 'files/b.pdf' } } },
+                    ],
+                },
+            });
+            const storageDelete = vi.fn().mockResolvedValue(undefined);
+            const ctx = {
+                ...buildCtx(db, definition),
+                storage: { delete: storageDelete },
+            };
+            await deleteDocument(ctx, { documentId: 'doc-1' });
+            // reconstruct: true because the collection is upload-capable
+            expect(getDocumentById).toHaveBeenCalledWith(expect.objectContaining({ reconstruct: true }));
+            expect(storageDelete.mock.calls.map((c) => c[0])).toEqual([
+                'covers/original.jpg',
+                'covers/thumb.avif',
+                'files/a.pdf',
+                'files/b.pdf',
+            ]);
+        });
     });
     // -----------------------------------------------------------------------
     // updateDocumentSystemFields (audited, non-versioned)

package/dist/utils/storage-utils.d.ts

@@ -5,8 +5,8 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
+import { type Field, type FileField, type ImageField } from '../@types/field-types.js';
 import type { CollectionDefinition } from '../@types/collection-types.js';
-import type { Field, FileField, ImageField } from '../@types/field-types.js';
 /**
  * Predicate: does this field carry an `upload` config? True for any
  * `image` / `file` field with an `upload` block declared.
@@ -15,20 +15,21 @@ export declare function isUploadField(field: Field): field is (ImageField | File
     upload: NonNullable<(ImageField | FileField)['upload']>;
 };
 /**
- * Walk the top-level field set and return every upload-capable
- * image/file field on the collection. Used by the delete path,
- * the upload-route resolver, and any UI that needs to reason about
- * "is this collection upload-capable, and which fields take uploads?"
+ * Walk the field set and return every upload-capable image/file field
+ * on the collection, recursing into `group` / `array` / `blocks`
+ * structure fields. Used by the delete path, the upload-route resolver,
+ * and any UI that needs to reason about "is this collection
+ * upload-capable, and which fields take uploads?"
  *
- * Does not recurse into `group` / `array` / `blocks` — the supported
- * transport surface is top-level upload fields. Nested upload fields
- * are reachable through the core upload service via `findUploadField`,
- * but require a richer transport selector.
+ * Field names are the upload transport's selector, so a schema should
+ * not declare two upload fields with the same name in different nesting
+ * scopes — resolvers match by name and take the first hit in
+ * declaration order.
  */
 export declare function getUploadFields(definition: Pick<CollectionDefinition, 'fields'>): (ImageField | FileField)[];
 /**
  * Convenience: does this collection have at least one upload-capable
- * image/file field at the top level? Replaces the old
+ * image/file field at any nesting depth? Replaces the old
  * `definition.upload != null` discriminator that "this collection is
  * an upload collection / media library."
  */

package/dist/utils/storage-utils.js

@@ -5,6 +5,7 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
+import { isArrayField, isBlocksField, isGroupField, } from '../@types/field-types.js';
 /**
  * Predicate: does this field carry an `upload` config? True for any
  * `image` / `file` field with an `upload` block declared.
@@ -13,25 +14,43 @@ export function isUploadField(field) {
     return (field.type === 'image' || field.type === 'file') && field.upload != null;
 }
 /**
- * Walk the top-level field set and return every upload-capable
- * image/file field on the collection. Used by the delete path,
- * the upload-route resolver, and any UI that needs to reason about
- * "is this collection upload-capable, and which fields take uploads?"
+ * Walk the field set and return every upload-capable image/file field
+ * on the collection, recursing into `group` / `array` / `blocks`
+ * structure fields. Used by the delete path, the upload-route resolver,
+ * and any UI that needs to reason about "is this collection
+ * upload-capable, and which fields take uploads?"
  *
- * Does not recurse into `group` / `array` / `blocks` — the supported
- * transport surface is top-level upload fields. Nested upload fields
- * are reachable through the core upload service via `findUploadField`,
- * but require a richer transport selector.
+ * Field names are the upload transport's selector, so a schema should
+ * not declare two upload fields with the same name in different nesting
+ * scopes — resolvers match by name and take the first hit in
+ * declaration order.
  */
 export function getUploadFields(definition) {
-    return definition.fields.filter(isUploadField);
+    const found = [];
+    collectUploadFields(definition.fields, found);
+    return found;
+}
+function collectUploadFields(fields, found) {
+    for (const field of fields) {
+        if (isUploadField(field)) {
+            found.push(field);
+        }
+        else if (isGroupField(field) || isArrayField(field)) {
+            collectUploadFields(field.fields, found);
+        }
+        else if (isBlocksField(field)) {
+            for (const block of field.blocks) {
+                collectUploadFields(block.fields, found);
+            }
+        }
+    }
 }
 /**
  * Convenience: does this collection have at least one upload-capable
- * image/file field at the top level? Replaces the old
+ * image/file field at any nesting depth? Replaces the old
  * `definition.upload != null` discriminator that "this collection is
  * an upload collection / media library."
  */
 export function hasUploadField(definition) {
-    return definition.fields.some(isUploadField);
+    return getUploadFields(definition).length > 0;
 }

package/dist/utils/storage-utils.test.node.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};

package/dist/utils/storage-utils.test.node.js

@@ -0,0 +1,90 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import { describe, expect, it } from 'vitest';
+import { getUploadFields, hasUploadField, isUploadField } from './storage-utils.js';
+const upload = { mimeTypes: ['application/pdf'], maxFileSize: 1024 };
+const coverField = { name: 'cover', label: 'Cover', type: 'image', upload };
+const nestedFileField = { name: 'publicationFile', label: 'File', type: 'file', upload };
+describe('isUploadField', () => {
+    it('is true for image/file fields with an upload block', () => {
+        expect(isUploadField(coverField)).toBe(true);
+        expect(isUploadField(nestedFileField)).toBe(true);
+    });
+    it('is false for image/file fields without an upload block', () => {
+        expect(isUploadField({ name: 'pic', label: 'Pic', type: 'image' })).toBe(false);
+        expect(isUploadField({ name: 'doc', label: 'Doc', type: 'file' })).toBe(false);
+    });
+    it('is false for non-media fields', () => {
+        expect(isUploadField({ name: 'title', label: 'Title', type: 'text' })).toBe(false);
+    });
+});
+describe('getUploadFields', () => {
+    it('returns top-level upload fields', () => {
+        const fields = [{ name: 'title', label: 'Title', type: 'text' }, coverField];
+        expect(getUploadFields({ fields }).map((f) => f.name)).toEqual(['cover']);
+    });
+    it('recurses into group / array / blocks structure fields', () => {
+        const fields = [
+            coverField,
+            {
+                name: 'files',
+                label: 'Files',
+                type: 'array',
+                fields: [
+                    {
+                        name: 'filesGroup',
+                        type: 'group',
+                        fields: [nestedFileField, { name: 'label', label: 'Label', type: 'text' }],
+                    },
+                ],
+            },
+            {
+                name: 'content',
+                label: 'Content',
+                type: 'blocks',
+                blocks: [
+                    {
+                        blockType: 'photo',
+                        label: 'Photo',
+                        fields: [{ name: 'photo', label: 'Photo', type: 'image', upload }],
+                    },
+                ],
+            },
+        ];
+        expect(getUploadFields({ fields }).map((f) => f.name)).toEqual([
+            'cover',
+            'publicationFile',
+            'photo',
+        ]);
+    });
+    it('skips nested image/file fields without an upload block', () => {
+        const fields = [
+            {
+                name: 'gallery',
+                label: 'Gallery',
+                type: 'group',
+                fields: [{ name: 'pic', label: 'Pic', type: 'image' }],
+            },
+        ];
+        expect(getUploadFields({ fields })).toEqual([]);
+    });
+});
+describe('hasUploadField', () => {
+    it('detects upload fields at any nesting depth', () => {
+        const fields = [
+            {
+                name: 'files',
+                label: 'Files',
+                type: 'array',
+                fields: [{ name: 'filesGroup', type: 'group', fields: [nestedFileField] }],
+            },
+        ];
+        expect(hasUploadField({ fields })).toBe(true);
+        expect(hasUploadField({ fields: [{ name: 'title', label: 'Title', type: 'text' }] })).toBe(false);
+    });
+});

package/dist/validation/shared.d.ts

@@ -33,9 +33,9 @@ import { z } from 'zod';
  * this file — emit codes here, translate in `@byline/admin`.
  */
 export declare const PASSWORD_ERROR_CODES: {
-    readonly TOO_SHORT: "password.tooShort";
-    readonly TOO_LONG: "password.tooLong";
-    readonly COMPLEXITY: "password.complexity";
+    readonly TOO_SHORT: 'password.tooShort';
+    readonly TOO_LONG: 'password.tooLong';
+    readonly COMPLEXITY: 'password.complexity';
 };
 /**
  * Standard password policy — 8 to 128 characters, must contain at least

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/core",
   "private": false,
   "license": "MPL-2.0",
-  "version": "3.17.0",
+  "version": "3.18.0",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -74,20 +74,20 @@
   "dependencies": {
     "dotenv": "^17.4.2",
     "pino": "^10.3.1",
-    "sharp": "^0.34.5",
+    "sharp": "^0.35.3",
     "zod": "^4.4.3",
-    "@byline/auth": "3.17.0"
+    "@byline/auth": "3.18.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.15",
-    "@types/node": "^25.9.1",
+    "@biomejs/biome": "2.5.2",
+    "@types/node": "^26.1.0",
     "chokidar": "^5.0.0",
     "chokidar-cli": "^3.0.0",
     "npm-run-all": "^4.1.5",
-    "tsc-alias": "^1.8.17",
-    "tsx": "^4.22.3",
-    "typescript": "6.0.3",
-    "vitest": "^4.1.7"
+    "tsc-alias": "^1.9.0",
+    "tsx": "^4.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
   },
   "publishConfig": {
     "access": "public",