@byline/core 6.7.2 → 6.9.0

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

@@ -0,0 +1,152 @@
+import { describe, expect, it } from 'vitest';
+import { testAdapter } from '../storage/db-adapter.test-helper.js';
+import { resolveServerConfig } from './config.js';
+import { resolvePasskeyConfig } from './validate-passkey-config.js';
+const unused = async () => {
+    throw new Error('Configuration validation must not execute provider operations');
+};
+const passwordOnly = {
+    capabilities: { passwordChange: true, magicLink: false, sso: false },
+    signInWithPassword: unused,
+    verifyAccessToken: unused,
+    refreshSession: unused,
+    revokeSession: unused,
+    resolveActor: unused,
+};
+const ceremonies = {
+    signInOptions: unused,
+    verifySignIn: unused,
+    passwordProof: unused,
+    proofOptions: unused,
+    verifyProof: unused,
+    enrollmentOptions: unused,
+    verifyEnrollment: unused,
+    listCredentials: unused,
+    renameCredential: unused,
+    removeCredential: unused,
+};
+const enabled = {
+    ...passwordOnly,
+    capabilities: { ...passwordOnly.capabilities, passkeys: true },
+    passkeys: ceremonies,
+};
+const config = {
+    rpId: 'example.com',
+    rpName: 'Byline',
+    origins: ['https://example.com', 'https://edit.example.com:8443'],
+};
+describe('optional passkey configuration', () => {
+    it('keeps existing password-only and absent providers working', () => {
+        expect(resolvePasskeyConfig(undefined, passwordOnly)).toBeUndefined();
+        expect(resolvePasskeyConfig(undefined, undefined)).toBeUndefined();
+        expect(resolvePasskeyConfig(undefined, {
+            ...passwordOnly,
+            capabilities: { ...passwordOnly.capabilities, passkeys: false },
+        })).toBeUndefined();
+    });
+    it('validates and snapshots explicitly configured trust without invoking a ceremony', () => {
+        const origins = [...config.origins];
+        const resolved = resolvePasskeyConfig({ ...config, origins }, enabled);
+        origins.push('https://evil.example.com');
+        expect(resolved.origins).toEqual(config.origins);
+        expect(Object.isFrozen(resolved)).toBe(true);
+        expect(Object.isFrozen(resolved.origins)).toBe(true);
+    });
+    it('runs validation through server configuration resolution', () => {
+        expect(() => resolveServerConfig({
+            collections: [],
+            db: testAdapter({}),
+            i18n: {
+                admin: { defaultLocale: 'en', locales: [] },
+                content: { defaultLocale: 'en', locales: [] },
+            },
+            sessionProvider: passwordOnly,
+            passkeys: config,
+        })).toThrow('provider does not support passkeys');
+    });
+    it('requires configuration and capability to agree', () => {
+        expect(() => resolvePasskeyConfig(undefined, enabled)).toThrow('explicit relying-party');
+        expect(() => resolvePasskeyConfig(config, passwordOnly)).toThrow('does not support');
+        expect(() => resolvePasskeyConfig(config, undefined)).toThrow('does not support');
+        expect(() => resolvePasskeyConfig(config, { ...enabled, passkeys: undefined })).toThrow('does not support');
+        expect(() => resolvePasskeyConfig(undefined, { ...passwordOnly, passkeys: ceremonies })).toThrow('explicit relying-party');
+    });
+    it.each(Object.keys(ceremonies))('rejects a provider missing %s', (method) => {
+        const partial = { ...ceremonies, [method]: undefined };
+        expect(() => resolvePasskeyConfig(config, { ...enabled, passkeys: partial })).toThrow(`missing ${method}`);
+    });
+    it.each([
+        '',
+        'example.com:443',
+        'https://example.com',
+        '*.example.com',
+        'EXAMPLE.COM',
+        'example.com.',
+        '127.0.0.1',
+        '[::1]',
+        'com',
+    ])('rejects invalid RP ID %s', (rpId) => {
+        expect(() => resolvePasskeyConfig({ ...config, rpId }, enabled)).toThrow('rpId');
+    });
+    it.each([
+        'http://example.com',
+        'https://example.com/',
+        'https://example.com/path',
+        'https://example.com?x=1',
+        'https://example.com#fragment',
+        'https://user@example.com',
+        'https://EXAMPLE.COM',
+        'https://example.com:443',
+        'https://evil-example.com',
+        'https://example.com.evil.com',
+        'https://other.com',
+        'null',
+        '*',
+    ])('rejects an unsafe or noncanonical origin %s', (origin) => {
+        expect(() => resolvePasskeyConfig({ ...config, origins: [origin] }, enabled)).toThrow('Invalid passkey');
+    });
+    it('permits HTTP only for explicitly enabled localhost development', () => {
+        const local = { rpId: 'localhost', rpName: 'Local', origins: ['http://localhost:5173'] };
+        expect(() => resolvePasskeyConfig(local, enabled)).toThrow('HTTPS');
+        expect(resolvePasskeyConfig({ ...local, allowInsecureLocalhost: true }, enabled)?.origins).toEqual(local.origins);
+        expect(() => resolvePasskeyConfig({ ...config, origins: ['http://example.com'], allowInsecureLocalhost: true }, enabled)).toThrow('HTTPS');
+        expect(() => resolvePasskeyConfig({ ...local, origins: ['http://foo.localhost'], allowInsecureLocalhost: true }, enabled)).toThrow('HTTPS');
+    });
+    it.each([
+        { rpName: '' },
+        { rpName: '   ' },
+        { rpName: 'x'.repeat(201) },
+        { origins: [] },
+        { origins: ['https://example.com', 'https://example.com'] },
+        { origins: [42] },
+        { allowInsecureLocalhost: 'true' },
+        { relatedOrigins: true },
+    ])('rejects malformed or unsupported configuration %j', (invalid) => {
+        expect(() => resolvePasskeyConfig({ ...config, ...invalid }, enabled)).toThrow('Invalid passkey');
+    });
+});
+describe('passkey host protection configuration', () => {
+    const server = {
+        collections: [],
+        db: testAdapter({}),
+        i18n: {
+            admin: { defaultLocale: 'en', locales: [] },
+            content: { defaultLocale: 'en', locales: [] },
+        },
+        sessionProvider: enabled,
+        passkeys: config,
+    };
+    it('fails closed at boot without trusted IP and admission methods', () => {
+        expect(() => resolveServerConfig(server)).toThrow('passkeyRequests');
+        expect(() => resolveServerConfig({
+            ...server,
+            passkeyRequests: { resolveClientIp: () => null, limiter: {} },
+        })).toThrow('passkeyRequests');
+    });
+    it('accepts explicit protection without invoking it', () => {
+        expect(resolveServerConfig({
+            ...server,
+            passkeyRequests: { resolveClientIp: unused, limiter: { acquire: unused, consume: unused } },
+        }).passkeys).toEqual(config);
+    });
+});

