@byline/admin 4.4.0 → 4.5.0

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

@@ -18,6 +18,8 @@ import { defaultScalarForField } from '../../fields/field-helpers'
 import { FieldRenderer } from '../../fields/field-renderer'
 import { SortableItem, StaticItem } from '../../fields/sortable-item'
 import { useFormContext } from '../../forms/form-context'
+import { hasExistingIdTargets } from '../../forms/nested-path'
+import { moveRepeatingItems, repeatingItemId, repeatingItemPath } from '../../forms/repeating-items'
 import styles from './array-field.module.css'
 
 // ---------------------------------------------------------------------------
@@ -55,7 +57,8 @@ export const ArrayField = ({
    */
   fieldAdmin?: Record<string, FieldAdminConfig>
 }) => {
-  const { appendPatch, getFieldValue, getFieldValues, setFieldStore } = useFormContext()
+  const { appendPatch, getFieldValue, getFieldValues, removePendingUploadsUnder, setFieldStore } =
+    useFormContext()
   const { t } = useTranslation('byline-admin')
   const [items, setItems] = useState<{ id: string; data: any }[]>([])
 
@@ -72,10 +75,10 @@ export const ArrayField = ({
       setItems(
         source.map((item: any) => ({
           id:
-            item && typeof item === 'object' && 'id' in item
-              ? String((item as { id: string }).id)
-              : item && typeof item === 'object' && '_id' in item
-                ? String((item as { _id: string })._id)
+            item && typeof item === 'object' && '_id' in item
+              ? String((item as { _id: string })._id)
+              : item && typeof item === 'object' && 'id' in item
+                ? String((item as { id: string }).id)
                 : crypto.randomUUID(),
           data: item,
         }))
@@ -85,23 +88,6 @@ export const ArrayField = ({
     }
   }, [defaultValue, getFieldValue, path])
 
-  /**
-   * Stable patch identity for an array item. Persisted items carry `_id`
-   * (the array-item identity from `store_meta`) — that is what the server's
-   * patch engine matches on (`applyArrayPatch`: `item._id === patch.itemId`),
-   * so it MUST be preferred here. `id` is accepted as a legacy/seed-data
-   * alias. Items added this session have neither (the storage layer assigns
-   * `_id` at write time), so fall back to the item's current index — the
-   * patch engine resolves a pure-integer itemId as an index fallback.
-   */
-  const patchItemId = (item: unknown, index: number): string => {
-    if (item && typeof item === 'object') {
-      if ('_id' in item) return String((item as { _id: string })._id)
-      if ('id' in item) return String((item as { id: string }).id)
-    }
-    return String(index)
-  }
-
   const handleDragEnd = ({
     moveFromIndex,
     moveToIndex,
@@ -109,23 +95,20 @@ export const ArrayField = ({
     moveFromIndex: number
     moveToIndex: number
   }) => {
-    setItems((prev) => moveItem(prev, moveFromIndex, moveToIndex))
     const currentArray = (getFieldValue(path) ?? defaultValue) as any[]
+    if (!Array.isArray(currentArray)) return
 
-    if (Array.isArray(currentArray)) {
-      const clampedFrom = Math.max(0, Math.min(moveFromIndex, currentArray.length - 1))
-      const clampedTo = Math.max(0, Math.min(moveToIndex, currentArray.length - 1))
-      if (clampedFrom === clampedTo) return
+    const move = moveRepeatingItems(currentArray, moveFromIndex, moveToIndex)
+    if (move == null) return
 
-      const item = currentArray[clampedFrom]
-
-      appendPatch({
-        kind: 'array.move',
-        path: path,
-        itemId: patchItemId(item, clampedFrom),
-        toIndex: clampedTo,
-      })
-    }
+    setItems((prev) => moveItem(prev, move.fromIndex, move.toIndex))
+    setFieldStore(path, move.items)
+    appendPatch({
+      kind: 'array.move',
+      path,
+      itemId: move.itemId,
+      toIndex: move.toIndex,
+    })
   }
 
   const handleAddItem = async (atIndex?: number) => {
@@ -153,6 +136,11 @@ export const ArrayField = ({
       }
     }
 
+    // Defaults may resolve asynchronously. If an enclosing stable-id item was
+    // removed in the meantime, do not append a structural patch that would
+    // recreate that missing parent on the server.
+    if (!hasExistingIdTargets(getFieldValues(), path)) return
+
     const currentArray = (getFieldValue(path) ?? defaultValue) as any[]
     const insertAt = atIndex != null ? atIndex : currentArray ? currentArray.length : 0
 
@@ -180,13 +168,15 @@ export const ArrayField = ({
     if (!Array.isArray(currentArray) || index < 0 || index >= currentArray.length) return
 
     const item = currentArray[index]
+    const itemPath = repeatingItemPath(path, item, index)
 
     setItems((prev) => prev.filter((_, i) => i !== index))
+    removePendingUploadsUnder(itemPath)
 
     appendPatch({
       kind: 'array.remove',
       path: path,
-      itemId: patchItemId(item, index),
+      itemId: repeatingItemId(item) ?? String(index),
     })
 
     const newArrayValue = [...currentArray]
@@ -200,7 +190,7 @@ export const ArrayField = ({
 
   const renderItem = (itemWrapper: { id: string; data: any }, index: number) => {
     const item = itemWrapper.data
-    const arrayElementPath = `${path}[${index}]`
+    const arrayElementPath = repeatingItemPath(path, item, index)
 
     if (!item || typeof item !== 'object') return null
 

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

@@ -31,6 +31,8 @@ import { defaultScalarForField } from '../../fields/field-helpers'
 import { GroupField } from '../../fields/group/group-field'
 import { SortableItem } from '../../fields/sortable-item'
 import { useFormContext } from '../../forms/form-context'
+import { hasExistingIdTargets } from '../../forms/nested-path'
+import { moveRepeatingItems, repeatingItemId, repeatingItemPath } from '../../forms/repeating-items'
 import styles from './blocks-field.module.css'
 
 // ---------------------------------------------------------------------------
@@ -54,7 +56,8 @@ export const BlocksField = ({
    */
   contentLocale?: string
 }) => {
-  const { appendPatch, getFieldValue, getFieldValues, setFieldStore } = useFormContext()
+  const { appendPatch, getFieldValue, getFieldValues, removePendingUploadsUnder, setFieldStore } =
+    useFormContext()
   const { t } = useTranslation('byline-admin')
   const [items, setItems] = useState<{ id: string; data: any }[]>([])
   const [showAddBlockModal, setShowAddBlockModal] = useState(false)
@@ -118,27 +121,20 @@ export const BlocksField = ({
     moveFromIndex: number
     moveToIndex: number
   }) => {
-    setItems((prev) => moveItem(prev, moveFromIndex, moveToIndex))
     const currentArray = (getFieldValue(path) ?? defaultValue) as any[]
+    if (!Array.isArray(currentArray)) return
 
-    if (Array.isArray(currentArray)) {
-      const clampedFrom = Math.max(0, Math.min(moveFromIndex, currentArray.length - 1))
-      const clampedTo = Math.max(0, Math.min(moveToIndex, currentArray.length - 1))
-      if (clampedFrom === clampedTo) return
-
-      const item = currentArray[clampedFrom]
-      const itemId =
-        item && typeof item === 'object' && '_id' in item
-          ? String((item as { _id: string })._id)
-          : String(clampedFrom)
-
-      appendPatch({
-        kind: 'array.move',
-        path: path,
-        itemId,
-        toIndex: clampedTo,
-      })
-    }
+    const move = moveRepeatingItems(currentArray, moveFromIndex, moveToIndex)
+    if (move == null) return
+
+    setItems((prev) => moveItem(prev, move.fromIndex, move.toIndex))
+    setFieldStore(path, move.items)
+    appendPatch({
+      kind: 'array.move',
+      path,
+      itemId: move.itemId,
+      toIndex: move.toIndex,
+    })
   }
 
   const handleAddItem = async (forcedVariantName?: string, atIndex?: number) => {
@@ -163,6 +159,8 @@ export const BlocksField = ({
       newItem[f.name] = await defaultScalarForField(f, getFieldValues)
     }
 
+    if (!hasExistingIdTargets(getFieldValues(), path)) return
+
     const currentArray = (getFieldValue(path) ?? defaultValue) as any[]
     const insertAt = atIndex != null ? atIndex : currentArray ? currentArray.length : 0
 
@@ -190,12 +188,11 @@ export const BlocksField = ({
     if (!Array.isArray(currentArray) || index < 0 || index >= currentArray.length) return
 
     const item = currentArray[index]
-    const itemId =
-      item && typeof item === 'object' && '_id' in item
-        ? String((item as { _id: string })._id)
-        : String(index)
+    const itemPath = repeatingItemPath(path, item, index)
+    const itemId = repeatingItemId(item) ?? String(index)
 
     setItems((prev) => prev.filter((_, i) => i !== index))
+    removePendingUploadsUnder(itemPath)
 
     appendPatch({
       kind: 'array.remove',
@@ -219,7 +216,7 @@ export const BlocksField = ({
 
   const renderItem = (itemWrapper: { id: string; data: any }, index: number) => {
     const item = itemWrapper.data
-    const arrayElementPath = `${path}[${index}]`
+    const arrayElementPath = repeatingItemPath(path, item, index)
 
     if (!item || typeof item !== 'object' || typeof item._type !== 'string') return null
 
@@ -233,9 +230,9 @@ export const BlocksField = ({
     // Render the block's children directly with arrayElementPath as the
     // path (not basePath).  FieldRenderer would append the group name
     // (e.g. "richTextBlock") producing paths like
-    // "content[0].richTextBlock.constrainedWidth", but the flat block
+    // "content[id=...].richTextBlock.constrainedWidth", but the flat block
     // shape stores fields directly on the item so the correct path is
-    // "content[0].constrainedWidth".
+    // "content[id=...].constrainedWidth".
     const body = (
       <GroupField
         key={subField.blockType}

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

@@ -24,7 +24,7 @@ const CodeEditor = React.lazy(() => import('./code-editor'))
 
 /**
  * Resolve the form-store path of a sibling field (same group/block/array
- * item scope). `content[0].code` + `language` → `content[0].language`;
+ * item scope). `content[id=x].code` + `language` → `content[id=x].language`;
  * a top-level `code` + `language` → `language`.
  */
 const siblingFieldPath = (fieldPath: string, siblingName: string): string => {

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

@@ -71,11 +71,15 @@ export const FileUploadField = ({
 
       const pendingValue = createPendingStoredFileValue(file, previewUrl)
 
-      addPendingUpload(fieldPath, {
-        file,
-        previewUrl,
-        collectionPath,
-      })
+      if (
+        !addPendingUpload(fieldPath, {
+          file,
+          previewUrl,
+          collectionPath,
+        })
+      ) {
+        return
+      }
 
       setStatus('idle')
       onUploaded(pendingValue)

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

@@ -18,7 +18,7 @@
  */
 
 import type { ChangeEvent, DragEvent } from 'react'
-import { useCallback, useRef, useState } from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 
 import {
   createPendingStoredFileValue,
@@ -62,12 +62,20 @@ export const ImageUploadField = ({
   accept = 'image/*',
 }: ImageUploadFieldProps) => {
   const inputRef = useRef<HTMLInputElement>(null)
+  const mountedRef = useRef(true)
   const [status, setStatus] = useState<SelectionStatus>('idle')
   const [errorMessage, setErrorMessage] = useState<string | null>(null)
   const [isDragOver, setIsDragOver] = useState(false)
   const { addPendingUpload } = useFormContext()
   const { t } = useTranslation('byline-admin')
 
+  useEffect(() => {
+    mountedRef.current = true
+    return () => {
+      mountedRef.current = false
+    }
+  }, [])
+
   // -------------------------------------------------------------------------
   // Core file selection logic (deferred upload)
   // -------------------------------------------------------------------------
@@ -90,6 +98,11 @@ export const ImageUploadField = ({
       // Extract image dimensions for the pending value
       const img = new Image()
       img.onload = () => {
+        if (!mountedRef.current) {
+          URL.revokeObjectURL(previewUrl)
+          return
+        }
+
         // SVGs without explicit width/height attrs (viewBox-only) report naturalWidth/Height = 0.
         // Skip dimensions when zero so they are stored as null (scalable, no fixed size).
         const w = img.naturalWidth
@@ -100,11 +113,15 @@ export const ImageUploadField = ({
         const pendingValue = createPendingStoredFileValue(file, previewUrl, dimensions)
 
         // Register the pending upload in form context
-        addPendingUpload(fieldPath, {
-          file,
-          previewUrl,
-          collectionPath,
-        })
+        if (
+          !addPendingUpload(fieldPath, {
+            file,
+            previewUrl,
+            collectionPath,
+          })
+        ) {
+          return
+        }
 
         setStatus('idle')
         onUploaded(pendingValue)
@@ -112,6 +129,7 @@ export const ImageUploadField = ({
 
       img.onerror = () => {
         URL.revokeObjectURL(previewUrl)
+        if (!mountedRef.current) return
         setStatus('error')
         setErrorMessage(t('fields.image.upload.errors.cannotRead'))
       }

package/src/forms/form-context.tsx

@@ -19,7 +19,12 @@ import type { DocumentPatch, FieldSetPatch } from '@byline/core/patches'
 // outright. A bare `from 'lodash-es'` import otherwise pools into a single
 // ~85KB chunk that leaks onto the public frontend bundle (form-context is
 // reachable from the layout graph).
-import { get as getNestedValue, set as setNestedValue } from './nested-path'
+import {
+  get as getNestedValue,
+  hasExistingIdTargets,
+  setWithResult as setNestedValue,
+} from './nested-path'
+import { deletePendingUploadsUnderPath } from './pending-uploads'
 import { useTrackedSlot } from './use-tracked-slot'
 
 interface FormError {
@@ -130,8 +135,9 @@ interface FormContextType {
   subscribeErrors: (listener: ErrorsListener) => () => void
   subscribeMeta: (listener: MetaListener) => () => void
   // Pending uploads (deferred until save)
-  addPendingUpload: (fieldPath: string, upload: PendingUpload) => void
+  addPendingUpload: (fieldPath: string, upload: PendingUpload) => boolean
   removePendingUpload: (fieldPath: string) => void
+  removePendingUploadsUnder: (itemPath: string) => void
   getPendingUploads: () => Map<string, PendingUpload>
   hasPendingUploads: () => boolean
   clearPendingUploads: () => void
@@ -284,13 +290,14 @@ export const FormProvider = ({
       const newFieldValues = { ...fieldValues.current }
 
       // Keep nested path values up to date for generic usage and patches.
-      setNestedValue(newFieldValues, name, value)
+      if (!setNestedValue(newFieldValues, name, value)) return false
 
       fieldValues.current = newFieldValues
       dirtyFields.current.add(name)
 
       notifyFieldListeners(name, value)
       notifyMetaListeners()
+      return true
     },
     [notifyFieldListeners, notifyMetaListeners]
   )
@@ -304,7 +311,7 @@ export const FormProvider = ({
 
   const setFieldValue = useCallback(
     (name: string, value: any) => {
-      updateFieldStoreInternal(name, value)
+      if (!updateFieldStoreInternal(name, value)) return
 
       const patch: FieldSetPatch = {
         kind: 'field.set',
@@ -421,6 +428,14 @@ export const FormProvider = ({
 
   const addPendingUpload = useCallback(
     (fieldPath: string, upload: PendingUpload) => {
+      // Image metadata extraction is asynchronous. If its containing item was
+      // removed while decoding, discard the late registration rather than
+      // allowing submit to recreate or overwrite an item through a stale path.
+      if (!hasExistingIdTargets(fieldValues.current, fieldPath)) {
+        URL.revokeObjectURL(upload.previewUrl)
+        return false
+      }
+
       // If there's an existing pending upload for this path, revoke its blob URL
       const existing = pendingUploadsRef.current.get(fieldPath)
       if (existing) {
@@ -429,6 +444,7 @@ export const FormProvider = ({
       pendingUploadsRef.current.set(fieldPath, upload)
       dirtyFields.current.add(fieldPath)
       notifyMetaListeners()
+      return true
     },
     [notifyMetaListeners]
   )
@@ -445,6 +461,16 @@ export const FormProvider = ({
     [notifyMetaListeners]
   )
 
+  const removePendingUploadsUnder = useCallback(
+    (itemPath: string) => {
+      const deleted = deletePendingUploadsUnderPath(pendingUploadsRef.current, itemPath, (url) =>
+        URL.revokeObjectURL(url)
+      )
+      if (deleted) notifyMetaListeners()
+    },
+    [notifyMetaListeners]
+  )
+
   const getPendingUploads = useCallback(() => {
     return new Map(pendingUploadsRef.current)
   }, [])
@@ -708,6 +734,7 @@ export const FormProvider = ({
         subscribeMeta,
         addPendingUpload,
         removePendingUpload,
+        removePendingUploadsUnder,
         getPendingUploads,
         hasPendingUploads,
         clearPendingUploads,

package/src/forms/form-renderer.tsx

@@ -551,6 +551,8 @@ const FormContent = ({
       noValidate
       onSubmit={handleSubmit}
       className={cx('byline-form', styles.form)}
+      inert={isUploading ? true : undefined}
+      aria-busy={isUploading}
     >
       <div className={cx('byline-form-heading-row', styles['heading-row'])}>
         <h1 className={cx('byline-form-heading', styles.heading)}>{heading}</h1>

package/src/forms/nested-path.test.node.ts

@@ -8,7 +8,7 @@
 
 import { describe, expect, it } from 'vitest'
 
-import { get, set, toPath } from './nested-path'
+import { get, hasExistingIdTargets, set, setWithResult, toPath } from './nested-path'
 
 describe('toPath', () => {
   it('parses dot and bracket notation', () => {
@@ -28,6 +28,22 @@ describe('get', () => {
     expect(get(obj, 'items[1].title')).toBe('y')
   })
 
+  it('selects nested repeating items by stable id', () => {
+    const value = {
+      content: [
+        {
+          _id: 'block-b',
+          gallery: [
+            { _id: 'image-1', alt: 'one' },
+            { _id: 'image-2', alt: 'two' },
+          ],
+        },
+      ],
+    }
+    expect(get(value, 'content[id=block-b].gallery[id=image-2].alt')).toBe('two')
+    expect(get(value, 'content[id=missing].gallery[id=image-2].alt')).toBeUndefined()
+  })
+
   it('preserves falsy values (does not conflate with missing)', () => {
     expect(get(obj, 'a.zero')).toBe(0)
     expect(get(obj, 'a.empty')).toBe('')
@@ -78,8 +94,41 @@ describe('set', () => {
     expect(Array.isArray(o.items)).toBe(true)
   })
 
+  it('writes through nested stable-id selectors without changing array order', () => {
+    const o = {
+      content: [
+        { _id: 'a', gallery: [{ _id: 'x', alt: 'keep' }] },
+        { _id: 'b', gallery: [{ _id: 'y', alt: 'old' }] },
+      ],
+    }
+    set(o, 'content[id=b].gallery[id=y].alt', 'new')
+    expect(o.content.map((item) => item._id)).toEqual(['a', 'b'])
+    expect(o.content[0]?.gallery[0]?.alt).toBe('keep')
+    expect(o.content[1]?.gallery[0]?.alt).toBe('new')
+  })
+
+  it('does not create a ghost item for an unknown stable id', () => {
+    const o = { items: [{ _id: 'a', title: 'keep' }] }
+    expect(setWithResult(o, 'items[id=gone].title', 'new')).toBe(false)
+    expect(o).toEqual({ items: [{ _id: 'a', title: 'keep' }] })
+
+    const missingContainer: { group: { items?: unknown[] } } = { group: {} }
+    expect(setWithResult(missingContainer, 'group.items[id=gone].title', 'new')).toBe(false)
+    expect(missingContainer).toEqual({ group: {} })
+  })
+
   it('returns the mutated root', () => {
     const o: any = {}
     expect(set(o, 'x', 1)).toBe(o)
   })
 })
+
+describe('hasExistingIdTargets', () => {
+  const value = { items: [{ _id: 'a', nested: [{ _id: 'b' }] }] }
+
+  it('accepts live nested identities and rejects removed ones', () => {
+    expect(hasExistingIdTargets(value, 'items[id=a].nested[id=b].title')).toBe(true)
+    expect(hasExistingIdTargets(value, 'items[id=a].nested[id=gone].title')).toBe(false)
+    expect(hasExistingIdTargets(value, 'title')).toBe(true)
+  })
+})

package/src/forms/nested-path.ts

@@ -8,7 +8,7 @@
  * Minimal nested `get`/`set` over string field paths, replacing lodash-es
  * (which pulled a large shared chunk onto unrelated bundles). Supports the
  * dot + bracket notation produced by the form field-path builders, e.g.
- * `title`, `a.b.c`, `items[0].title`, `blocks[2].nested[1].field`.
+ * `title`, `a.b.c`, `items[0].title`, `blocks[id=abc].nested[1].field`.
  *
  * `set` mirrors lodash semantics: it creates intermediate **arrays** when the
  * next path segment is a numeric index and plain **objects** otherwise, and it
@@ -19,42 +19,130 @@
  * form paths ever produce. See nested-path.test.node.ts for the covered cases.
  */
 
-const isIndexKey = (key: string): boolean => /^(?:0|[1-9]\d*)$/.test(key)
+import { type PathSegment, parseInstancePath } from '@byline/core'
 
 /** Split a field path into segments: `items[0].title` -> ['items','0','title']. */
 export function toPath(path: string): string[] {
   return path.match(/[^.[\]]+/g) ?? []
 }
 
+function selectId(value: unknown, id: string): number {
+  if (!Array.isArray(value)) return -1
+  return value.findIndex((item) => item != null && typeof item === 'object' && item._id === id)
+}
+
+function newContainer(next: PathSegment | undefined): any[] | Record<string, unknown> {
+  return next?.kind === 'index' || next?.kind === 'id' ? [] : {}
+}
+
 // Returns `any` (not `T | undefined`) to match lodash's loose `get` contract,
 // so existing call sites that treat the result as `any` keep type-checking.
 export function get<T = any>(object: unknown, path: string): T {
   if (object == null) return undefined as T
+  const parsed = parseInstancePath(path)
+  if (!parsed.ok) return undefined as T
+
   let current: any = object
-  for (const key of toPath(path)) {
+  for (const segment of parsed.segments) {
     if (current == null) return undefined as T
-    current = current[key]
+    if (segment.kind === 'field') {
+      current = current[segment.name]
+    } else if (segment.kind === 'index') {
+      current = current[segment.index]
+    } else if (segment.kind === 'id') {
+      const index = selectId(current, segment.id)
+      if (index === -1) return undefined as T
+      current = current[index]
+    } else {
+      return undefined as T
+    }
   }
   return current as T
 }
 
-export function set<T extends object>(object: T, path: string, value: unknown): T {
-  if (object == null) return object
-  const keys = toPath(path)
-  if (keys.length === 0) return object
+/** Whether every stable-id selector in a path still identifies a live item. */
+export function hasExistingIdTargets(object: unknown, path: string): boolean {
+  const parsed = parseInstancePath(path)
+  if (!parsed.ok) return false
+
+  let current: any = object
+  for (const segment of parsed.segments) {
+    if (segment.kind === 'field') {
+      current = current?.[segment.name]
+    } else if (segment.kind === 'index') {
+      current = current?.[segment.index]
+    } else if (segment.kind === 'id') {
+      const index = selectId(current, segment.id)
+      if (index === -1) return false
+      current = current[index]
+    } else {
+      return false
+    }
+  }
+  return true
+}
+
+/** Set a path and report whether all stable-id selectors resolved. */
+export function setWithResult<T extends object>(object: T, path: string, value: unknown): boolean {
+  if (object == null) return false
+  const parsed = parseInstancePath(path)
+  if (!parsed.ok || parsed.segments.length === 0) return false
 
   let current: any = object
-  for (let i = 0; i < keys.length - 1; i++) {
-    // Bounded by the loop condition, so these indexed reads are always defined.
-    const key = keys[i] as string
-    const nextKey = keys[i + 1] as string
-    const existing = current[key]
-    if (existing == null || typeof existing !== 'object') {
-      // Create the container the next segment needs: array for an index, else object.
-      current[key] = isIndexKey(nextKey) ? [] : {}
+  for (let i = 0; i < parsed.segments.length; i++) {
+    const segment = parsed.segments[i] as PathSegment
+    const next = parsed.segments[i + 1]
+    const last = i === parsed.segments.length - 1
+
+    if (segment.kind === 'field') {
+      if (last) {
+        current[segment.name] = value
+        return true
+      }
+      const existing = current[segment.name]
+      if (existing == null || typeof existing !== 'object') {
+        // Do not create a partial container on the way to an item identity
+        // that may no longer exist. Normal non-ID lodash-style writes still
+        // create their intermediate structure below.
+        if (parsed.segments.slice(i + 1).some((candidate) => candidate.kind === 'id')) return false
+        current[segment.name] = newContainer(next)
+      }
+      current = current[segment.name]
+      continue
     }
-    current = current[key]
+
+    if (segment.kind === 'index') {
+      if (!Array.isArray(current)) return false
+      if (last) {
+        current[segment.index] = value
+        return true
+      }
+      const existing = current[segment.index]
+      if (existing == null || typeof existing !== 'object') {
+        if (parsed.segments.slice(i + 1).some((candidate) => candidate.kind === 'id')) return false
+        current[segment.index] = newContainer(next)
+      }
+      current = current[segment.index]
+      continue
+    }
+
+    if (segment.kind === 'id') {
+      const index = selectId(current, segment.id)
+      if (index === -1) return false
+      if (last) {
+        current[index] = value
+        return true
+      }
+      current = current[index]
+      continue
+    }
+
+    return false
   }
-  current[keys[keys.length - 1] as string] = value
+  return false
+}
+
+export function set<T extends object>(object: T, path: string, value: unknown): T {
+  setWithResult(object, path, value)
   return object
 }