@byline/core 6.8.0 → 6.10.0

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

@@ -251,14 +251,14 @@ export interface FormAdminConfig {
  * Admin UI configuration for a collection.
  * This is the presentation/UI layer — separate from the data schema.
  *
- * Linked to a `CollectionDefinition` by `slug` matching the collection's
+ * Linked to a `CollectionDefinition` by `path` matching the collection's
  * `path`.
  */
 export interface CollectionAdminConfig<T = any> extends FormAdminConfig {
     /** Explicit resource discriminator. Stamped by `defineAdmin`. */
     singleton?: false;
     /** Must match the `path` of the corresponding `CollectionDefinition`. */
-    slug: string;
+    path: string;
     /**
      * Dashboard group this collection belongs to. Must name an entry in
      * `AdminConfig.collectionGroups`; an unknown name throws at startup.
@@ -447,7 +447,7 @@ export interface SingletonAdminConfig<T = any> extends FormAdminConfig {
     /** Explicit resource discriminator. Stamped by `defineSingletonAdmin`. */
     singleton: true;
     /** Must match the `path` of the corresponding `SingletonDefinition`. */
-    slug: string;
+    path: string;
     /**
      * Dashboard group this resource belongs to. The registry remains named
      * `AdminConfig.collectionGroups` for backwards compatibility.
@@ -487,14 +487,14 @@ export interface ListActionComponentProps {
 }
 /**
  * Type-safe factory for creating a `CollectionAdminConfig` linked to a schema.
- * Sets `slug` from the schema's `path`.
+ * Sets `path` from the schema's `path`.
  */
-export declare function defineAdmin<T = any>(schema: MultiCollectionDefinition, config: Omit<CollectionAdminConfig<T>, 'slug' | 'singleton'>): CollectionAdminConfig<T>;
+export declare function defineAdmin<T = any>(schema: MultiCollectionDefinition, config: Omit<CollectionAdminConfig<T>, 'path' | 'singleton'>): CollectionAdminConfig<T>;
 /**
  * Type-safe factory for a `SingletonAdminConfig` linked to a singleton schema.
  * Sets both the schema path and resource discriminator for authors.
  */
-export declare function defineSingletonAdmin<T = any>(schema: SingletonDefinition, config: Omit<SingletonAdminConfig<T>, 'slug' | 'singleton'>): SingletonAdminConfig<T>;
+export declare function defineSingletonAdmin<T = any>(schema: SingletonDefinition, config: Omit<SingletonAdminConfig<T>, 'path' | 'singleton'>): SingletonAdminConfig<T>;
 /**
  * Admin UI configuration for a block — the block-scoped analogue of
  * `CollectionAdminConfig`, carrying **rendering overrides only**.

package/dist/@types/admin-types.js

@@ -7,13 +7,13 @@
  */
 /**
  * Type-safe factory for creating a `CollectionAdminConfig` linked to a schema.
- * Sets `slug` from the schema's `path`.
+ * Sets `path` from the schema's `path`.
  */
 export function defineAdmin(schema, config) {
     return {
         ...config,
         singleton: false,
-        slug: schema.path,
+        path: schema.path,
     };
 }
 /**
@@ -24,7 +24,7 @@ export function defineSingletonAdmin(schema, config) {
     return {
         ...config,
         singleton: true,
-        slug: schema.path,
+        path: schema.path,
     };
 }
 /**

package/dist/@types/form-admin-config.test.node.js

@@ -17,7 +17,7 @@ describe('FormAdminConfig', () => {
     });
     it('is satisfied by a full CollectionAdminConfig', () => {
         const collection = {
-            slug: 'pages',
+            path: 'pages',
             layout: { main: [] },
         };
         const asForm = collection;

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

@@ -167,6 +167,24 @@ export interface SearchMatching {
 }
 /** Maximum UTF-16 length accepted for one full-text query. */
 export declare const MAX_SEARCH_QUERY_LENGTH = 1024;
+/** Maximum `ceil((end - start) / gap)` for one range-facet request. */
+export declare const MAX_RANGE_FACET_BUCKETS = 200;
+/** One numeric range-facet request over an integer `search.filters` field. */
+export interface SearchRangeFacetRequest {
+    field: string;
+    /** Inclusive lower edge of the first bucket. */
+    start: number;
+    /** Exclusive upper edge of the last bucket. */
+    end: number;
+    /** Bucket width; must be finite and greater than zero. */
+    gap: number;
+}
+/** One range bucket: `[start, end)` and its match count. */
+export interface SearchRangeFacetBucket {
+    start: number;
+    end: number;
+    count: number;
+}
 /**
  * A search request. Either collection-scoped (`collectionPath`) for
  * homogeneous results, or zone-scoped (`zone`) for heterogeneous
@@ -201,6 +219,8 @@ export interface SearchQuery {
     where?: QueryPredicate;
     /** Field names to compute facet buckets for (driver-capability gated). */
     facets?: string[];
+    /** Integer range aggregates; requires `capabilities.rangeFacets: true`. */
+    rangeFacets?: SearchRangeFacetRequest[];
     /** Restrict to a single content locale. */
     locale?: string;
     /**
@@ -254,6 +274,12 @@ export interface SearchResults {
      * driver supports them.
      */
     facets?: Record<string, SearchFacetBucket[]>;
+    /**
+     * Contiguous ascending buckets keyed by field, including zero counts.
+     * Cover exactly the requested `[start, end)`, truncating the final bucket.
+     * Counts respect the query, where, locale, status, and collection/zone scope.
+     */
+    rangeFacets?: Record<string, SearchRangeFacetBucket[]>;
 }
 /**
  * What a given driver can actually do. Lets consumers (the admin UI, the
@@ -266,6 +292,14 @@ export interface SearchResults {
 export interface SearchCapabilities {
     /** Faceted aggregation over indexed fields. */
     facets: boolean;
+    /** Integer range aggregation. Omission means false; unsupported requests must fail. */
+    rangeFacets?: boolean;
+    /**
+     * Applies `SearchQuery.where`. Omission means false. Advertise-only: the
+     * client still forwards `where` when absent. Providers may support a
+     * documented subset, but must reject unsupported fields or operators.
+     */
+    structuredFilters?: boolean;
     /** Fuzzy / typo-tolerant matching (e.g. `pg_trgm`). */
     typoTolerance: boolean;
     /** Vector / semantic / hybrid retrieval. */

package/dist/@types/search-types.js

@@ -7,3 +7,5 @@
  */
 /** Maximum UTF-16 length accepted for one full-text query. */
 export const MAX_SEARCH_QUERY_LENGTH = 1_024;
+/** Maximum `ceil((end - start) / gap)` for one range-facet request. */
+export const MAX_RANGE_FACET_BUCKETS = 200;

package/dist/@types/search-types.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/@types/search-types.test.node.js

@@ -0,0 +1,21 @@
+/**
+ * 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 { expect, it } from 'vitest';
+import { MAX_RANGE_FACET_BUCKETS } from '../index.js';
+it('exports the range-facet contract and bucket cap from the public core entry point', () => {
+    const request = { field: 'year', start: 2000, end: 2003, gap: 2 };
+    const buckets = [
+        { start: 2000, end: 2002, count: 0 },
+        { start: 2002, end: 2003, count: 1 },
+    ];
+    const query = { query: '', rangeFacets: [request] };
+    const result = { hits: [], total: 1, rangeFacets: { year: buckets } };
+    expect(MAX_RANGE_FACET_BUCKETS).toBe(200);
+    expect(query.rangeFacets).toEqual([request]);
+    expect(result.rangeFacets?.year).toEqual(buckets);
+});

package/dist/@types/singleton-admin-config.test.node.js

@@ -24,19 +24,22 @@ describe('singleton admin config', () => {
         const singletonAdmin = defineSingletonAdmin(settings, {});
         expect(collectionAdmin.singleton).toBe(false);
         expect(singletonAdmin.singleton).toBe(true);
-        expect(singletonAdmin.slug).toBe(settings.path);
+        expect(collectionAdmin.path).toBe(pages.path);
+        expect(singletonAdmin.path).toBe(settings.path);
+        expect(collectionAdmin).not.toHaveProperty('slug');
+        expect(singletonAdmin).not.toHaveProperty('slug');
     });
     it('does not let untyped config input override factory-owned identity', () => {
         const collectionAdmin = defineAdmin(pages, {
             singleton: true,
-            slug: 'wrong-collection',
+            path: 'wrong-collection',
         });
         const singletonAdmin = defineSingletonAdmin(settings, {
             singleton: false,
-            slug: 'wrong-singleton',
+            path: 'wrong-singleton',
         });
-        expect(collectionAdmin).toMatchObject({ singleton: false, slug: pages.path });
-        expect(singletonAdmin).toMatchObject({ singleton: true, slug: settings.path });
+        expect(collectionAdmin).toMatchObject({ singleton: false, path: pages.path });
+        expect(singletonAdmin).toMatchObject({ singleton: true, path: settings.path });
     });
     it('shares the reusable form composition contract', () => {
         const singletonAdmin = defineSingletonAdmin(settings, {

package/dist/config/config.d.ts

@@ -11,8 +11,8 @@ import type { AdminConfig, CollectionAdminConfig, CollectionDefinition, Resolved
  * still throw the loud "Byline has not been configured" error.
  */
 export declare const getCollectionDefinition: (path: string) => CollectionDefinition | null;
-export declare const getCollectionAdminConfig: (slug: string) => CollectionAdminConfig | null;
-export declare const getSingletonAdminConfig: (slug: string) => SingletonAdminConfig | null;
+export declare const getCollectionAdminConfig: (path: string) => CollectionAdminConfig | null;
+export declare const getSingletonAdminConfig: (path: string) => SingletonAdminConfig | null;
 export declare function defineAdminConfig(config: AdminConfig): ResolvedAdminConfig;
 export declare function defineServerConfig<TAdminStore = unknown>(config: ServerConfig<TAdminStore>): ResolvedServerConfig<TAdminStore>;
 /** Resolve and validate server config without replacing the registered singleton. */

package/dist/config/config.js

@@ -52,18 +52,18 @@ export const getCollectionDefinition = (path) => {
         return null;
     return config.collections.find((collection) => collection.path === path) ?? null;
 };
-const getAdminResourceConfig = (slug) => {
+const getAdminResourceConfig = (path) => {
     const adminConfig = getAdminConfigInstance();
     if (adminConfig == null)
         return null;
-    return adminConfig.admin?.find((admin) => admin.slug === slug) ?? null;
+    return adminConfig.admin?.find((admin) => admin.path === path) ?? null;
 };
-export const getCollectionAdminConfig = (slug) => {
-    const admin = getAdminResourceConfig(slug);
+export const getCollectionAdminConfig = (path) => {
+    const admin = getAdminResourceConfig(path);
     return admin?.singleton === true ? null : admin;
 };
-export const getSingletonAdminConfig = (slug) => {
-    const admin = getAdminResourceConfig(slug);
+export const getSingletonAdminConfig = (path) => {
+    const admin = getAdminResourceConfig(path);
     return admin?.singleton === true ? admin : null;
 };
 export function defineAdminConfig(config) {

package/dist/config/group-collections.js

@@ -33,7 +33,7 @@ export function groupCollectionsForAdmin(collections, admin, collectionGroups) {
     const groupByCollectionPath = new Map();
     for (const entry of admin ?? []) {
         if (entry.group != null)
-            groupByCollectionPath.set(entry.slug, entry.group);
+            groupByCollectionPath.set(entry.path, entry.group);
     }
     const membersByGroup = new Map();
     for (const group of collectionGroups ?? []) {

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

@@ -29,9 +29,9 @@ const groups = [
     { name: 'taxonomy', label: 'Taxonomies' },
 ];
 const admin = [
-    { slug: 'images', group: 'media' },
-    { slug: 'authors', group: 'authorities' },
-    { slug: 'categories', group: 'taxonomy' },
+    { path: 'images', group: 'media' },
+    { path: 'authors', group: 'authorities' },
+    { path: 'categories', group: 'taxonomy' },
 ];
 describe('groupCollectionsForAdmin', () => {
     it('returns one ungrouped bucket when no registry is declared', () => {
@@ -67,13 +67,13 @@ describe('groupCollectionsForAdmin', () => {
     });
     it('preserves collection declaration order within a bucket', () => {
         const more = define('videos');
-        const result = groupCollectionsForAdmin([more, images], [...admin, { slug: 'videos', group: 'media' }], groups);
+        const result = groupCollectionsForAdmin([more, images], [...admin, { path: 'videos', group: 'media' }], groups);
         expect(result[0]?.collections).toEqual([more, images]);
     });
     it('groups singleton and multi-collection resources together in declaration order', () => {
         const resourceAdmin = [
             ...admin,
-            { singleton: true, slug: settings.path, group: 'media' },
+            { singleton: true, path: settings.path, group: 'media' },
         ];
         const result = groupCollectionsForAdmin([images, settings], resourceAdmin, groups);
         expect(result[0]?.collections).toEqual([images, settings]);
@@ -85,7 +85,7 @@ describe('groupCollectionsForAdmin', () => {
     it('treats an undeclared group name as ungrouped rather than throwing', () => {
         // Boot validation rejects this configuration, but the function stays total
         // so a renderer can never crash on a stale or hand-built config object.
-        const result = groupCollectionsForAdmin([pages], [{ slug: 'pages', group: 'ghost' }], groups);
+        const result = groupCollectionsForAdmin([pages], [{ path: 'pages', group: 'ghost' }], groups);
         expect(result).toEqual([{ name: null, label: null, collections: [pages] }]);
     });
     it('ignores admin configs whose collection is not registered', () => {

package/dist/config/validate-admin-configs.d.ts

@@ -25,7 +25,7 @@ export declare function validateCollectionGroups(collectionGroups: readonly Coll
  * Validate every admin config in a configuration.
  *
  * Enforced rules (per admin config):
- *  1. Slug pairing — `admin.slug` matches exactly one `collection.path`.
+ *  1. Path pairing — `admin.path` matches exactly one `collection.path`.
  *  2. Placement — when `layout` is present, every top-level schema field
  *     name appears exactly once across the union of all `tabSet.tabs[].fields`,
  *     all `row.fields`, all `group.fields`, `layout.main`, and `layout.sidebar`.

package/dist/config/validate-admin-configs.js

@@ -91,14 +91,14 @@ export function validateCollectionGroups(collectionGroups, admins) {
         const known = declared.size === 0
             ? '`collectionGroups` was not declared, or is empty'
             : `declared groups: ${[...declared].map((name) => `"${name}"`).join(', ')}`;
-        throw new Error(`Admin resource "${admin.slug}": \`group: '${admin.group}'\` does not name a declared collection group (${known}). Add it to \`AdminConfig.collectionGroups\`, or remove the \`group\` property.`);
+        throw new Error(`Admin config for path "${admin.path}": \`group: '${admin.group}'\` does not name a declared collection group (${known}). Add it to \`AdminConfig.collectionGroups\`, or remove the \`group\` property.`);
     }
 }
 /**
  * Validate every admin config in a configuration.
  *
  * Enforced rules (per admin config):
- *  1. Slug pairing — `admin.slug` matches exactly one `collection.path`.
+ *  1. Path pairing — `admin.path` matches exactly one `collection.path`.
  *  2. Placement — when `layout` is present, every top-level schema field
  *     name appears exactly once across the union of all `tabSet.tabs[].fields`,
  *     all `row.fields`, all `group.fields`, `layout.main`, and `layout.sidebar`.
@@ -210,24 +210,24 @@ export function validateBlockAdminConfigs(blockAdmins, collections) {
     }
 }
 function validateOne(admin, collectionsByPath) {
-    // Rule 1 — slug pairing.
-    const collection = collectionsByPath.get(admin.slug);
+    // Rule 1 — path pairing.
+    const collection = collectionsByPath.get(admin.path);
     if (collection == null) {
         if (admin.singleton === true) {
-            throw new Error(`Singleton admin config "${admin.slug}" has no matching singleton definition (no singleton with \`path: '${admin.slug}'\` was registered).`);
+            throw new Error(`Singleton admin config "${admin.path}" has no matching singleton definition (no singleton with \`path: '${admin.path}'\` was registered).`);
         }
-        throw new Error(`Admin config "${admin.slug}" has no matching collection (no collection with \`path: '${admin.slug}'\` was registered).`);
+        throw new Error(`Admin config "${admin.path}" has no matching collection (no collection with \`path: '${admin.path}'\` was registered).`);
     }
     if (admin.singleton === true && !isSingleton(collection)) {
-        throw new Error(`Singleton admin config "${admin.slug}" targets a collection definition. Register it with \`defineAdmin\`, or point it at a singleton definition.`);
+        throw new Error(`Singleton admin config "${admin.path}" targets a collection definition. Register it with \`defineAdmin\`, or point it at a singleton definition.`);
     }
     if (admin.singleton !== true && isSingleton(collection)) {
-        throw new Error(`Collection admin config "${admin.slug}" targets a singleton definition. Register it with \`defineSingletonAdmin\`, or point it at a multi-collection definition.`);
+        throw new Error(`Collection admin config "${admin.path}" targets a singleton definition. Register it with \`defineSingletonAdmin\`, or point it at a multi-collection definition.`);
     }
-    const slug = admin.slug;
+    const path = admin.path;
     const fail = (msg) => {
         const resource = admin.singleton === true ? 'Singleton' : 'Collection';
-        throw new Error(`${resource} "${slug}": ${msg}`);
+        throw new Error(`${resource} "${path}": ${msg}`);
     };
     if (admin.singleton === true) {
         for (const key of COLLECTION_ONLY_ADMIN_KEYS) {

package/dist/config/validate-admin-configs.test.node.js

@@ -21,7 +21,7 @@ const collection = {
     ],
 };
 const baseAdmin = {
-    slug: 'news',
+    path: 'news',
     tabSets: [
         {
             name: 'main',
@@ -80,20 +80,20 @@ describe('validateAdminConfigs', () => {
         expect(() => validateAdminConfigs([admin], [collection, singleton])).toThrow(/lockPath.*not allowed on a singleton admin config/);
     });
     it('rejects a singleton admin config targeting a multi-collection', () => {
-        const admin = { ...defineSingletonAdmin(singleton, {}), slug: collection.path };
+        const admin = { ...defineSingletonAdmin(singleton, {}), path: collection.path };
         expect(() => validateAdminConfigs([admin], [collection, singleton])).toThrow(/targets a collection definition/);
     });
     it('rejects a singleton admin config with no matching definition', () => {
-        const admin = { ...defineSingletonAdmin(singleton, {}), slug: 'missing-settings' };
+        const admin = { ...defineSingletonAdmin(singleton, {}), path: 'missing-settings' };
         expect(() => validateAdminConfigs([admin], [collection, singleton])).toThrow(/no matching singleton definition/);
     });
     it('rejects a multi-collection admin config targeting a singleton', () => {
-        const admin = { slug: singleton.path };
+        const admin = { path: singleton.path };
         expect(() => validateAdminConfigs([admin], [collection, singleton])).toThrow(/targets a singleton definition/);
     });
-    // Rule 1 — slug pairing.
-    it('rejects an admin config whose slug has no matching collection', () => {
-        const orphan = { slug: 'nonexistent', layout: { main: [] } };
+    // Rule 1 — path pairing.
+    it('rejects an admin config whose path has no matching collection', () => {
+        const orphan = { path: 'nonexistent', layout: { main: [] } };
         expect(() => validateAdminConfigs([orphan], [collection])).toThrow(/no matching collection/);
     });
     // Rule 2 — placement bookkeeping.
@@ -177,7 +177,7 @@ describe('validateAdminConfigs', () => {
     // Rule 5 — nesting.
     it('rejects a row whose fields include a non-field primitive', () => {
         const admin = {
-            slug: 'news',
+            path: 'news',
             tabSets: [
                 {
                     name: 'main',
@@ -198,7 +198,7 @@ describe('validateAdminConfigs', () => {
     });
     it('rejects a tab set referenced from inside a tab', () => {
         const admin = {
-            slug: 'news',
+            path: 'news',
             tabSets: [
                 {
                     name: 'inner',
@@ -226,7 +226,7 @@ describe('validateAdminConfigs', () => {
     });
     it('rejects a group nested inside another group', () => {
         const admin = {
-            slug: 'news',
+            path: 'news',
             tabSets: [
                 {
                     name: 'main',
@@ -290,7 +290,7 @@ describe('validateAdminConfigs', () => {
         ],
     };
     const nestedAdmin = (fields) => ({
-        slug: 'library',
+        path: 'library',
         fields: fields,
     });
     it('accepts a dotted fields key through array and group declarations', () => {
@@ -386,14 +386,14 @@ describe('validateAdminConfigs', () => {
     // Layout omitted — bookkeeping skipped, primitive declarations still checked.
     it('skips placement bookkeeping when layout is omitted', () => {
         const admin = {
-            slug: 'news',
+            path: 'news',
             // No layout — renderer will synthesise a default.
         };
         expect(() => validateAdminConfigs([admin], [collection])).not.toThrow();
     });
     it('still rejects a primitive collision when layout is omitted', () => {
         const admin = {
-            slug: 'news',
+            path: 'news',
             rows: [
                 { name: 'titles', fields: ['text1', 'text2'] },
                 // 'title' is also a schema field — collision still caught.
@@ -518,34 +518,34 @@ describe('validateAdminConfigs — collection groups', () => {
         { name: 'taxonomy', label: 'Taxonomies' },
     ];
     it('accepts a valid registry and a valid reference', () => {
-        expect(() => validateAdminConfigs([{ slug: 'news', group: 'media' }], [collection], groups)).not.toThrow();
+        expect(() => validateAdminConfigs([{ path: 'news', group: 'media' }], [collection], groups)).not.toThrow();
     });
     it('accepts a collection with no group when a registry is declared', () => {
-        expect(() => validateAdminConfigs([{ slug: 'news' }], [collection], groups)).not.toThrow();
+        expect(() => validateAdminConfigs([{ path: 'news' }], [collection], groups)).not.toThrow();
     });
     it('is a no-op when no registry and no group references are present', () => {
-        expect(() => validateAdminConfigs([{ slug: 'news' }], [collection])).not.toThrow();
+        expect(() => validateAdminConfigs([{ path: 'news' }], [collection])).not.toThrow();
     });
     it('rejects a duplicate group name', () => {
-        expect(() => validateAdminConfigs([{ slug: 'news' }], [collection], [
+        expect(() => validateAdminConfigs([{ path: 'news' }], [collection], [
             { name: 'media', label: 'Media' },
             { name: 'media', label: 'Media Library' },
         ])).toThrow(/declared more than once/);
     });
     it('rejects a blank group name', () => {
-        expect(() => validateAdminConfigs([{ slug: 'news' }], [collection], [{ name: '  ', label: 'Media' }])).toThrow(/blank `name`/);
+        expect(() => validateAdminConfigs([{ path: 'news' }], [collection], [{ name: '  ', label: 'Media' }])).toThrow(/blank `name`/);
     });
     it('rejects a blank group label', () => {
-        expect(() => validateAdminConfigs([{ slug: 'news' }], [collection], [{ name: 'media', label: '' }])).toThrow(/blank `label`/);
+        expect(() => validateAdminConfigs([{ path: 'news' }], [collection], [{ name: 'media', label: '' }])).toThrow(/blank `label`/);
     });
     it('rejects a group reference that names no declared group', () => {
-        expect(() => validateAdminConfigs([{ slug: 'news', group: 'medai' }], [collection], groups)).toThrow(/does not name a declared collection group/);
+        expect(() => validateAdminConfigs([{ path: 'news', group: 'medai' }], [collection], groups)).toThrow(/does not name a declared collection group/);
     });
     it('names the declared groups in the unresolved-reference error', () => {
-        expect(() => validateAdminConfigs([{ slug: 'news', group: 'medai' }], [collection], groups)).toThrow(/"media", "taxonomy"/);
+        expect(() => validateAdminConfigs([{ path: 'news', group: 'medai' }], [collection], groups)).toThrow(/"media", "taxonomy"/);
     });
     it('rejects a group reference when no registry was declared at all', () => {
-        expect(() => validateAdminConfigs([{ slug: 'news', group: 'media' }], [collection])).toThrow(/was not declared/);
+        expect(() => validateAdminConfigs([{ path: 'news', group: 'media' }], [collection])).toThrow(/was not declared/);
     });
     // Registry sanity must not be skipped by the `admins` early return.
     it('validates the registry even when there are no admin configs', () => {

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/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>;