package/dist/core.js

@@ -87,6 +87,7 @@ export const initBylineCore = async (config, pinoLogger) => {
         tasks: configuredTasks,
         adapter: composed.db,
         passwordSignIn: resolvedConfig.passwordSignIn,
+        passkeyRequests: resolvedConfig.passkeyRequests,
     });
     // Freeze a snapshot of the validated task set: a new array of new, frozen
     // objects, then freeze the array itself. Without this, `core.recurringTasks`

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export { type CollectionGroupBucket, groupCollectionsForAdmin, } from './config/
 export { resolveRoutes } from './config/routes.js';
 export { validateAdminConfigs, validateBlockAdminConfigs, validateCollectionGroups, } from './config/validate-admin-configs.js';
 export { RESERVED_FIELD_NAMES } from './config/validate-collections.js';
+export { resolvePasskeyConfig } from './config/validate-passkey-config.js';
 export { type BylineCore, getBylineCore, initBylineCore } from './core.js';
 export * from './defaults/default-values.js';
 export { getHostRequestBridge, type HostCookieSetOptions, type HostRequestBridge, registerHostRequestBridge, tryGetHostRequestBridge, } from './host/host-request-bridge.js';

package/dist/index.js

@@ -17,6 +17,7 @@ export { groupCollectionsForAdmin, } from './config/group-collections.js';
 export { resolveRoutes } from './config/routes.js';
 export { validateAdminConfigs, validateBlockAdminConfigs, validateCollectionGroups, } from './config/validate-admin-configs.js';
 export { RESERVED_FIELD_NAMES } from './config/validate-collections.js';
+export { resolvePasskeyConfig } from './config/validate-passkey-config.js';
 export { getBylineCore, initBylineCore } from './core.js';
 export * from './defaults/default-values.js';
 export { getHostRequestBridge, registerHostRequestBridge, tryGetHostRequestBridge, } from './host/host-request-bridge.js';

package/dist/paths/path-dialects.test.node.js

