@byline/core 6.8.0 → 6.10.0

package/dist/services/document-lifecycle/merge-write-locale.js

@@ -0,0 +1,53 @@
+/**
+ * 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
+ */
+/** Preserve other locales by item identity after unavailable blocks were compacted.
+ * Incoming structure is authoritative; never carry old positional store rows forward.
+ */
+export function mergeWriteLocale(fields, previous, incoming, locale) {
+    const result = {};
+    for (const field of fields) {
+        const value = incoming[field.name];
+        const old = previous?.[field.name];
+        if (field.type === 'group') {
+            if (value != null)
+                result[field.name] = mergeWriteLocale(field.fields, old ?? {}, value, locale);
+        }
+        else if (field.type === 'array' || field.type === 'blocks') {
+            if (!Array.isArray(value))
+                continue;
+            result[field.name] = value.map((item, index) => {
+                // Hand-built payloads may omit identity metadata. Match their compacted
+                // position, as ordinary locale writes do; an explicit ID stays authoritative.
+                const prior = Array.isArray(old)
+                    ? item._id != null
+                        ? old.find((candidate) => candidate._id === item._id)
+                        : old[index]
+                    : undefined;
+                const childFields = field.type === 'array'
+                    ? field.fields
+                    : field.blocks.find((block) => block.blockType === item._type)?.fields;
+                return {
+                    ...(item._id != null ? { _id: item._id } : {}),
+                    ...(field.type === 'blocks' ? { _type: item._type } : {}),
+                    ...mergeWriteLocale(childFields ?? [], prior ?? {}, item, locale),
+                };
+            });
+        }
+        else if (field.localized) {
+            const localized = { ...old };
+            delete localized[locale];
+            if (value !== undefined)
+                localized[locale] = value;
+            if (Object.keys(localized).length > 0)
+                result[field.name] = localized;
+        }
+        else if (value !== undefined)
+            result[field.name] = value;
+    }
+    return result;
+}

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

@@ -6,6 +6,7 @@
  * Copyright (c) Infonomic Company Limited
  */
 import type { IDocumentCommands } from '../../@types/index.js';
+import type { UnavailableBlock } from '../../storage/storage-restore.js';
 import type { DocumentLifecycleContext } from './context.js';
 type AdapterVersionWrite = Parameters<IDocumentCommands['createDocumentVersion']>[0];
 type LifecycleOwnedWriteKeys = 'collectionId' | 'collectionVersion' | 'collectionConfig' | 'createdBy';
