@byline/admin 4.3.0 → 4.4.0

package/dist/fields/array/array-field.d.ts

@@ -6,18 +6,11 @@
  * Copyright (c) Infonomic Company Limited
  */
 import type { ArrayField as ArrayFieldType, FieldAdminConfig } from '@byline/core';
-export declare const ArrayField: ({ field, defaultValue, path, disableSorting, collectionPath, contentLocale, fieldAdmin, }: {
+export declare const ArrayField: ({ field, defaultValue, path, disableSorting, contentLocale, fieldAdmin, }: {
     field: ArrayFieldType;
     defaultValue: any;
     path: string;
     disableSorting?: boolean;
-    /**
-     * Collection path forwarded to upload-capable fields (`file` / `image`)
-     * nested inside an array item, which need it to reach the `/upload`
-     * endpoint. Without it those fields fall back to their empty placeholder
-     * and never render an upload widget.
-     */
-    collectionPath?: string;
     /**
      * Active content locale, forwarded to each array item's fields so
      * localized widgets nested inside an array (e.g. a `localized` richText)

package/dist/fields/array/array-field.js

@@ -9,7 +9,7 @@ import { FieldRenderer } from "../field-renderer.js";
 import { SortableItem, StaticItem } from "../sortable-item.js";
 import { useFormContext } from "../../forms/form-context.js";
 import array_field_module from "./array-field.module.js";
-const ArrayField = ({ field, defaultValue, path, disableSorting = false, collectionPath, contentLocale, fieldAdmin })=>{
+const ArrayField = ({ field, defaultValue, path, disableSorting = false, contentLocale, fieldAdmin })=>{
     const { appendPatch, getFieldValue, getFieldValues, setFieldStore } = useFormContext();
     const { t } = useTranslation('byline-admin');
     const [items, setItems] = useState([]);
@@ -127,7 +127,6 @@ const ArrayField = ({ field, defaultValue, path, disableSorting = false, collect
                                 defaultValue: groupData[innerField.name],
                                 basePath: `${arrayElementPath}.${childField.name}`,
                                 disableSorting: true,
-                                collectionPath: collectionPath,
                                 contentLocale: contentLocale,
                                 components: groupAdmin?.[innerField.name]?.components,
                                 editor: groupAdmin?.[innerField.name]?.editor,
@@ -141,7 +140,6 @@ const ArrayField = ({ field, defaultValue, path, disableSorting = false, collect
                 defaultValue: initial,
                 basePath: arrayElementPath,
                 disableSorting: true,
-                collectionPath: collectionPath,
                 contentLocale: contentLocale,
                 components: fieldAdmin?.[childField.name]?.components,
                 editor: fieldAdmin?.[childField.name]?.editor,

package/dist/fields/field-renderer.d.ts

@@ -12,8 +12,6 @@ interface FieldRendererProps {
     basePath?: string;
     disableSorting?: boolean;
     hideLabel?: boolean;
-    /** Collection path (e.g. `'media'`) forwarded to upload-capable fields. */
-    collectionPath?: string;
     /**
      * The active content locale (e.g. `'en'`, `'fr'`). When provided and
      * `field.localized === true`, a small locale badge is shown so the editor
@@ -42,5 +40,5 @@ interface FieldRendererProps {
      */
     fieldAdmin?: Record<string, FieldAdminConfig>;
 }
-export declare const FieldRenderer: ({ field, defaultValue: initialDefault, basePath, disableSorting, hideLabel, collectionPath, contentLocale, components, editor, fieldAdmin, }: FieldRendererProps) => import("react").JSX.Element | null;
+export declare const FieldRenderer: ({ field, defaultValue: initialDefault, basePath, disableSorting, hideLabel, contentLocale, components, editor, fieldAdmin, }: FieldRendererProps) => import("react").JSX.Element | null;
 export {};

package/dist/fields/field-renderer.js

@@ -20,7 +20,7 @@ import { TextField } from "./text/text-field.js";
 import { TextAreaField } from "./text-area/text-area-field.js";
 import { useFieldChangeHandler } from "./use-field-change-handler.js";
 import { useFieldCondition } from "./use-field-condition.js";
-const FieldRenderer = ({ field, defaultValue: initialDefault, basePath, disableSorting, hideLabel, collectionPath, contentLocale, components, editor, fieldAdmin })=>{
+const FieldRenderer = ({ field, defaultValue: initialDefault, basePath, disableSorting, hideLabel, contentLocale, components, editor, fieldAdmin })=>{
     const path = basePath ? `${basePath}.${field.name}` : field.name;
     const htmlId = path.replace(/[[\].]/g, '-');
     const handleChange = useFieldChangeHandler(field, path);
@@ -161,8 +161,7 @@ const FieldRenderer = ({ field, defaultValue: initialDefault, basePath, disableS
                     } : field,
                     defaultValue: defaultValue,
                     onChange: handleChange,
-                    path: path,
-                    collectionPath: collectionPath
+                    path: path
                 });
             case 'image':
                 return /*#__PURE__*/ jsx(ImageField, {
@@ -172,8 +171,7 @@ const FieldRenderer = ({ field, defaultValue: initialDefault, basePath, disableS
                     } : field,
                     defaultValue: defaultValue,
                     onChange: handleChange,
-                    path: path,
-                    collectionPath: collectionPath
+                    path: path
                 });
             case 'relation':
                 if (field.hasMany) return /*#__PURE__*/ jsx(RelationManyField, {
@@ -204,7 +202,6 @@ const FieldRenderer = ({ field, defaultValue: initialDefault, basePath, disableS
                     defaultValue: defaultValue,
                     path: path,
                     disableSorting: disableSorting,
-                    collectionPath: collectionPath,
                     contentLocale: contentLocale,
                     fieldAdmin: fieldAdmin
                 });
@@ -223,7 +220,6 @@ const FieldRenderer = ({ field, defaultValue: initialDefault, basePath, disableS
                     defaultValue: defaultValue,
                     path: path,
                     disableSorting: disableSorting,
-                    collectionPath: collectionPath,
                     contentLocale: contentLocale,
                     fieldAdmin: fieldAdmin
                 });

package/dist/fields/file/file-field.d.ts

@@ -8,12 +8,10 @@
 import { type FileField as FieldType, type StoredFileValue } from '@byline/core';
 interface FileFieldProps {
     field: FieldType;
-    /** Collection path required to call the /upload endpoint. */
-    collectionPath?: string;
     value?: StoredFileValue | null;
     defaultValue?: StoredFileValue | null;
     onChange?: (value: StoredFileValue | null) => void;
     path?: string;
 }
-export declare const FileField: ({ field, collectionPath, value, defaultValue, onChange: _onChange, path, }: FileFieldProps) => import("react").JSX.Element;
+export declare const FileField: ({ field, value, defaultValue, onChange: _onChange, path, }: FileFieldProps) => import("react").JSX.Element;
 export {};

package/dist/fields/file/file-field.js

@@ -18,14 +18,14 @@ function triggerDownload(url, filename) {
     a.click();
     document.body.removeChild(a);
 }
-const FileField = ({ field, collectionPath, value, defaultValue, onChange: _onChange, path })=>{
+const FileField = ({ field, value, defaultValue, onChange: _onChange, path })=>{
     const fieldPath = path ?? field.name;
     const { t } = useTranslation('byline-admin');
     const fieldError = useFieldError(fieldPath);
     const isDirty = useIsDirty(fieldPath);
     const fieldValue = useFieldValue(fieldPath);
     const isUploading = useIsFieldUploading(fieldPath);
-    const { removePendingUpload, documentId } = useFormContext();
+    const { removePendingUpload, documentId, collectionPath } = useFormContext();
     const handleChange = useFieldChangeHandler(field, fieldPath);
     const incomingValue = isDirty ? fieldValue ?? null : value ?? fieldValue ?? defaultValue ?? null;
     const isPending = isPendingStoredFileValue(incomingValue);

package/dist/fields/group/group-field.d.ts

@@ -20,12 +20,6 @@ interface GroupFieldProps {
      * listeners.
      */
     disableSorting?: boolean;
-    /**
-     * Collection path forwarded to upload-capable child fields (`file` / `image`),
-     * which need it to reach the `/upload` endpoint. Without it those fields fall
-     * back to their empty placeholder and never render an upload widget.
-     */
-    collectionPath?: string;
     /**
      * Active content locale, forwarded to child fields so localized widgets
      * nested inside the group (e.g. a `localized` richText) can render their
@@ -44,5 +38,5 @@ interface GroupFieldProps {
      */
     fieldAdmin?: Record<string, FieldAdminConfig>;
 }
-export declare const GroupField: ({ field, defaultValue, path, disableSorting, collectionPath, contentLocale, fieldAdmin, }: GroupFieldProps) => import("react").JSX.Element;
+export declare const GroupField: ({ field, defaultValue, path, disableSorting, contentLocale, fieldAdmin, }: GroupFieldProps) => import("react").JSX.Element;
 export {};

package/dist/fields/group/group-field.js

@@ -7,7 +7,7 @@ import { placeholderForField } from "../field-helpers.js";
 import { FieldRenderer } from "../field-renderer.js";
 import { useFieldError } from "../../forms/form-context.js";
 import group_field_module from "./group-field.module.js";
-const GroupField = ({ field, defaultValue, path, disableSorting = true, collectionPath, contentLocale, fieldAdmin })=>{
+const GroupField = ({ field, defaultValue, path, disableSorting = true, contentLocale, fieldAdmin })=>{
     const fieldError = useFieldError(field.name);
     const groupData = useMemo(()=>{
         if (defaultValue && 'object' == typeof defaultValue && !Array.isArray(defaultValue)) return defaultValue;
@@ -48,7 +48,6 @@ const GroupField = ({ field, defaultValue, path, disableSorting = true, collecti
                         defaultValue: groupData[innerField.name],
                         basePath: path,
                         disableSorting: disableSorting,
-                        collectionPath: collectionPath,
                         contentLocale: contentLocale,
                         components: fieldAdmin?.[innerField.name]?.components,
                         editor: fieldAdmin?.[innerField.name]?.editor,

package/dist/fields/image/image-field.d.ts

@@ -8,12 +8,10 @@
 import { type ImageField as FieldType, type StoredFileValue } from '@byline/core';
 interface ImageFieldProps {
     field: FieldType;
-    /** Collection path required to call the /upload endpoint. */
-    collectionPath?: string;
     value?: StoredFileValue | null;
     defaultValue?: StoredFileValue | null;
     onChange?: (value: StoredFileValue | null) => void;
     path?: string;
 }
-export declare const ImageField: ({ field, collectionPath, value, defaultValue, onChange: _onChange, path, }: ImageFieldProps) => import("react").JSX.Element;
+export declare const ImageField: ({ field, value, defaultValue, onChange: _onChange, path, }: ImageFieldProps) => import("react").JSX.Element;
 export {};

package/dist/fields/image/image-field.js

@@ -8,13 +8,13 @@ import { useFieldError, useFieldValue, useFormContext, useIsDirty, useIsFieldUpl
 import { useFieldChangeHandler } from "../use-field-change-handler.js";
 import image_field_module from "./image-field.module.js";
 import { ImageUploadField } from "./image-upload-field.js";
-const ImageField = ({ field, collectionPath, value, defaultValue, onChange: _onChange, path })=>{
+const ImageField = ({ field, value, defaultValue, onChange: _onChange, path })=>{
     const fieldPath = path ?? field.name;
     const fieldError = useFieldError(fieldPath);
     const isDirty = useIsDirty(fieldPath);
     const fieldValue = useFieldValue(fieldPath);
     const isUploading = useIsFieldUploading(fieldPath);
-    const { removePendingUpload, documentId } = useFormContext();
+    const { removePendingUpload, documentId, collectionPath } = useFormContext();
     const { t } = useTranslation('byline-admin');
     const handleChange = useFieldChangeHandler(field, fieldPath);
     const incomingValue = isDirty ? fieldValue ?? null : value ?? fieldValue ?? defaultValue ?? null;

package/dist/forms/form-context.d.ts

@@ -55,6 +55,19 @@ interface FormContextType {
      * `@byline/core`).
      */
     documentId: string | null;
+    /**
+     * Path of the collection this form edits, `null` when the form is rendered
+     * without one. Upload widgets need it to address the upload endpoint.
+     *
+     * It lives here rather than being passed down because it is constant for
+     * the whole form: threading it as a prop meant every nesting-capable
+     * container (`array`, `group`, `blocks`) had to remember to forward it,
+     * and a container that forgot silently rendered upload fields read-only —
+     * no error, just a missing drop zone. That happened twice, in `array` /
+     * `group` and then in `blocks`. A value read from context cannot be
+     * dropped by a container that never carries it.
+     */
+    collectionPath: string | null;
     setFieldValue: (name: string, value: any) => void;
     setFieldStore: (name: string, value: any) => void;
     getFieldValue: (name: string) => any;
@@ -97,7 +110,7 @@ interface FormContextType {
     subscribeSystemAvailableLocales: (listener: SystemAvailableLocalesListener) => () => void;
 }
 export declare const useFormContext: () => FormContextType;
-export declare const FormProvider: ({ children, initialData, documentId, }: {
+export declare const FormProvider: ({ children, initialData, documentId, collectionPath, }: {
     children: React.ReactNode;
     initialData?: Record<string, any>;
     /**
@@ -105,6 +118,12 @@ export declare const FormProvider: ({ children, initialData, documentId, }: {
      * the context for upload widgets honouring `upload.requireSavedDocument`.
      */
     documentId?: string | null;
+    /**
+     * Path of the collection being edited. Exposed on the context so upload
+     * widgets can reach the upload endpoint from any nesting depth without
+     * every container forwarding it — see `FormContextType.collectionPath`.
+     */
+    collectionPath?: string | null;
 }) => React.JSX.Element;
 /**
  * Subscribe to the system `path` slot edited by the path widget.

package/dist/forms/form-context.js

@@ -22,7 +22,7 @@ const useFormContext = ()=>{
     if (null == context) throw new Error('useFormContext must be used within a FormProvider');
     return context;
 };
-const FormProvider = ({ children, initialData = {}, documentId = null })=>{
+const FormProvider = ({ children, initialData = {}, documentId = null, collectionPath = null })=>{
     const fieldValues = useRef(JSON.parse(JSON.stringify(initialData?.fields ?? initialData)));
     const initialValues = useRef(initialData?.fields ?? initialData);
     const errorsRef = useRef([]);
@@ -377,6 +377,7 @@ const FormProvider = ({ children, initialData = {}, documentId = null })=>{
     return /*#__PURE__*/ jsx(FormContext.Provider, {
         value: {
             documentId,
+            collectionPath,
             setFieldValue,
             setFieldStore,
             getFieldValue,

package/dist/forms/form-renderer.js

@@ -183,7 +183,6 @@ const FormContent = ({ mode, fields, onSubmit, onCancel, onStatusChange, onUnpub
         return /*#__PURE__*/ jsx(FieldRenderer, {
             field: field,
             defaultValue: initialData?.fields?.[field.name],
-            collectionPath: collectionPath,
             contentLocale: contentLocale,
             components: adminConfig?.fields?.[field.name]?.components,
             editor: adminConfig?.fields?.[field.name]?.editor,
@@ -405,6 +404,7 @@ const FormRenderer = ({ mode, fields, onSubmit, onCancel, onStatusChange, onUnpu
     return /*#__PURE__*/ jsx(FormProvider, {
         initialData: initialData,
         documentId: 'edit' === mode && 'string' == typeof initialData?.id ? initialData.id : null,
+        collectionPath: collectionPath ?? null,
         children: /*#__PURE__*/ jsx(FormContent, {
             mode: mode,
             fields: fields,

package/dist/forms/upload-executor.js

@@ -1,3 +1,4 @@
+import { parseInstancePath } from "@byline/core";
 import { get } from "./nested-path.js";
 async function executeUploads(pendingUploads, uploadField, executionContext) {
     const results = [];
@@ -36,16 +37,14 @@ function buildUploadFormData(fieldPath, upload, executionContext) {
     formData.append('field', uploadFieldName(fieldPath));
     formData.append('fieldPath', fieldPath);
     if (executionContext?.documentId) formData.append('documentId', executionContext.documentId);
-    const contextPaths = executionContext?.fields != null ? findUploadFieldByPath(executionContext.fields, fieldPath)?.context : void 0;
-    if (contextPaths && contextPaths.length > 0 && executionContext?.getFormValues) {
-        const formValues = executionContext.getFormValues();
-        for (const contextPath of contextPaths){
-            const resolvedPath = resolveContextPath(fieldPath, contextPath);
-            if (void 0 === resolvedPath) continue;
-            const value = '' === resolvedPath ? formValues : get(formValues, resolvedPath);
-            const serialized = serializeContextValue(value);
-            if (void 0 !== serialized) formData.append(leafName(contextPath), serialized);
-        }
+    const formValues = executionContext?.getFormValues?.();
+    const contextPaths = executionContext?.fields != null ? findUploadFieldByPath(executionContext.fields, fieldPath, formValues)?.context : void 0;
+    if (contextPaths && contextPaths.length > 0 && formValues) for (const contextPath of contextPaths){
+        const resolvedPath = resolveContextPath(fieldPath, contextPath);
+        if (void 0 === resolvedPath) continue;
+        const value = '' === resolvedPath ? formValues : get(formValues, resolvedPath);
+        const serialized = serializeContextValue(value);
+        if (void 0 !== serialized) formData.append(leafName(contextPath), serialized);
     }
     return formData;
 }
@@ -89,27 +88,49 @@ function serializeContextValue(value) {
 function isRelationEnvelope(value) {
     return 'object' == typeof value && null !== value && 'string' == typeof value.targetDocumentId;
 }
-function findUploadFieldByPath(fields, fieldPath) {
-    const segments = fieldPath.split('.').map((s)=>s.replace(/\[\d+\]$/, ''));
-    let currentFields = fields;
-    for(let i = 0; i < segments.length; i++){
-        const name = segments[i];
-        const isLeaf = i === segments.length - 1;
-        const field = currentFields.find((f)=>f.name === name);
-        if (!field) break;
-        if (isLeaf) return 'image' === field.type || 'file' === field.type ? field.upload : void 0;
-        if ('group' === field.type || 'array' === field.type) {
-            currentFields = field.fields;
-            continue;
+function findUploadFieldByPath(fields, fieldPath, formValues) {
+    const parsed = parseInstancePath(fieldPath);
+    if (!parsed.ok) return;
+    return resolveUploadConfig(fields, parsed.segments, formValues);
+}
+function selectItem(value, segment) {
+    if (!Array.isArray(value)) return;
+    if ('index' === segment.kind) return value[segment.index];
+    if ('id' === segment.kind) return value.find((item)=>item?._id === segment.id);
+}
+function resolveUploadConfig(fields, segments, value) {
+    const head = segments[0];
+    if (null == head || 'field' !== head.kind) return;
+    const field = fields.find((candidate)=>candidate.name === head.name);
+    if (null == field) return;
+    const fieldValue = value?.[head.name];
+    const rest = segments.slice(1);
+    if (0 === rest.length) return 'image' === field.type || 'file' === field.type ? field.upload : void 0;
+    if ('group' === field.type) return resolveUploadConfig(field.fields, rest, fieldValue);
+    if ('array' === field.type) {
+        const selector = rest[0];
+        if (selector?.kind === 'index' || selector?.kind === 'id') return resolveUploadConfig(field.fields, rest.slice(1), selectItem(fieldValue, selector));
+        return resolveUploadConfig(field.fields, rest, void 0);
+    }
+    if ('blocks' === field.type) {
+        const selector = rest[0];
+        const remainder = selector?.kind === 'index' || selector?.kind === 'id' ? rest.slice(1) : rest;
+        const item = selector?.kind === 'index' || selector?.kind === 'id' ? selectItem(fieldValue, selector) : void 0;
+        const blockType = item?._type;
+        if ('string' == typeof blockType) {
+            const block = field.blocks.find((candidate)=>candidate.blockType === blockType);
+            return null == block ? void 0 : resolveUploadConfig(block.fields, remainder, item);
         }
-        if ('blocks' === field.type) {
-            const remaining = segments[i + 1];
-            const block = field.blocks.find((b)=>b.fields.some((f)=>f.name === remaining));
-            if (!block) return;
-            currentFields = block.fields;
-            continue;
+        let found;
+        let matches = 0;
+        for (const block of field.blocks){
+            const result = resolveUploadConfig(block.fields, remainder, void 0);
+            if (void 0 !== result) {
+                matches += 1;
+                found = result;
+            }
         }
-        break;
+        return 1 === matches ? found : void 0;
     }
 }
 async function executeUploadsWithProgress(pendingUploads, uploadField, onProgress, executionContext) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/admin",
   "private": false,
   "license": "MPL-2.0",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -168,10 +168,10 @@
     "react-diff-viewer-continued": "^4.4.0",
     "uuid": "^14.0.1",
     "zod": "^4.4.3",
-    "@byline/core": "4.3.0",
-    "@byline/auth": "4.3.0",
-    "@byline/i18n": "4.3.0",
-    "@byline/ui": "4.3.0"
+    "@byline/auth": "4.4.0",
+    "@byline/i18n": "4.4.0",
+    "@byline/ui": "4.4.0",
+    "@byline/core": "4.4.0"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/fields/array/array-field.tsx

@@ -31,7 +31,6 @@ export const ArrayField = ({
   defaultValue,
   path,
   disableSorting = false,
-  collectionPath,
   contentLocale,
   fieldAdmin,
 }: {
@@ -39,13 +38,6 @@ export const ArrayField = ({
   defaultValue: any
   path: string
   disableSorting?: boolean
-  /**
-   * Collection path forwarded to upload-capable fields (`file` / `image`)
-   * nested inside an array item, which need it to reach the `/upload`
-   * endpoint. Without it those fields fall back to their empty placeholder
-   * and never render an upload widget.
-   */
-  collectionPath?: string
   /**
    * Active content locale, forwarded to each array item's fields so
    * localized widgets nested inside an array (e.g. a `localized` richText)
@@ -242,7 +234,6 @@ export const ArrayField = ({
                 defaultValue={groupData[innerField.name]}
                 basePath={`${arrayElementPath}.${childField.name}`}
                 disableSorting={true}
-                collectionPath={collectionPath}
                 contentLocale={contentLocale}
                 components={groupAdmin?.[innerField.name]?.components}
                 editor={groupAdmin?.[innerField.name]?.editor}
@@ -260,7 +251,6 @@ export const ArrayField = ({
           defaultValue={initial}
           basePath={arrayElementPath}
           disableSorting={true}
-          collectionPath={collectionPath}
           contentLocale={contentLocale}
           components={fieldAdmin?.[childField.name]?.components}
           editor={fieldAdmin?.[childField.name]?.editor}

package/src/fields/field-renderer.tsx

@@ -49,8 +49,6 @@ interface FieldRendererProps {
   basePath?: string
   disableSorting?: boolean
   hideLabel?: boolean
-  /** Collection path (e.g. `'media'`) forwarded to upload-capable fields. */
-  collectionPath?: string
   /**
    * The active content locale (e.g. `'en'`, `'fr'`). When provided and
    * `field.localized === true`, a small locale badge is shown so the editor
@@ -86,7 +84,6 @@ export const FieldRenderer = ({
   basePath,
   disableSorting,
   hideLabel,
-  collectionPath,
   contentLocale,
   components,
   editor,
@@ -256,7 +253,6 @@ export const FieldRenderer = ({
             defaultValue={defaultValue}
             onChange={handleChange}
             path={path}
-            collectionPath={collectionPath}
           />
         )
       case 'image':
@@ -266,7 +262,6 @@ export const FieldRenderer = ({
             defaultValue={defaultValue}
             onChange={handleChange}
             path={path}
-            collectionPath={collectionPath}
           />
         )
       case 'relation':
@@ -301,7 +296,6 @@ export const FieldRenderer = ({
             defaultValue={defaultValue}
             path={path}
             disableSorting={disableSorting}
-            collectionPath={collectionPath}
             contentLocale={contentLocale}
             fieldAdmin={fieldAdmin}
           />
@@ -324,7 +318,6 @@ export const FieldRenderer = ({
             defaultValue={defaultValue}
             path={path}
             disableSorting={disableSorting}
-            collectionPath={collectionPath}
             contentLocale={contentLocale}
             fieldAdmin={fieldAdmin}
           />

package/src/fields/file/file-field.tsx

@@ -57,8 +57,6 @@ function triggerDownload(url: string, filename?: string) {
 
 interface FileFieldProps {
   field: FieldType
-  /** Collection path required to call the /upload endpoint. */
-  collectionPath?: string
   value?: StoredFileValue | null
   defaultValue?: StoredFileValue | null
   onChange?: (value: StoredFileValue | null) => void
@@ -67,7 +65,6 @@ interface FileFieldProps {
 
 export const FileField = ({
   field,
-  collectionPath,
   value,
   defaultValue,
   onChange: _onChange,
@@ -79,7 +76,10 @@ export const FileField = ({
   const isDirty = useIsDirty(fieldPath)
   const fieldValue = useFieldValue<StoredFileValue | null | undefined>(fieldPath)
   const isUploading = useIsFieldUploading(fieldPath)
-  const { removePendingUpload, documentId } = useFormContext()
+  // `collectionPath` comes from form context rather than a prop: it is
+  // constant for the form, and prop-drilling it meant any container that
+  // forgot to forward it silently rendered this widget read-only.
+  const { removePendingUpload, documentId, collectionPath } = useFormContext()
 
   const handleChange = useFieldChangeHandler(field, fieldPath)
 

package/src/fields/group/group-field.tsx

@@ -43,12 +43,6 @@ interface GroupFieldProps {
    * listeners.
    */
   disableSorting?: boolean
-  /**
-   * Collection path forwarded to upload-capable child fields (`file` / `image`),
-   * which need it to reach the `/upload` endpoint. Without it those fields fall
-   * back to their empty placeholder and never render an upload widget.
-   */
-  collectionPath?: string
   /**
    * Active content locale, forwarded to child fields so localized widgets
    * nested inside the group (e.g. a `localized` richText) can render their
@@ -73,7 +67,6 @@ export const GroupField = ({
   defaultValue,
   path,
   disableSorting = true,
-  collectionPath,
   contentLocale,
   fieldAdmin,
 }: GroupFieldProps) => {
@@ -116,7 +109,6 @@ export const GroupField = ({
               defaultValue={groupData[innerField.name]}
               basePath={path}
               disableSorting={disableSorting}
-              collectionPath={collectionPath}
               contentLocale={contentLocale}
               components={fieldAdmin?.[innerField.name]?.components}
               editor={fieldAdmin?.[innerField.name]?.editor}

package/src/fields/image/image-field.tsx

@@ -38,8 +38,6 @@ import { ImageUploadField } from './image-upload-field'
 
 interface ImageFieldProps {
   field: FieldType
-  /** Collection path required to call the /upload endpoint. */
-  collectionPath?: string
   // Stored value is currently a plain object with file/image metadata
   // coming from the seed data / storage layer.
   value?: StoredFileValue | null
@@ -50,7 +48,6 @@ interface ImageFieldProps {
 
 export const ImageField = ({
   field,
-  collectionPath,
   value,
   defaultValue,
   onChange: _onChange,
@@ -61,7 +58,10 @@ export const ImageField = ({
   const isDirty = useIsDirty(fieldPath)
   const fieldValue = useFieldValue<StoredFileValue | null | undefined>(fieldPath)
   const isUploading = useIsFieldUploading(fieldPath)
-  const { removePendingUpload, documentId } = useFormContext()
+  // `collectionPath` comes from form context rather than a prop: it is
+  // constant for the form, and prop-drilling it meant any container that
+  // forgot to forward it silently rendered this widget read-only.
+  const { removePendingUpload, documentId, collectionPath } = useFormContext()
   const { t } = useTranslation('byline-admin')
 
   // Re-use the standard field change handler so patches are emitted correctly.

package/src/forms/form-context.tsx

@@ -90,6 +90,19 @@ interface FormContextType {
    * `@byline/core`).
    */
   documentId: string | null
+  /**
+   * Path of the collection this form edits, `null` when the form is rendered
+   * without one. Upload widgets need it to address the upload endpoint.
+   *
+   * It lives here rather than being passed down because it is constant for
+   * the whole form: threading it as a prop meant every nesting-capable
+   * container (`array`, `group`, `blocks`) had to remember to forward it,
+   * and a container that forgot silently rendered upload fields read-only —
+   * no error, just a missing drop zone. That happened twice, in `array` /
+   * `group` and then in `blocks`. A value read from context cannot be
+   * dropped by a container that never carries it.
+   */
+  collectionPath: string | null
   setFieldValue: (name: string, value: any) => void
   setFieldStore: (name: string, value: any) => void
   getFieldValue: (name: string) => any
@@ -158,6 +171,7 @@ export const FormProvider = ({
   children,
   initialData = {},
   documentId = null,
+  collectionPath = null,
 }: {
   children: React.ReactNode
   initialData?: Record<string, any>
@@ -166,6 +180,12 @@ export const FormProvider = ({
    * the context for upload widgets honouring `upload.requireSavedDocument`.
    */
   documentId?: string | null
+  /**
+   * Path of the collection being edited. Exposed on the context so upload
+   * widgets can reach the upload endpoint from any nesting depth without
+   * every container forwarding it — see `FormContextType.collectionPath`.
+   */
+  collectionPath?: string | null
 }) => {
   const fieldValues = useRef<Record<string, any>>(
     JSON.parse(JSON.stringify(initialData?.fields ?? initialData))
@@ -662,6 +682,7 @@ export const FormProvider = ({
     <FormContext.Provider
       value={{
         documentId,
+        collectionPath,
         setFieldValue,
         setFieldStore,
         getFieldValue,

package/src/forms/form-renderer.tsx

@@ -485,7 +485,6 @@ const FormContent = ({
         key={field.name}
         field={field}
         defaultValue={initialData?.fields?.[field.name]}
-        collectionPath={collectionPath}
         contentLocale={contentLocale}
         components={adminConfig?.fields?.[field.name]?.components}
         editor={adminConfig?.fields?.[field.name]?.editor}
@@ -778,6 +777,7 @@ export const FormRenderer = ({
       key={`${initialLocale ?? 'default'}-${initialData?.versionId ?? ''}`}
       initialData={initialData}
       documentId={mode === 'edit' && typeof initialData?.id === 'string' ? initialData.id : null}
+      collectionPath={collectionPath ?? null}
     >
       <FormContent
         mode={mode}

package/src/forms/upload-executor.test.node.ts

@@ -56,6 +56,76 @@ const publicationsFields: Field[] = [
   },
 ]
 
+/**
+ * Two block types that both declare an array named `gallery`, each holding a
+ * different upload-capable leaf. Leaf names stay unique across the
+ * collection, so this passes the boot-time uniqueness constraint — the shape
+ * is legal, and it is the shape that made block resolution ambiguous.
+ */
+const blocksFields: Field[] = [
+  { name: 'title', label: 'Title', type: 'text' },
+  {
+    name: 'content',
+    label: 'Content',
+    type: 'blocks',
+    blocks: [
+      {
+        blockType: 'photoBlock',
+        fields: [
+          {
+            name: 'gallery',
+            label: 'Gallery',
+            type: 'array',
+            fields: [
+              {
+                name: 'heroImage',
+                label: 'Hero',
+                type: 'image',
+                upload: { context: ['/title'] },
+              },
+            ],
+          },
+        ],
+      },
+      {
+        blockType: 'videoBlock',
+        fields: [
+          {
+            name: 'gallery',
+            label: 'Gallery',
+            type: 'array',
+            fields: [
+              {
+                name: 'poster',
+                label: 'Poster',
+                type: 'image',
+                upload: { context: ['/title'] },
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  },
+]
+
+/** Form state for `blocksFields`: a photoBlock then a videoBlock. */
+const blocksFormValues = () => ({
+  title: 'Hello',
+  content: [
+    { _type: 'photoBlock', _id: 'blk-photo', gallery: [{}] },
+    { _type: 'videoBlock', _id: 'blk-video', gallery: [{}] },
+  ],
+})
+
+function imageUpload(name = 'p.png'): PendingUpload {
+  return {
+    file: new File(['x'], name, { type: 'image/png' }),
+    previewUrl: 'blob:mock',
+    collectionPath: 'pages',
+  }
+}
+
 function pendingUpload(name = 'test.pdf'): PendingUpload {
   return {
     file: new File(['%PDF'], name, { type: 'application/pdf' }),
@@ -174,3 +244,120 @@ describe('executeUploads — context transmission', () => {
     expect(body.get('documentId')).toBeNull()
   })
 })
+
+// ---------------------------------------------------------------------------
+// Block resolution
+//
+// A form field path is an INSTANCE path — `content[1].gallery[0].poster` — and
+// carries no block type, because a block item holds its own `_type`. Resolving
+// an upload field inside a block therefore means reading that item.
+// ---------------------------------------------------------------------------
+
+describe('executeUploads — upload fields inside blocks', () => {
+  it('resolves upload.context for a field in the first block', async () => {
+    const { fn, bodies } = captureUploadField()
+    const uploads = new Map([['content[0].gallery[0].heroImage', imageUpload('h.png')]])
+
+    await executeUploads(uploads, fn, {
+      fields: blocksFields,
+      getFormValues: blocksFormValues,
+    })
+
+    expect(bodies[0]?.get('title')).toBe('Hello')
+  })
+
+  it('resolves upload.context for a field in a later block', async () => {
+    // Regression: block resolution used to match the first block declaring a
+    // field named by the next path segment. Both blocks declare `gallery`, so
+    // `photoBlock` won, `poster` was not found in it, and the declared context
+    // was dropped silently — no error, just a missing value the server-side
+    // beforeStore / afterStore hooks were relying on.
+    const { fn, bodies } = captureUploadField()
+    const uploads = new Map([['content[1].gallery[0].poster', imageUpload()]])
+
+    await executeUploads(uploads, fn, {
+      fields: blocksFields,
+      getFormValues: blocksFormValues,
+    })
+
+    expect(bodies[0]?.get('title')).toBe('Hello')
+  })
+
+  it('addresses a block item by stable id as well as position', async () => {
+    const { fn, bodies } = captureUploadField()
+    const uploads = new Map([['content[id=blk-video].gallery[0].poster', imageUpload()]])
+
+    await executeUploads(uploads, fn, {
+      fields: blocksFields,
+      getFormValues: blocksFormValues,
+    })
+
+    expect(bodies[0]?.get('title')).toBe('Hello')
+  })
+
+  it('still resolves when the addressed block item is missing from form state', async () => {
+    // Form state can lag a pending upload. The item is what supplies `_type`,
+    // so its absence drops us to the unique-match fallback — but the *field*
+    // is a declaration, and `poster` is declared in exactly one block, so the
+    // answer is unchanged. Staleness costs nothing here; genuine ambiguity
+    // would still return nothing (see the ambiguous case below).
+    const { fn, bodies } = captureUploadField()
+    const uploads = new Map([['content[7].gallery[0].poster', imageUpload()]])
+
+    await executeUploads(uploads, fn, {
+      fields: blocksFields,
+      getFormValues: blocksFormValues,
+    })
+
+    expect(bodies[0]?.get('title')).toBe('Hello')
+    expect(bodies[0]?.get('fieldPath')).toBe('content[7].gallery[0].poster')
+  })
+
+  it('falls back to a unique match when form values cannot disambiguate', async () => {
+    // Without data the block type is unknowable from the path. `poster` is
+    // declared in exactly one block, so the answer is still unambiguous.
+    const { fn, bodies } = captureUploadField()
+    const uploads = new Map([['content[1].gallery[0].poster', imageUpload()]])
+
+    await executeUploads(uploads, fn, {
+      fields: blocksFields,
+      getFormValues: () => ({ title: 'Hello' }),
+    })
+
+    expect(bodies[0]?.get('title')).toBe('Hello')
+  })
+
+  it('sends no context when the path genuinely identifies no single declaration', async () => {
+    // Same leaf name in both blocks and no data to choose between them. A
+    // guess would be wrong half the time, so nothing is sent.
+    const ambiguous: Field[] = [
+      { name: 'title', label: 'Title', type: 'text' },
+      {
+        name: 'content',
+        label: 'Content',
+        type: 'blocks',
+        blocks: [
+          {
+            blockType: 'aBlock',
+            fields: [
+              { name: 'shared', label: 'S', type: 'image', upload: { context: ['/title'] } },
+            ],
+          },
+          {
+            blockType: 'bBlock',
+            fields: [
+              { name: 'shared', label: 'S', type: 'image', upload: { context: ['/title'] } },
+            ],
+          },
+        ],
+      },
+    ]
+
+    const { fn, bodies } = captureUploadField()
+    const uploads = new Map([['content[1].shared', imageUpload()]])
+
+    await executeUploads(uploads, fn, { fields: ambiguous, getFormValues: () => ({ title: 'x' }) })
+
+    expect(bodies[0]?.get('title')).toBeNull()
+  })
+})

package/src/forms/upload-executor.ts

@@ -15,6 +15,7 @@
  */
 
 import type { Field, StoredFileValue, UploadConfig } from '@byline/core'
+import { type PathSegment, parseInstancePath } from '@byline/core'
 
 import { get as getNestedValue } from './nested-path'
 import type { UploadFieldFn } from '../fields/field-services-types'
@@ -149,13 +150,16 @@ function buildUploadFormData(
     formData.append('documentId', executionContext.documentId)
   }
 
+  // Resolved once per upload, before locating the field: a `blocks` hop in
+  // the path can only be resolved by reading the addressed item's `_type`.
+  const formValues = executionContext?.getFormValues?.()
+
   const contextPaths =
     executionContext?.fields != null
-      ? findUploadFieldByPath(executionContext.fields, fieldPath)?.context
+      ? findUploadFieldByPath(executionContext.fields, fieldPath, formValues)?.context
       : undefined
 
-  if (contextPaths && contextPaths.length > 0 && executionContext?.getFormValues) {
-    const formValues = executionContext.getFormValues()
+  if (contextPaths && contextPaths.length > 0 && formValues) {
     for (const contextPath of contextPaths) {
       const resolvedPath = resolveContextPath(fieldPath, contextPath)
       if (resolvedPath === undefined) continue
@@ -263,43 +267,100 @@ function isRelationEnvelope(value: unknown): value is { targetDocumentId: string
 
 /**
  * Locate the upload-capable `image | file` schema field addressed by a form
- * field path, walking `group` / `array` / `blocks` structures. Array indices
- * in the path (`files[2]`) map onto the schema's repeating field (`files`);
- * blocks are matched by trying each block's field set (block-type info is
- * not encoded in the path, so the first block containing the remaining path
- * wins — upload leaf names must be unique among a collection's
- * upload-capable fields anyway, per the server-side resolver's contract).
+ * field path, walking `group` / `array` / `blocks` structures.
+ *
+ * The path is an *instance* path (`content[1].gallery[0].poster`), so it
+ * carries no block type — a block item's type lives on the item itself, as
+ * `_type`. Passing `formValues` therefore lets a `blocks` hop be resolved
+ * exactly: read the addressed item, take its `_type`, descend into that
+ * block. Without form values the block type is genuinely unknowable from the
+ * path, so every block is tried and the result is accepted only when exactly
+ * one resolves — ambiguity returns `undefined` rather than a guess.
  */
 function findUploadFieldByPath(
   fields: readonly Field[],
-  fieldPath: string
+  fieldPath: string,
+  formValues?: Record<string, any>
 ): UploadConfig | undefined {
-  const segments = fieldPath.split('.').map((s) => s.replace(/\[\d+\]$/, ''))
+  const parsed = parseInstancePath(fieldPath)
+  if (!parsed.ok) return undefined
+  return resolveUploadConfig(fields, parsed.segments, formValues)
+}
 
-  let currentFields: readonly Field[] = fields
-  for (let i = 0; i < segments.length; i++) {
-    const name = segments[i]
-    const isLeaf = i === segments.length - 1
-    const field = currentFields.find((f) => f.name === name)
-    if (!field) return undefined
+/** Select the item an index / id segment addresses, when data is available. */
+function selectItem(value: unknown, segment: PathSegment): unknown {
+  if (!Array.isArray(value)) return undefined
+  if (segment.kind === 'index') return value[segment.index]
+  if (segment.kind === 'id') {
+    return value.find((item) => (item as { _id?: unknown } | null)?._id === segment.id)
+  }
+  return undefined
+}
+
+/**
+ * Walk instance-path segments against the schema, carrying the corresponding
+ * slice of form data alongside so `blocks` hops can read `_type`.
+ */
+function resolveUploadConfig(
+  fields: readonly Field[],
+  segments: readonly PathSegment[],
+  value: unknown
+): UploadConfig | undefined {
+  const head = segments[0]
+  if (head == null || head.kind !== 'field') return undefined
 
-    if (isLeaf) {
-      return field.type === 'image' || field.type === 'file' ? field.upload : undefined
+  const field = fields.find((candidate) => candidate.name === head.name)
+  if (field == null) return undefined
+
+  const fieldValue = (value as Record<string, unknown> | undefined)?.[head.name]
+  const rest = segments.slice(1)
+
+  if (rest.length === 0) {
+    return field.type === 'image' || field.type === 'file' ? field.upload : undefined
+  }
+
+  if (field.type === 'group') {
+    return resolveUploadConfig(field.fields, rest, fieldValue)
+  }
+
+  if (field.type === 'array') {
+    // An item selector may be absent when the caller addresses the array's
+    // child declaration rather than one item; the child fields are the same.
+    const selector = rest[0]
+    if (selector?.kind === 'index' || selector?.kind === 'id') {
+      return resolveUploadConfig(field.fields, rest.slice(1), selectItem(fieldValue, selector))
     }
+    return resolveUploadConfig(field.fields, rest, undefined)
+  }
 
-    if (field.type === 'group' || field.type === 'array') {
-      currentFields = field.fields
-      continue
+  if (field.type === 'blocks') {
+    const selector = rest[0]
+    const remainder = selector?.kind === 'index' || selector?.kind === 'id' ? rest.slice(1) : rest
+    const item =
+      selector?.kind === 'index' || selector?.kind === 'id'
+        ? selectItem(fieldValue, selector)
+        : undefined
+
+    const blockType = (item as { _type?: unknown } | undefined)?._type
+    if (typeof blockType === 'string') {
+      const block = field.blocks.find((candidate) => candidate.blockType === blockType)
+      return block == null ? undefined : resolveUploadConfig(block.fields, remainder, item)
     }
-    if (field.type === 'blocks') {
-      const remaining = segments[i + 1]
-      const block = field.blocks.find((b) => b.fields.some((f) => f.name === remaining))
-      if (!block) return undefined
-      currentFields = block.fields
-      continue
+
+    // No data to disambiguate. Try every block and accept a unique answer;
+    // two matches mean the path genuinely does not identify one declaration.
+    let found: UploadConfig | undefined
+    let matches = 0
+    for (const block of field.blocks) {
+      const result = resolveUploadConfig(block.fields, remainder, undefined)
+      if (result !== undefined) {
+        matches += 1
+        found = result
+      }
     }
-    return undefined
+    return matches === 1 ? found : undefined
   }
+
   return undefined
 }