@@ -139,7 +139,7 @@ describe('path dialect — upload hook registry keys', () => {
 // one registration applies wherever the block renders.
 // ---------------------------------------------------------------------------
 describe('path dialect — admin fields{} override keys', () => {
-    const admin = (key) => ({ slug: 'pages', fields: { [key]: {} } });
+    const admin = (key) => ({ path: 'pages', fields: { [key]: {} } });
     const validate = (key) => () => validateAdminConfigs([admin(key)], [fixture()]);
     it('accepts a top-level field name', () => {
         expect(validate('title')).not.toThrow();
@@ -262,6 +262,6 @@ describe('path dialects — cross-dialect relationships', () => {
             collections: [fixture()],
             hooks: { uploads: { [registryKey]: async () => ({}) } },
         })).not.toThrow();
-        expect(() => validateAdminConfigs([{ slug: 'pages', fields: { [adminKey]: {} } }], [fixture()])).not.toThrow();
+        expect(() => validateAdminConfigs([{ path: 'pages', fields: { [adminKey]: {} } }], [fixture()])).not.toThrow();
     });
 });

package/dist/paths/paths.test.node.js

@@ -309,7 +309,7 @@ describe('resolveDeclarationPath — agreement with the admin fields{} validator
     };
     const validatorAccepts = (key) => {
         try {
-            validateAdminConfigs([{ slug: 'pages', fields: { [key]: {} } }], [collection]);
+            validateAdminConfigs([{ path: 'pages', fields: { [key]: {} } }], [collection]);
             return true;
         }
         catch {

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

@@ -5,7 +5,7 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-import type { PasswordSignInProtection } from '@byline/auth';
+import type { PasskeyRequestProtection, PasswordSignInProtection } from '@byline/auth';
 import type { ISchedulerStore, RecurringTaskDefinition } from './types.js';
 /**
  * Boot-time gate. Recurring tasks registered against an adapter that does not
@@ -14,6 +14,7 @@ import type { ISchedulerStore, RecurringTaskDefinition } from './types.js';
  */
 export declare function validateSchedulerConfig(params: {
     passwordSignIn?: PasswordSignInProtection;
+    passkeyRequests?: PasskeyRequestProtection;
     tasks?: readonly RecurringTaskDefinition[];
     adapter: {
         scheduler?: ISchedulerStore;

package/dist/scheduler/validate-scheduler-config.js

@@ -13,10 +13,15 @@ import { validateRecurringTasks } from './validate-tasks.js';
  */
 export function validateSchedulerConfig(params) {
     const tasks = params.tasks ?? [];
-    const cleanup = params.passwordSignIn?.limiter.requiredCleanupTask;
-    if (cleanup && !tasks.some((task) => task.name === cleanup)) {
-        throw new Error(`Password sign-in requires recurring task "${cleanup}". Register the limiter's cleanupTask ` +
-            'in recurringTasks and start the host scheduler (or invoke runDueTasks externally).');
+    for (const [name, protection] of [
+        ['Password sign-in', params.passwordSignIn],
+        ['Passkeys', params.passkeyRequests],
+    ]) {
+        const cleanup = protection?.limiter.requiredCleanupTask;
+        if (cleanup && !tasks.some((task) => task.name === cleanup)) {
+            throw new Error(`${name} requires recurring task "${cleanup}". Register the limiter's cleanupTask ` +
+                'in recurringTasks and start the host scheduler (or invoke runDueTasks externally).');
+        }
     }
     if (tasks.length === 0)
         return;

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

@@ -52,3 +52,20 @@ describe('validateSchedulerConfig', () => {
         })).toThrow(/interval/i);
     });
 });
+it('requires passkey counter cleanup and accepts one shared task for both limiters', () => {
+    const protection = {
+        resolveClientIp: () => '192.0.2.1',
+        limiter: {
+            requiredCleanupTask: task.name,
+            acquire: async () => () => { },
+            consume: async () => ({ allowed: true, retryAfterSeconds: 0 }),
+        },
+    };
+    expect(() => validateSchedulerConfig({ passkeyRequests: protection, adapter: { scheduler: store } })).toThrow('Passkeys requires recurring task');
+    expect(() => validateSchedulerConfig({
+        passwordSignIn: protection,
+        passkeyRequests: protection,
+        tasks: [task],
+        adapter: { scheduler: store },
+    })).not.toThrow();
+});

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

@@ -104,6 +104,7 @@ export async function copyToLocale(ctx, params) {
         const committed = await commitGuardedDocumentMutation(ctx, { ...params, previousVersionId, locale: params.targetLocale }, async () => {
             if ((targetRecord._availableVersionLocales?.includes(params.targetLocale) ||
                 targetRecord._localeAgnostic === true) &&
+                !targetRecord.unavailableBlocks?.length &&
                 sameDocumentData(merged.data, baseline))
                 return { value: previousVersionId, changed: false };
             const writeResult = await persistExistingDocumentVersion(ctx, {
@@ -113,7 +114,7 @@ export async function copyToLocale(ctx, params) {
                 status: getDefaultStatus(definition),
                 locale: params.targetLocale,
                 previousVersionId,
-            });
+            }, targetRecord);
             return { value: extractVersionId(writeResult.document), changed: true };
         });
         const documentVersionId = committed.value;

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

@@ -9,6 +9,8 @@ import { resolveHooks } from '../../@types/index.js';
 import { assertActorCanPerform } from '../../auth/assert-actor-can-perform.js';
 import { ERR_NOT_FOUND, ERR_VALIDATION } from '../../lib/errors.js';
 import { withLogContext } from '../../lib/logger.js';
+import { flattenFieldSetData } from '../../storage/storage-flatten.js';
+import { restoreFieldSetData } from '../../storage/storage-restore.js';
 import { getDefaultStatus } from '../../workflow/workflow.js';
 import { runCommittedDocumentHook } from './committed-hook.js';
 import { actorId, invokeHook } from './internals.js';
@@ -84,6 +86,31 @@ export async function deleteLocale(ctx, params) {
                 ctx,
                 documentId: params.documentId,
                 write: async () => {
+                    // The ordinary delete-locale primitive copies raw stored rows.
+                    // Reconstruct affected versions so unavailable blocks are omitted too.
+                    if (targetRecord.unavailableBlocks?.length) {
+                        const previous = await db.queries.documents.getDocumentByVersion({
+                            document_version_id: previousVersionId,
+                            document_id: params.documentId,
+                            collection_id: collectionId,
+                            locale: 'all',
+                        });
+                        const rows = flattenFieldSetData(definition.fields, previous.fields, 'all').filter((row) => row.locale !== params.locale);
+                        const { data } = restoreFieldSetData(definition.fields, rows);
+                        const saved = await db.commands.documents.createDocumentVersion({
+                            documentId: params.documentId,
+                            collectionId,
+                            collectionVersion: ctx.collectionVersion,
+                            collectionConfig: definition,
+                            action: 'delete_locale',
+                            documentData: data,
+                            locale: 'all',
+                            previousVersionId,
+                            status: getDefaultStatus(definition),
+                            createdBy: actorId(ctx),
+                        });
+                        return { newVersionId: saved.document.id, previousVersionId };
+                    }
                     const deleted = await db.commands.documents.deleteDocumentLocale({
                         documentId: params.documentId,
                         locale: params.locale,

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

@@ -112,8 +112,9 @@ export declare function resolvePathForUpdate(args: {
  */
 export declare function derivePath(definition: CollectionDefinition, data: Record<string, any>, defaultLocale: string, slugifier: SlugifierFn): string;
 /**
- * Strip the synthetic `_id` / `_type` meta keys from every block and
- * array-item node in a reconstructed document tree.
+ * Strip the synthetic `_id` identity from every block and
+ * array-item node in a reconstructed document tree. Preserve `_type`, which
+ * selects the schema used to flatten each surviving block.
  *
  * Reconstructed `locale: 'all'` trees carry stable `_id` values for
  * blocks and array items (see CLAUDE.md → "Block/array items carry a

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

@@ -232,8 +232,9 @@ export function derivePath(definition, data, defaultLocale, slugifier) {
     return crypto.randomUUID();
 }
 /**
- * Strip the synthetic `_id` / `_type` meta keys from every block and
- * array-item node in a reconstructed document tree.
+ * Strip the synthetic `_id` identity from every block and
+ * array-item node in a reconstructed document tree. Preserve `_type`, which
+ * selects the schema used to flatten each surviving block.
  *
  * Reconstructed `locale: 'all'` trees carry stable `_id` values for
  * blocks and array items (see CLAUDE.md → "Block/array items carry a
@@ -254,7 +255,6 @@ export function stripMetaIdsInPlace(value) {
     if (value != null && typeof value === 'object' && !(value instanceof Date)) {
         const obj = value;
         delete obj._id;
-        delete obj._type;
         for (const key of Object.keys(obj)) {
             stripMetaIdsInPlace(obj[key]);
         }

package/dist/services/document-lifecycle/merge-write-locale.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 type { FieldSet } from '../../@types/index.js';
+/** Preserve other locales by item identity after unavailable blocks were compacted.
+ * Incoming structure is authoritative; never carry old positional store rows forward.
+ */
+export declare function mergeWriteLocale(fields: FieldSet, previous: Record<string, any>, incoming: Record<string, any>, locale: string): Record<string, any>;

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;