@@ -25,5 +26,7 @@ export declare function persistInitialDocumentVersion(ctx: DocumentLifecycleCont
  * publication schedule atomically. All operation-specific preparation and
  * hook sequencing remains in the caller.
  */
-export declare function persistExistingDocumentVersion(ctx: DocumentLifecycleContext, write: ExistingDocumentVersionWrite): ReturnType<IDocumentCommands['createDocumentVersion']>;
+export declare function persistExistingDocumentVersion(ctx: DocumentLifecycleContext, write: ExistingDocumentVersionWrite, previousRead?: {
+    unavailableBlocks?: readonly UnavailableBlock[];
+} | null): ReturnType<IDocumentCommands['createDocumentVersion']>;
 export {};

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

@@ -8,6 +8,7 @@
 import { assertDocumentFields } from '../../validation/document-fields.js';
 import { requireAuditCapability } from './audit.js';
 import { actorId } from './internals.js';
+import { mergeWriteLocale } from './merge-write-locale.js';
 import { commitContentVersionWithScheduleSuspension } from './publish-schedule-consistency.js';
 import { normalizeDocumentVersionParentError } from './stale-document.js';
 import { appendTreeRoot } from './tree.js';
@@ -73,8 +74,29 @@ export async function persistInitialDocumentVersion(ctx, write) {
  * publication schedule atomically. All operation-specific preparation and
  * hook sequencing remains in the caller.
  */
-export function persistExistingDocumentVersion(ctx, write) {
+export async function persistExistingDocumentVersion(ctx, write, previousRead) {
     assertWritableContent(ctx, write);
+    // Single-locale storage writes copy other locales' positional rows forward.
+    // After compaction those rows can resurrect unavailable blocks or attach a
+    // translation to the wrong survivor. Rebuild all locales by item identity.
+    if (previousRead?.unavailableBlocks?.length &&
+        write.previousVersionId &&
+        write.locale &&
+        write.locale !== 'all') {
+        const previous = await ctx.db.queries.documents.getDocumentByVersion({
+            document_version_id: write.previousVersionId,
+            document_id: write.documentId,
+            collection_id: ctx.collectionId,
+            locale: 'all',
+        });
+        if (previous?.unavailableBlocks?.length) {
+            write = {
+                ...write,
+                documentData: mergeWriteLocale(ctx.definition.fields, previous.fields, write.documentData, write.locale),
+                locale: 'all',
+            };
+        }
+    }
     return commitContentVersionWithScheduleSuspension({
         ctx,
         documentId: write.documentId,

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

@@ -102,7 +102,7 @@ async function replaceFields(ctx, params, policy) {
                 status: policy === 'preserve' ? preservedStatus(ctx, locked.status) : defaultStatus,
                 locale: requestLocale,
                 previousVersionId,
-            });
+            }, latest);
             if (policy === 'preserve' && locked.status === 'published') {
                 await db.commands.documents.archivePublishedVersions({
                     document_id: params.documentId,
@@ -212,7 +212,7 @@ export async function updateDocumentWithPatches(ctx, params) {
                 status: defaultStatus,
                 locale: requestLocale,
                 previousVersionId,
-            });
+            }, latest);
             await selfHealTreePlacement(ctx, params.documentId);
             return { value: { result, systemFields }, changed: true };
         }).catch((err) => rethrowPathConflict(db, err, pathForCommand ?? '', sourceLocale, 'update'));

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

@@ -2857,7 +2857,7 @@ describe('Document lifecycle service', () => {
             expect(call.path).toBe('hello-world-copy');
             expect(result.newPath).toBe('hello-world-copy');
         });
-        it('strips _id and _type metadata from blocks and array items so the new doc gets fresh identities', async () => {
+        it('strips _id identities but preserves block types when duplicating', async () => {
             const mocks = createMockDb();
             setupSource(mocks, {
                 sourceFields: {
@@ -2881,7 +2881,9 @@ describe('Document lifecycle service', () => {
             const call = mocks.createDocumentVersion.mock.calls[0]?.[0];
             const sections = call.documentData.sections;
             expect(sections[0]._id).toBeUndefined();
-            expect(sections[0]._type).toBeUndefined();
+            expect(sections[0]._type).toBe('section');
+            expect(sections[0].blocks[0]._type).toBe('photoBlock');
+            expect(sections[0].blocks[1]._type).toBe('textBlock');
             expect(sections[0].blocks[0]._id).toBeUndefined();
             expect(sections[0].blocks[1]._id).toBeUndefined();
             // Content survives — only meta is stripped.

package/dist/services/singleton-lifecycle/copy-to-locale.js

@@ -98,7 +98,7 @@ export async function copySingletonToLocale(ctx, params) {
                             status: getDefaultStatus(definition),
                             locale: params.targetLocale,
                             previousVersionId: slot.currentVersion?.document_version_id,
-                        });
+                        }, existingTarget ?? source);
                     },
                 };
             },

package/dist/services/singleton-lifecycle/update.js

@@ -139,7 +139,7 @@ export async function updateSingleton(ctx, params) {
                 action: 'update',
                 documentId: mappedDocumentId,
                 previousVersionId,
-            });
+            }, observed.current);
         const documentId = extractDocumentId(result.document);
         const documentVersionId = extractVersionId(result.document);
         if (!documentId || !documentVersionId)

package/dist/storage/index.d.ts

@@ -10,7 +10,7 @@ export { assertDocumentVersionParent, type DocumentVersionParentAssertion, type
 export { ALL_STORE_TYPES, type FieldStoreKind, type FieldStoreMapping, fieldTypeToStore, fieldTypeToStoreType, type StoreType, } from './field-store-map.js';
 export { deriveVersionLocaleLedger, resolveLocaleVisibility, resolveReadLocale, type VersionLocaleLedger, } from './locale-resolution.js';
 export { flattenFieldSetData } from './storage-flatten.js';
-export { extractFlattenedFieldValue, type RestoreResult, restoreFieldSetData, } from './storage-restore.js';
+export { extractFlattenedFieldValue, type RestoreResult, restoreFieldSetData, type UnavailableBlock, } from './storage-restore.js';
 export { resolveStoreTypes } from './storage-utils.js';
 export { type ColumnDef, storeColumnManifest, storeTableNames } from './store-manifest.js';
 export type { FlattenedFieldValue, UnifiedFieldValue } from './storage-row-types.js';

package/dist/storage/storage-flatten.js

@@ -101,8 +101,14 @@ function* flattenFieldDataGen(field, data, locale, field_path) {
     else if (field.type === 'blocks') {
         const items = data;
         for (let i = 0; i < items.length; i++) {
-            // biome-ignore lint/style/noNonNullAssertion: i is always in-bounds
-            const { _id, _type, ...item_data } = items[i];
+            const item = items[i];
+            if (item == null || typeof item !== 'object' || Array.isArray(item)) {
+                throw ERR_DATABASE({
+                    message: `${field_path.join('.')}[${i}]: Block item is missing or must be an object`,
+                    details: { fieldPath: field_path, index: i },
+                });
+            }
+            const { _id, _type, ...item_data } = item;
             const item_path = [...field_path, `${i}`, _type];
             const block = field.blocks.find((f) => f.blockType === _type);
             if (!block) {

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

@@ -7,15 +7,24 @@
  */
 import type { FieldSet } from '../@types/index.js';
 import type { FlattenedFieldValue, UnifiedFieldValue } from './storage-row-types.js';
+export interface UnavailableBlock {
+    /** Instance path in the compacted document, e.g. sections[0].body. */
+    fieldPath: string;
+    /** Position in the stored blocks array before compaction. */
+    storedIndex: number;
+    blockType: string;
+    id?: string;
+}
 export interface RestoreResult {
     data: any;
     warnings: string[];
+    unavailableBlocks: UnavailableBlock[];
 }
 /**
  * Main entrypoint for restoring a document's field data from flattened form
  * back into the original nested structure.
  *
- * Always returns `{ data, warnings }`. Warnings carry per-row reasons (e.g.
+ * Always returns `{ data, warnings, unavailableBlocks }`. Warnings carry per-row reasons (e.g.
  * "Invalid block index 'undefined'") that are typically the result of a
  * collection schema change leaving orphan rows behind. Callers decide what
  * to do with them — strict reads reject any non-empty `warnings`, lenient
@@ -24,5 +33,9 @@ export interface RestoreResult {
  * @param fields - The field definitions for the collection.
  * @param flattenedData - The flattened field data to restore.
  */
-export declare const restoreFieldSetData: (fields: FieldSet, flattenedData: FlattenedFieldValue[], resolveLocale?: string) => RestoreResult;
+export declare const restoreFieldSetData: (fields: FieldSet, flattenedData: FlattenedFieldValue[], resolveLocale?: string, identity?: {
+    collectionPath: string;
+    documentId: string;
+    versionId: string;
+}) => RestoreResult;
 export declare const extractFlattenedFieldValue: (unifiedValue: UnifiedFieldValue) => FlattenedFieldValue;

package/dist/storage/storage-restore.js

@@ -8,11 +8,16 @@
 import { RESERVED_FIELD_NAMES } from '../config/validate-collections.js';
 import { ERR_DATABASE } from '../lib/errors.js';
 import { getLogger } from '../lib/logger.js';
+// Shared across duplicate server module graphs, just like the logger registry.
+const loggedVersionsKey = Symbol.for('byline.unavailable-block-versions');
+const processState = globalThis;
+processState[loggedVersionsKey] ??= new Set();
+const loggedVersions = processState[loggedVersionsKey];
 /**
  * Main entrypoint for restoring a document's field data from flattened form
  * back into the original nested structure.
  *
- * Always returns `{ data, warnings }`. Warnings carry per-row reasons (e.g.
+ * Always returns `{ data, warnings, unavailableBlocks }`. Warnings carry per-row reasons (e.g.
  * "Invalid block index 'undefined'") that are typically the result of a
  * collection schema change leaving orphan rows behind. Callers decide what
  * to do with them — strict reads reject any non-empty `warnings`, lenient
@@ -21,9 +26,10 @@ import { getLogger } from '../lib/logger.js';
  * @param fields - The field definitions for the collection.
  * @param flattenedData - The flattened field data to restore.
  */
-export const restoreFieldSetData = (fields, flattenedData, resolveLocale) => {
+export const restoreFieldSetData = (fields, flattenedData, resolveLocale, identity) => {
     const result = {};
     const warnings = [];
+    const unavailableByArray = new Map();
     for (const item of flattenedData) {
         // biome-ignore lint/style/noNonNullAssertion: TODO: put in a proper check here?
         const fieldName = item.field_path[0];
@@ -38,7 +44,7 @@ export const restoreFieldSetData = (fields, flattenedData, resolveLocale) => {
         if (!field) {
         }
         else {
-            result[fieldName] = restoreFieldData(field, result[fieldName], item, 1, warnings, resolveLocale);
+            result[fieldName] = restoreFieldData(field, result[fieldName], item, 1, warnings, unavailableByArray, resolveLocale);
         }
     }
     // Array/blocks/group/hasMany-relation fixup — a required list-shaped field
@@ -54,17 +60,52 @@ export const restoreFieldSetData = (fields, flattenedData, resolveLocale) => {
             result[field.name] = result[field.name] || {};
         }
     }
-    return { data: result, warnings };
+    const unavailableBlocks = [];
+    // Finish only after all rows (including identity metadata) have been read.
+    // Walk parents before children so nested report paths use compacted indices.
+    const finish = (fields, value, prefix = '') => {
+        for (const field of fields) {
+            const path = prefix ? `${prefix}.${field.name}` : field.name;
+            const child = value?.[field.name];
+            if (field.type === 'group' && child)
+                finish(field.fields, child, path);
+            if ((field.type === 'blocks' || field.type === 'array') && Array.isArray(child)) {
+                for (const issue of [...(unavailableByArray.get(child)?.values() ?? [])].sort((a, b) => a.storedIndex - b.storedIndex))
+                    unavailableBlocks.push({ fieldPath: path, ...issue });
+                const compacted = child.filter((item) => item != null);
+                value[field.name] = compacted;
+                compacted.forEach((item, index) => {
+                    const itemFields = field.type === 'array'
+                        ? field.fields
+                        : field.blocks.find((block) => block.blockType === item._type)?.fields;
+                    if (itemFields)
+                        finish(itemFields, item, `${path}[${index}]`);
+                });
+            }
+        }
+    };
+    finish(fields, result);
+    if (identity && unavailableBlocks.length > 0) {
+        const key = JSON.stringify([identity.collectionPath, identity.documentId, identity.versionId]);
+        if (!loggedVersions.has(key)) {
+            loggedVersions.add(key);
+            getLogger().warn({
+                ...identity,
+                blockTypes: [...new Set(unavailableBlocks.map((issue) => issue.blockType))],
+            }, 'Document contains unavailable blocks; saving content will remove them');
+        }
+    }
+    return { data: result, warnings, unavailableBlocks };
 };
-const restoreFieldData = (field, target, data, pathIndex, warnings, resolveLocale) => {
+const restoreFieldData = (field, target, data, pathIndex, warnings, unavailableByArray, resolveLocale) => {
     if (field.type === 'group') {
-        return restoreGroupFieldData(field, target, data, pathIndex, warnings, resolveLocale);
+        return restoreGroupFieldData(field, target, data, pathIndex, warnings, unavailableByArray, resolveLocale);
     }
     else if (field.type === 'array') {
-        return restoreArrayFieldData(field, target, data, pathIndex, warnings, resolveLocale);
+        return restoreArrayFieldData(field, target, data, pathIndex, warnings, unavailableByArray, resolveLocale);
     }
     else if (field.type === 'blocks') {
-        return restoreBlocksFieldData(field, target, data, pathIndex, warnings, resolveLocale);
+        return restoreBlocksFieldData(field, target, data, pathIndex, warnings, unavailableByArray, resolveLocale);
     }
     else if (field.type === 'relation' && field.hasMany) {
         return restoreMultiRelationFieldData(target, data, pathIndex, warnings);
@@ -95,7 +136,7 @@ const restoreFieldData = (field, target, data, pathIndex, warnings, resolveLocal
     }
     return target;
 };
-const restoreGroupFieldData = (field, target, data, pathIndex, warnings, resolveLocale) => {
+const restoreGroupFieldData = (field, target, data, pathIndex, warnings, unavailableByArray, resolveLocale) => {
     if (pathIndex >= data.field_path.length) {
         warnings.push(`Path ended unexpectedly while restoring group: ${data.field_path.join('.')}`);
         return target;
@@ -108,10 +149,10 @@ const restoreGroupFieldData = (field, target, data, pathIndex, warnings, resolve
         return target;
     }
     target = target || {};
-    target[fieldName] = restoreFieldData(subField, target[fieldName], data, pathIndex + 1, warnings, resolveLocale);
+    target[fieldName] = restoreFieldData(subField, target[fieldName], data, pathIndex + 1, warnings, unavailableByArray, resolveLocale);
     return target;
 };
-const restoreArrayFieldData = (field, target, data, pathIndex, warnings, resolveLocale) => {
+const restoreArrayFieldData = (field, target, data, pathIndex, warnings, unavailableByArray, resolveLocale) => {
     if (pathIndex >= data.field_path.length) {
         warnings.push(`Path ended unexpectedly while restoring array: ${data.field_path.join('.')}`);
         return target;
@@ -140,10 +181,10 @@ const restoreArrayFieldData = (field, target, data, pathIndex, warnings, resolve
         // Sub-field was removed from the schema; silently skip orphaned rows.
         return target;
     }
-    target[arrayIndex][fieldName] = restoreFieldData(subField, target[arrayIndex][fieldName], data, pathIndex + 2, warnings, resolveLocale);
+    target[arrayIndex][fieldName] = restoreFieldData(subField, target[arrayIndex][fieldName], data, pathIndex + 2, warnings, unavailableByArray, resolveLocale);
     return target;
 };
-const restoreBlocksFieldData = (field, target, data, pathIndex, warnings, resolveLocale) => {
+const restoreBlocksFieldData = (field, target, data, pathIndex, warnings, unavailableByArray, resolveLocale) => {
     const arrayIndex = Number.parseInt(data.field_path[pathIndex] ?? '', 10);
     if (Number.isNaN(arrayIndex) || arrayIndex < 0) {
         warnings.push(`Invalid block index '${data.field_path[pathIndex]}' in path ${data.field_path.join('.')}`);
@@ -156,7 +197,17 @@ const restoreBlocksFieldData = (field, target, data, pathIndex, warnings, resolv
     }
     const block = field.blocks.find((f) => f.blockType === blockType);
     if (block == null) {
-        // Block type was removed from the schema; silently skip orphaned rows.
+        target = target || [];
+        let issues = unavailableByArray.get(target);
+        if (!issues) {
+            issues = new Map();
+            unavailableByArray.set(target, issues);
+        }
+        const issue = issues.get(arrayIndex) ?? { storedIndex: arrayIndex, blockType };
+        if (data.field_type === 'meta' && pathIndex + 2 === data.field_path.length) {
+            issue.id = data.item_id;
+        }
+        issues.set(arrayIndex, issue);
         return target;
     }
     target = target || [];
@@ -178,7 +229,7 @@ const restoreBlocksFieldData = (field, target, data, pathIndex, warnings, resolv
         // Sub-field was removed from the schema; silently skip orphaned rows.
         return target;
     }
-    target[arrayIndex][fieldName] = restoreFieldData(subField, target[arrayIndex][fieldName], data, pathIndex + 3, warnings, resolveLocale);
+    target[arrayIndex][fieldName] = restoreFieldData(subField, target[arrayIndex][fieldName], data, pathIndex + 3, warnings, unavailableByArray, resolveLocale);
     return target;
 };
 const restoreMultiRelationFieldData = (target, data, pathIndex, warnings) => {

package/dist/storage/unavailable-blocks.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/storage/unavailable-blocks.test.node.js

@@ -0,0 +1,132 @@
+/**
+ * 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, vi } from 'vitest';
+import { getLogger } from '../lib/logger.js';
+import { applyPatches } from '../patches/apply-patches.js';
+import { validateDocumentFields } from '../validation/document-fields.js';
+import { flattenFieldSetData } from './storage-flatten.js';
+import { restoreFieldSetData } from './storage-restore.js';
+const logger = vi.hoisted(() => ({ warn: vi.fn() }));
+vi.mock('../lib/logger.js', () => ({ getLogger: () => logger }));
+const live = { blockType: 'live', fields: [{ name: 'text', type: 'text' }] };
+const retired = { ...live, blockType: 'retired' };
+const blocks = (optional = false) => ({
+    name: 'content',
+    type: 'blocks',
+    optional,
+    blocks: [live, retired],
+});
+const item = (_type, i) => ({ _id: `item-${i}`, _type, text: `${_type}-${i}` });
+describe('unavailable blocks', () => {
+    for (const optional of [false, true]) {
+        for (const types of [
+            ['retired', 'live'],
+            ['live', 'retired', 'live'],
+            ['live', 'retired'],
+            ['retired'],
+            ['retired', 'retired', 'live'],
+        ]) {
+            it(`compacts ${types.join(',')} (optional=${optional}) with an independent report`, () => {
+                const before = [blocks(optional)];
+                const after = [{ ...blocks(optional), blocks: [live] }];
+                const original = { content: types.map(item) };
+                const rows = flattenFieldSetData(before, original, 'en');
+                const restored = restoreFieldSetData(after, rows, 'en');
+                expect(restored.warnings).toEqual([]);
+                expect(restored.unavailableBlocks).toEqual(types.flatMap((type, storedIndex) => type === 'retired'
+                    ? [{ fieldPath: 'content', storedIndex, blockType: type, id: `item-${storedIndex}` }]
+                    : []));
+                expect(restored.data.content).toEqual(original.content.filter((item) => item._type === 'live'));
+                for (const data of [restored.data, JSON.parse(JSON.stringify(restored.data))]) {
+                    expect(validateDocumentFields(after, data)).toEqual([]);
+                    const saved = restoreFieldSetData(after, flattenFieldSetData(after, data, 'en'), 'en');
+                    expect(saved.unavailableBlocks).toEqual([]);
+                    expect(saved.data.content ?? []).toEqual(restored.data.content);
+                }
+            });
+        }
+    }
+    it('reports groups, arrays and nested blocks using compacted parent indices', () => {
+        const before = [
+            { name: 'group', type: 'group', fields: [blocks()] },
+            { name: 'sections', type: 'array', fields: [blocks()] },
+            {
+                name: 'outer',
+                type: 'blocks',
+                blocks: [retired, { blockType: 'container', fields: [blocks()] }],
+            },
+        ];
+        const after = [
+            { name: 'group', type: 'group', fields: [{ ...blocks(), blocks: [live] }] },
+            { name: 'sections', type: 'array', fields: [{ ...blocks(), blocks: [live] }] },
+            {
+                name: 'outer',
+                type: 'blocks',
+                blocks: [{ blockType: 'container', fields: [{ ...blocks(), blocks: [live] }] }],
+            },
+        ];
+        const content = [item('retired', 0), item('live', 1)];
+        const rows = flattenFieldSetData(before, {
+            group: { content },
+            sections: [{ content }],
+            outer: [item('retired', 0), { _type: 'container', content }],
+        }, 'en');
+        const result = restoreFieldSetData(after, rows.reverse(), 'en');
+        expect(result.unavailableBlocks.map((issue) => issue.fieldPath)).toEqual([
+            'group.content',
+            'sections[0].content',
+            'outer',
+            'outer[0].content',
+        ]);
+        expect(result.warnings).toEqual([]);
+        expect(result.data.outer[0].content).toEqual([item('live', 1)]);
+    });
+    it('applies a positional patch to a surviving block after the missing card', () => {
+        const before = [blocks()];
+        const after = [{ ...blocks(), blocks: [live] }];
+        const source = { content: ['retired', 'live', 'live'].map(item) };
+        const { data } = restoreFieldSetData(after, flattenFieldSetData(before, source, 'en'));
+        const definition = {
+            path: 'pages',
+            labels: { singular: 'Page', plural: 'Pages' },
+            fields: after,
+        };
+        const patched = applyPatches(definition, data, [
+            { kind: 'field.set', path: 'content[1].text', value: 'edited' },
+        ]);
+        expect(patched.errors).toEqual([]);
+        const saved = restoreFieldSetData(after, flattenFieldSetData(after, patched.doc, 'en'));
+        expect(saved.data.content.map((item) => [item._id, item.text])).toEqual([
+            ['item-1', 'live-1'],
+            ['item-2', 'edited'],
+        ]);
+    });
+    it.each([new Array(1), [null], [undefined], [42], [[]]].map((content) => ({ content })))('rejects malformed items without a destructure crash: $content', ({ content }) => {
+        expect(validateDocumentFields([blocks()], { content })).not.toEqual([]);
+        expect(() => flattenFieldSetData([blocks()], { content }, 'en')).toThrow(/Block item is missing or must be an object/);
+    });
+    it('logs once per document version without adding a strict-read warning', () => {
+        const spy = vi.spyOn(getLogger(), 'warn').mockImplementation(() => { });
+        try {
+            const rows = flattenFieldSetData([blocks()], { content: [item('retired', 0)] }, 'en');
+            const identity = { collectionPath: 'pages', documentId: crypto.randomUUID(), versionId: 'v1' };
+            for (let i = 0; i < 2; i++)
+                expect(restoreFieldSetData([{ ...blocks(), blocks: [live] }], rows, 'en', identity).warnings).toEqual([]);
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect(spy).toHaveBeenCalledWith({ ...identity, blockTypes: ['retired'] }, expect.any(String));
+            restoreFieldSetData([{ ...blocks(), blocks: [live] }], rows, 'en', {
+                ...identity,
+                versionId: 'v2',
+            });
+            expect(spy).toHaveBeenCalledTimes(2);
+        }
+        finally {
+            spy.mockRestore();
+        }
+    });
+});

package/dist/validation/document-fields.js

@@ -119,13 +119,16 @@ export function validateDocumentFields(fields, data, options = {}) {
                     if (field.validation?.maxLength != null && value.length > field.validation.maxLength)
                         add(path, `${label} allows at most ${field.validation.maxLength} items`);
                 }
-                value.forEach((item, index) => {
+                for (let index = 0; index < value.length; index++) {
+                    const item = value[index];
                     const itemPath = record(item) && typeof item._id === 'string' && /^[\w-]+$/.test(item._id)
                         ? `${path}[id=${item._id}]`
                         : `${path}[${index}]`;
                     if (!record(item)) {
-                        add(itemPath, 'Item must be an object');
-                        return;
+                        add(itemPath, field.type === 'blocks'
+                            ? 'Block item is missing or must be an object'
+                            : 'Item must be an object');
+                        continue;
                     }
                     if (field.type === 'array')
                         visit(field.fields, item, itemPath);
@@ -136,7 +139,7 @@ export function validateDocumentFields(fields, data, options = {}) {
                         else
                             visit(block.fields, item, itemPath);
                     }
-                });
+                }
             }
         }
         else {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/core",
   "private": false,
   "license": "MPL-2.0",
-  "version": "6.8.0",
+  "version": "6.10.0",
   "engines": {
     "node": ">=22.22.2"
   },
@@ -82,7 +82,7 @@
     "dist"
   ],
   "dependencies": {
-    "@byline/auth": "6.8.0",
+    "@byline/auth": "6.10.0",
     "dotenv": "^18.0.8",
     "pino": "^10.4.0",
     "sharp": "^0.35.5",
@@ -90,15 +90,15 @@
     "zod": "^4.6.7"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.15",
+    "@biomejs/biome": "2.6.2",
     "@types/node": "^26.6.5",
-    "chokidar": "^5.0.0",
+    "chokidar": "^6.0.0",
     "chokidar-cli": "^3.0.0",
     "npm-run-all": "^4.1.5",
-    "tsc-alias": "^1.9.7",
+    "tsc-alias": "^1.9.8",
     "tsx": "^4.23.15",
     "typescript": "^7.0.2",
-    "vitest": "^5.0.4"
+    "vitest": "^5.0.5"
   },
   "publishConfig": {
     "access": "public",