@formicoidea/labre-core 1.0.0 → 2.0.0

package/dist/_pkgs/affine-database-block/turn-into-source.js

@@ -0,0 +1,187 @@
+import { toast } from '../affine-components/toast/index.js';
+import { DataSourcePickerProvider, NotificationProvider, translateKey, } from '../affine-shared/services/index.js';
+import { insertLinkedDatabaseView, moveDatabaseIntoSource, } from './linked-view.js';
+import { DATABASE_TURN_INTO_FAILED, DATABASE_TURN_INTO_NESTED, } from './translations.js';
+/**
+ * "Turn into a source" (ADR 0035 amendment of 2026-10-29): under a host that
+ * requires a source (`requireSource`), "Create Table" on selected paragraphs
+ * and "Move into a database" on a database with native rows hand their
+ * content to the host's `createDatabaseFrom`, then connect the block to the
+ * database it answers, in one undo step. Nothing is written until the host
+ * answers; a refusal, a rejection, a read-only document or content changed
+ * in the meantime writes nothing and says so with a fixed message.
+ */
+/** The id of the title property a conversion of paragraphs sends. */
+export const TURN_INTO_TITLE_PROPERTY = 'title';
+function notify(std, wording) {
+    const message = translateKey(std, ...wording);
+    const notification = std.getOptional(NotificationProvider);
+    if (notification)
+        notification.toast(message);
+    else
+        toast(std.host, message);
+}
+function rowOf(std, block, values = {}) {
+    const transformer = std.store.getTransformer();
+    return {
+        // A Y.Text delta holds inserts only; the guard narrows its type.
+        title: (block.text?.toDelta() ?? []).filter((op) => typeof op.insert === 'string'),
+        values,
+        body: block.children.flatMap(child => {
+            const snapshot = transformer.blockToSnapshot(child);
+            return snapshot ? [snapshot] : [];
+        }),
+    };
+}
+/** The blocks, less those nested in another of them: they ride in its body. */
+export function outermostBlocks(blocks) {
+    const ids = new Set(blocks.map(block => block.id));
+    return blocks.filter(block => {
+        for (let parent = block.parent; parent; parent = parent.parent) {
+            if (ids.has(parent.id))
+                return false;
+        }
+        return true;
+    });
+}
+/** One row per block, its title the block's text, its body its children. */
+export function blocksContent(std, blocks) {
+    return {
+        title: '',
+        properties: [{ id: TURN_INTO_TITLE_PROPERTY, name: '', type: 'title' }],
+        rows: blocks.map(block => rowOf(std, block)),
+    };
+}
+/**
+ * A native database's columns and rows. A value is sent as stored, a rich
+ * text as its delta; the title column is the row's own text.
+ */
+export function databaseContent(std, model) {
+    const columns = model.props.columns;
+    const title = columns.find(column => column.type === 'title');
+    const properties = [
+        title
+            ? { id: title.id, name: title.name, type: 'title' }
+            : { id: TURN_INTO_TITLE_PROPERTY, name: '', type: 'title' },
+        ...columns
+            .filter(column => column.type !== 'title')
+            .map(column => {
+            const options = column.data.options;
+            return {
+                id: column.id,
+                name: column.name,
+                type: column.type,
+                ...(Array.isArray(options)
+                    ? {
+                        options: options.map((option) => ({
+                            id: option.id,
+                            value: option.value,
+                        })),
+                    }
+                    : {}),
+            };
+        }),
+    ];
+    const rows = model.children.map(row => {
+        const values = {};
+        for (const column of columns) {
+            if (column.type === 'title')
+                continue;
+            const value = model.props.cells[row.id]?.[column.id]?.value;
+            if (value === undefined)
+                continue;
+            values[column.id] =
+                value && typeof value === 'object' && 'toDelta' in value
+                    ? value.toDelta()
+                    : value;
+        }
+        return rowOf(std, row, values);
+    });
+    return { title: model.props.title.toString(), properties, rows };
+}
+/** Whether the host turns content into a source where one is required. */
+export function canTurnIntoSource(std) {
+    const picker = std.getOptional(DataSourcePickerProvider);
+    return picker?.requireSource === true && !!picker.createDatabaseFrom;
+}
+/** The host's database for `content`, or `null` once the reader was told why. */
+async function createFrom(std, content) {
+    const picker = std.getOptional(DataSourcePickerProvider);
+    const createDatabaseFrom = picker?.createDatabaseFrom;
+    if (!picker || !createDatabaseFrom || std.store.readonly)
+        return null;
+    if (!picker.rowBodies && content.rows.some(row => row.body.length > 0)) {
+        notify(std, DATABASE_TURN_INTO_NESTED);
+        return null;
+    }
+    try {
+        const database = await createDatabaseFrom.call(picker, content);
+        if (database?.sources[0])
+            return database;
+    }
+    catch (error) {
+        console.error(error);
+    }
+    notify(std, DATABASE_TURN_INTO_FAILED);
+    return null;
+}
+/**
+ * "Create Table" under a host that requires a source: the selected blocks
+ * become the rows of a new host database, and a view of its first source
+ * takes their place. Returns whether it was written.
+ */
+export async function turnBlocksIntoSource(std, selected, viewType) {
+    const blocks = outermostBlocks(selected);
+    const first = blocks[0];
+    if (!first || std.store.readonly)
+        return false;
+    const content = blocksContent(std, blocks);
+    const database = await createFrom(std, content);
+    const source = database?.sources[0];
+    if (!database || !source)
+        return false;
+    const unchanged = !std.store.readonly &&
+        blocks.every(block => std.store.getBlock(block.id)) &&
+        JSON.stringify(blocksContent(std, blocks)) === JSON.stringify(content);
+    if (!unchanged) {
+        notify(std, DATABASE_TURN_INTO_FAILED);
+        return false;
+    }
+    // `insertLinkedDatabaseView` opens the undo step; the deletions join it.
+    const id = insertLinkedDatabaseView(std, {
+        after: first,
+        database,
+        sourceId: source.id,
+        viewType,
+    });
+    if (!id) {
+        notify(std, DATABASE_TURN_INTO_FAILED);
+        return false;
+    }
+    for (const block of blocks)
+        std.store.deleteBlock(block);
+    return true;
+}
+/**
+ * "Move into a database" over native rows shown read-only: the database's
+ * columns and rows become a new host database, and the block reads its
+ * first source (`moveDatabaseIntoSource`). Returns whether it was written.
+ */
+export async function moveDatabaseRowsIntoSource(std, model) {
+    if (std.store.readonly || model.props.externalSourceId !== undefined) {
+        return false;
+    }
+    const content = databaseContent(std, model);
+    const database = await createFrom(std, content);
+    const source = database?.sources[0];
+    if (!database || !source)
+        return false;
+    const unchanged = !!std.store.getBlock(model.id) &&
+        JSON.stringify(databaseContent(std, model)) === JSON.stringify(content);
+    if (!unchanged ||
+        !moveDatabaseIntoSource(std, model, { database, sourceId: source.id })) {
+        notify(std, DATABASE_TURN_INTO_FAILED);
+        return false;
+    }
+    return true;
+}

package/dist/_pkgs/affine-database-block/view-deletion.d.ts

@@ -0,0 +1,15 @@
+import type { DatabaseBlockModel } from '../affine-model/index.js';
+import type { DataSourcePickerService } from '../affine-shared/services/index.js';
+/**
+ * Deletes view `viewId` of `model`, through the host's `deleteView` when it
+ * has one and the block shows one of its databases; at once otherwise.
+ * `removeNow` is the 1.0 removal (one undo step); `afterRemove` runs after a
+ * removal the host asked for (the view to show next).
+ */
+export declare function deleteViewThroughHost(options: {
+    model: DatabaseBlockModel;
+    viewId: string;
+    picker: DataSourcePickerService | null;
+    removeNow: () => void;
+    afterRemove: () => void;
+}): void;

package/dist/_pkgs/affine-database-block/view-deletion.js

@@ -0,0 +1,113 @@
+/**
+ * A host decides what a deleted view takes with it (ADR 0035 amendment of
+ * 2026-10-29). Labre sends a source to its trash with the last view reading
+ * it, and must confirm that BEFORE the view goes, then restore it when the
+ * removal is undone. So the delete gesture of a view of a host database
+ * becomes a request (`DataSourcePickerService.deleteView`) whose `remove()`
+ * is the 1.0 removal, and the undo step it makes is tagged so an undo or a
+ * redo of it reaches `viewHistory`.
+ *
+ * The tag rides in the undo step's `meta`. Yjs builds a NEW step for the
+ * opposite stack while it pops one ('stack-item-added' with the undo manager
+ * as origin, fired inside the pop's transaction, before 'stack-item-popped'),
+ * so the tag is carried over to that step, and an undo, redo, undo… chain
+ * keeps reporting. Remote updates never pop a step: they report nothing.
+ */
+const VIEW_REMOVED = 'labre:database-view-removed';
+// One listener pair per undo manager, whatever the number of blocks: the
+// step outlives the block's data source (a block remounted after a mode
+// switch, or unmounted, still has its removals undone).
+const watches = new WeakMap();
+function isViewRef(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const ref = value;
+    return (typeof ref.databaseId === 'string' &&
+        typeof ref.viewId === 'string' &&
+        typeof ref.docId === 'string' &&
+        typeof ref.blockId === 'string');
+}
+function watchHistory(undoManager, picker) {
+    const known = watches.get(undoManager);
+    if (known) {
+        known.picker = picker;
+        return;
+    }
+    const watch = { picker };
+    watches.set(undoManager, watch);
+    let replay = null;
+    undoManager.on('stack-item-added', event => {
+        if (event.origin === undoManager)
+            replay = event.stackItem;
+    });
+    undoManager.on('stack-item-popped', event => {
+        const opposite = replay;
+        replay = null;
+        const ref = event.stackItem.meta.get(VIEW_REMOVED);
+        if (!isViewRef(ref))
+            return;
+        opposite?.meta.set(VIEW_REMOVED, ref);
+        try {
+            watch.picker.viewHistory?.(ref, event.type);
+        }
+        catch (error) {
+            // A host failure must not break the undo itself.
+            console.error(error);
+        }
+    });
+}
+/**
+ * Deletes view `viewId` of `model`, through the host's `deleteView` when it
+ * has one and the block shows one of its databases; at once otherwise.
+ * `removeNow` is the 1.0 removal (one undo step); `afterRemove` runs after a
+ * removal the host asked for (the view to show next).
+ */
+export function deleteViewThroughHost(options) {
+    const { model, viewId, picker, removeNow, afterRemove } = options;
+    const store = model.store;
+    const databaseId = model.props.externalSourceId;
+    const deleteView = picker?.deleteView;
+    if (!picker || !deleteView || !databaseId || store.readonly) {
+        removeNow();
+        return;
+    }
+    const view = model.props.views.find(v => v.id === viewId);
+    if (!view)
+        return;
+    const ref = {
+        databaseId,
+        viewId,
+        docId: store.id,
+        blockId: model.id,
+        ...(view.sourceId === undefined ? {} : { sourceId: view.sourceId }),
+    };
+    let used = false;
+    const request = {
+        ...ref,
+        viewName: typeof view.name === 'string' ? view.name : '',
+        remove: () => {
+            if (used || store.readonly)
+                return false;
+            if (!model.props.views.some(v => v.id === viewId))
+                return false;
+            used = true;
+            const undoManager = store.history.undoManager;
+            watchHistory(undoManager, picker);
+            let added = null;
+            const grab = (event) => {
+                added = event.stackItem;
+            };
+            undoManager.on('stack-item-added', grab);
+            try {
+                removeNow();
+            }
+            finally {
+                undoManager.off('stack-item-added', grab);
+            }
+            added?.meta.set(VIEW_REMOVED, ref);
+            afterRemove();
+            return true;
+        },
+    };
+    deleteView.call(picker, request);
+}

package/dist/_pkgs/affine-database-block/views/index.d.ts

@@ -1,17 +1,16 @@
 import type { ViewMeta } from '../../affine-database-engine/index.js';
 /**
  * Every preset a stored `affine:database` view can be drawn with (ADR 0035
- * §6). Calendar stays here: calendar views were creatable until 0.48, so
- * documents hold them, and a stored calendar keeps rendering and editing as a
- * calendar. Never shrink this list: a mode that leaves it falls back to a
- * table on every document that stores it.
+ * §6). A mode that leaves this list falls back to a table on every document
+ * that stores it, so shrinking it is a major and an ADR decision: calendar
+ * left it in 2.0 (ADR 0035 amendment of 2026-10-29), and a stored calendar
+ * now draws as a table through `databaseBlockViewMetaGet`.
  */
 export declare const databaseBlockRenderableViews: ViewMeta[];
 /**
  * The presets a user can CREATE, a subset of the renderable ones: what the
  * data source answers as `viewMetas`, so the views bar ("+", "Create …") and
- * the Layout switch list only these. Calendar left it after 0.48 (ADR 0035 §6,
- * labre ADR-0046 §8): no new calendar, the stored ones still render.
+ * the Layout switch list only these.
  */
 export declare const databaseBlockViews: ViewMeta[];
 /** The preset a mode with none of its own is drawn with. */
@@ -26,8 +25,7 @@ export declare const databaseBlockViewMap: Record<string, ViewMeta | undefined>;
  */
 export declare function databaseBlockViewMetaGet(mode: string): ViewMeta;
 /**
- * Conversions INTO a creatable preset only: switching a view's layout to
- * calendar would create a calendar. The conversions out of calendar stay, so a
- * stored calendar can still become a table or a board.
+ * Conversions INTO a creatable preset only: a layout switch never creates a
+ * view a user could not have added.
  */
 export declare const databaseBlockViewConverts: import("../index.js").ViewConvertConfig[];

package/dist/_pkgs/affine-database-block/views/index.js

@@ -1,23 +1,21 @@
 import { viewConverts, viewPresets, } from '../../affine-database-engine/view-presets/index.js';
 /**
  * Every preset a stored `affine:database` view can be drawn with (ADR 0035
- * §6). Calendar stays here: calendar views were creatable until 0.48, so
- * documents hold them, and a stored calendar keeps rendering and editing as a
- * calendar. Never shrink this list: a mode that leaves it falls back to a
- * table on every document that stores it.
+ * §6). A mode that leaves this list falls back to a table on every document
+ * that stores it, so shrinking it is a major and an ADR decision: calendar
+ * left it in 2.0 (ADR 0035 amendment of 2026-10-29), and a stored calendar
+ * now draws as a table through `databaseBlockViewMetaGet`.
  */
 export const databaseBlockRenderableViews = [
     viewPresets.tableViewMeta,
     viewPresets.kanbanViewMeta,
-    viewPresets.calendarViewMeta,
     viewPresets.galleryViewMeta,
     viewPresets.listViewMeta,
 ];
 /**
  * The presets a user can CREATE, a subset of the renderable ones: what the
  * data source answers as `viewMetas`, so the views bar ("+", "Create …") and
- * the Layout switch list only these. Calendar left it after 0.48 (ADR 0035 §6,
- * labre ADR-0046 §8): no new calendar, the stored ones still render.
+ * the Layout switch list only these.
  */
 export const databaseBlockViews = [
     viewPresets.tableViewMeta,
@@ -42,8 +40,7 @@ export function databaseBlockViewMetaGet(mode) {
 }
 const creatableModes = new Set(databaseBlockViews.map(view => view.type));
 /**
- * Conversions INTO a creatable preset only: switching a view's layout to
- * calendar would create a calendar. The conversions out of calendar stay, so a
- * stored calendar can still become a table or a board.
+ * Conversions INTO a creatable preset only: a layout switch never creates a
+ * view a user could not have added.
  */
 export const databaseBlockViewConverts = viewConverts.filter(convert => creatableModes.has(convert.to));

package/dist/_pkgs/affine-database-engine/core/common/properties.js

@@ -42,7 +42,7 @@ import { css, html, nothing, unsafeCSS } from 'lit';
 import { property, query } from 'lit/decorators.js';
 import { classMap } from 'lit/directives/class-map.js';
 import { repeat } from 'lit/directives/repeat.js';
-import { DATA_VIEW_NEW_PROPERTY, DATA_VIEW_PROPERTIES, DATA_VIEW_PROPERTY_TYPE, } from '../../translations.js';
+import { DATA_VIEW_NEW_PROPERTY, DATA_VIEW_PROPERTIES, DATA_VIEW_PROPERTY_TYPE, DATA_VIEW_HIDE_ALL, DATA_VIEW_SHOW_ALL, } from '../../translations.js';
 import { dragHandler } from '../utils/wc-dnd/dnd-context.js';
 import { defaultActivators } from '../utils/wc-dnd/sensors/index.js';
 import { createSortContext, sortable, } from '../utils/wc-dnd/sort/sort-context.js';
@@ -214,8 +214,9 @@ let DataViewPropertiesSettingView = (() => {
         get view() { return this.#view_accessor_storage; }
         set view(value) { this.#view_accessor_storage = value; }
         _renderNewProperty() {
-            if (this.view.readonly$.value)
+            if (this.view.readonly$.value || this.view.propertiesLocked$.value) {
                 return nothing;
+            }
             return html `<div
       class="property-item property-item-new"
       data-testid="data-view-properties-new"
@@ -267,16 +268,15 @@ let DataViewPropertiesSettingView = (() => {
             this._openMenu = (property, row) => {
                 if (this.view.readonly$.value)
                     return;
-                popPropertyMenu(popupTargetFromElement(row), property, {
-                    wording: this.wording,
-                });
+                popPropertyMenu(popupTargetFromElement(row), property, { wording: this.wording }, { beside: true });
             };
             this._newProperty = (event) => {
-                if (this.view.readonly$.value)
+                if (this.view.readonly$.value || this.view.propertiesLocked$.value)
                     return;
                 const button = event.currentTarget;
                 popNewPropertyMenu(popupTargetFromElement(button), this.view, {
                     title: this.wording(DATA_VIEW_PROPERTY_TYPE),
+                    wording: this.wording,
                     onAdd: id => {
                         this.updateComplete
                             .then(() => {
@@ -385,7 +385,7 @@ export const popPropertiesSetting = (target, props) => {
             class="properties-group-op"
             @click="${clickChangeAll}"
           >
-            ${isAllShowed ? 'Hide All' : 'Show All'}
+            ${(props.wording ?? englishWording)(isAllShowed ? DATA_VIEW_HIDE_ALL : DATA_VIEW_SHOW_ALL)}
           </div>`;
                 },
             },

package/dist/_pkgs/affine-database-engine/core/common/property-menu.d.ts

@@ -2,7 +2,7 @@ import { type MenuConfig, type PopupTarget } from '../../../affine-components/co
 import { type Wording } from '../utils/wording.js';
 import type { Property } from '../view-manager/property.js';
 import type { SingleView } from '../view-manager/single-view.js';
-export declare const inputConfig: (property: Property, wording?: Wording) => (menu: import("../../../affine-components/context-menu/menu.js").Menu) => import("lit-html").TemplateResult<1> | undefined;
+export declare const inputConfig: (property: Property, wording?: Wording) => MenuConfig;
 export declare const typeConfig: (property: Property, wording?: Wording) => (menu: import("../../../affine-components/context-menu/menu.js").Menu, index: number) => import("lit-html").TemplateResult | undefined;
 /** What a property menu's opener adds around the shared entries. */
 export type PropertyMenuSlots = {
@@ -32,7 +32,22 @@ export type PropertyMenuSlots = {
  * own copy of these entries; point it here in a dedicated pass.
  */
 export declare const propertyMenuItems: (property: Property, slots?: PropertyMenuSlots) => MenuConfig[];
-export declare const popPropertyMenu: (target: PopupTarget, property: Property, slots?: PropertyMenuSlots) => import("../../../affine-components/context-menu/menu-renderer.js").MenuHandler;
+/**
+ * A property menu opened from a list of properties sits BESIDE the list, on
+ * the side with more room, and stays inside the viewport: below the row it
+ * covered the list, and in a host's narrow sidebar (labre, about 470px) it
+ * hid the very rows it edits, its « Type » sub-menu half off screen (labre
+ * recette of 1.1). The sub-menu then opens on the same side
+ * (`nestedSubMenuPosition`).
+ */
+export declare const besideListMiddleware: () => {
+    name: string;
+    options?: any;
+    fn: (state: import("@floating-ui/dom").MiddlewareState) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+}[];
+export declare const popPropertyMenu: (target: PopupTarget, property: Property, slots?: PropertyMenuSlots, placement?: {
+    beside?: boolean;
+}) => import("../../../affine-components/context-menu/menu-renderer.js").MenuHandler;
 /**
  * The type picker of a new property, as the virtual table header's "+" and
  * the record detail's "Add property" draw it: one entry per type the source
@@ -43,4 +58,5 @@ export declare const popPropertyMenu: (target: PopupTarget, property: Property,
 export declare const popNewPropertyMenu: (target: PopupTarget, view: SingleView, options: {
     title: string;
     onAdd: (id: string) => void;
+    wording?: Wording;
 }) => import("../../../affine-components/context-menu/menu-renderer.js").MenuHandler;

package/dist/_pkgs/affine-database-engine/core/common/property-menu.js

@@ -1,11 +1,45 @@
 import { menu, popMenu, } from '../../../affine-components/context-menu/index.js';
 import { TOOLBAR_DELETE, TOOLBAR_DUPLICATE, } from '../../../affine-shared/services/index.js';
 import { DeleteIcon, DuplicateIcon, ViewIcon } from '@blocksuite/icons/lit';
+import { autoPlacement, offset, shift } from '@floating-ui/dom';
 import { html } from 'lit/static-html.js';
-import { DATA_VIEW_PROPERTY_HIDE_IN_VIEW, DATA_VIEW_PROPERTY_NAME, DATA_VIEW_PROPERTY_TYPE, DATA_VIEW_PROPERTY_TYPE_ENTRY, } from '../../translations.js';
+import { DATA_VIEW_PROPERTIES_LOCKED, DATA_VIEW_PROPERTY_HIDE_IN_VIEW, DATA_VIEW_PROPERTY_NAME, DATA_VIEW_PROPERTY_TYPE, DATA_VIEW_PROPERTY_TYPE_ENTRY, } from '../../translations.js';
 import { renderUniLit } from '../utils/uni-component/index.js';
-import { englishWording } from '../utils/wording.js';
+import { englishWording, propertyTypeName, } from '../utils/wording.js';
+/** The name of the type `property` has, in the host language. */
+const currentTypeName = (property, wording) => {
+    const meta = property.view.propertyMetas$.value.find(v => v.type === property.type$.value);
+    return meta ? propertyTypeName(wording, meta.config) : undefined;
+};
+/**
+ * The name of a property whose source its host locked (ADR 0035 amendment
+ * of 2026-10-29): shown, not editable, with the reason under it, so a menu
+ * that lost its rename, type, duplicate and delete says why.
+ */
+const lockedNameConfig = (property, wording) => () => html `
+    <div
+      data-testid="dv-property-locked"
+      style="display:flex;flex-direction:column;gap:4px;padding:4px 6px;margin-bottom:8px;"
+    >
+      <div
+        style="display:flex;align-items:center;gap:4px;font-size:14px;line-height:22px;"
+      >
+        <div class="affine-database-column-type-menu-icon">
+          ${renderUniLit(property.icon)}
+        </div>
+        <span>${property.name$.value}</span>
+      </div>
+      <div
+        style="font-size:12px;line-height:20px;color:var(--affine-text-secondary-color);"
+      >
+        ${wording(DATA_VIEW_PROPERTIES_LOCKED)}
+      </div>
+    </div>
+  `;
 export const inputConfig = (property, wording = englishWording) => {
+    if (property.nameCanSet === false) {
+        return lockedNameConfig(property, wording);
+    }
     return menu.input({
         prefix: html `
       <div class="affine-database-column-type-menu-icon">
@@ -31,8 +65,7 @@ export const typeConfig = (property, wording = englishWording) => {
           class="affine-database-column-type-icon"
           style="color: var(--affine-text-secondary-color);gap:4px;font-size: 14px;"
         >
-          ${renderUniLit(property.icon)}
-          ${property.view.propertyMetas$.value.find(v => v.type === property.type$.value)?.config.name}
+          ${renderUniLit(property.icon)} ${currentTypeName(property, wording)}
         </div>`,
                 options: {
                     title: {
@@ -43,7 +76,7 @@ export const typeConfig = (property, wording = englishWording) => {
                             items: property.view.propertyMetas$.value.map(config => {
                                 return menu.action({
                                     isSelected: config.type === property.type$.value,
-                                    name: config.config.name,
+                                    name: propertyTypeName(wording, config.config),
                                     prefix: renderUniLit(config.renderer.icon),
                                     select: () => {
                                         if (property.type$.value === config.type) {
@@ -122,8 +155,22 @@ export const propertyMenuItems = (property, slots = {}) => {
         }),
     ];
 };
-export const popPropertyMenu = (target, property, slots) => popMenu(target, {
+/**
+ * A property menu opened from a list of properties sits BESIDE the list, on
+ * the side with more room, and stays inside the viewport: below the row it
+ * covered the list, and in a host's narrow sidebar (labre, about 470px) it
+ * hid the very rows it edits, its « Type » sub-menu half off screen (labre
+ * recette of 1.1). The sub-menu then opens on the same side
+ * (`nestedSubMenuPosition`).
+ */
+export const besideListMiddleware = () => [
+    autoPlacement({ allowedPlacements: ['right-start', 'left-start'] }),
+    offset(4),
+    shift({ padding: 8, crossAxis: true }),
+];
+export const popPropertyMenu = (target, property, slots, placement = {}) => popMenu(target, {
     options: { items: propertyMenuItems(property, slots) },
+    middleware: placement.beside ? besideListMiddleware() : undefined,
 });
 /**
  * The type picker of a new property, as the virtual table header's "+" and
@@ -132,24 +179,28 @@ export const popPropertyMenu = (target, property, slots) => popMenu(target, {
  * source (every view), under the type's own name, and `onAdd` gets its id
  * so the opener can open its menu for the rename.
  */
-export const popNewPropertyMenu = (target, view, options) => popMenu(target, {
-    options: {
-        title: { text: options.title },
-        items: [
-            menu.group({
-                items: view.propertyMetas$.value.map(meta => menu.action({
-                    name: meta.config.name,
-                    prefix: renderUniLit(meta.renderer.icon),
-                    select: () => {
-                        const id = view.propertyAdd('end', {
-                            type: meta.type,
-                            name: meta.config.name,
-                        });
-                        if (id)
-                            options.onAdd(id);
-                    },
-                })),
-            }),
-        ],
-    },
-});
+export const popNewPropertyMenu = (target, view, options) => {
+    const wording = options.wording ?? englishWording;
+    return popMenu(target, {
+        options: {
+            title: { text: options.title },
+            items: [
+                menu.group({
+                    items: view.propertyMetas$.value.map(meta => menu.action({
+                        name: propertyTypeName(wording, meta.config),
+                        prefix: renderUniLit(meta.renderer.icon),
+                        select: () => {
+                            // Written resolved: a stored name is never re-translated.
+                            const id = view.propertyAdd('end', {
+                                type: meta.type,
+                                name: propertyTypeName(wording, meta.config),
+                            });
+                            if (id)
+                                options.onAdd(id);
+                        },
+                    })),
+                }),
+            ],
+        },
+    });
+};

package/dist/_pkgs/affine-database-engine/core/data-source/base.d.ts

@@ -11,6 +11,14 @@ import type { ViewManager } from '../view-manager/view-manager.js';
 import { type CellStatus, type DataSourceHydration, type ValuesState } from './hydration.js';
 export interface DataSource extends DataSourceHydration {
     readonly$: ReadonlySignal<boolean>;
+    /**
+     * The current view's source refuses new, renamed, deleted, duplicated or
+     * retyped properties (a host's policy, ADR 0035 amendment of 2026-10-29).
+     * Absent, nothing is locked. Read through `SingleView.propertiesLocked$`.
+     */
+    propertiesLocked$?: ReadonlySignal<boolean>;
+    /** The current view's source refuses new rows; absent, it takes them. */
+    rowsLocked$?: ReadonlySignal<boolean>;
     properties$: ReadonlySignal<string[]>;
     featureFlags$: ReadonlySignal<DatabaseFlags>;
     cellValueGet(rowId: string, propertyId: string): unknown;
@@ -69,6 +77,9 @@ export declare abstract class DataSourceBase implements DataSource {
     /** Every cell is `ready` unless a source says otherwise (ADR 0035 §9e). */
     cellStatus(_rowId: string, _propertyId: string): CellStatus;
     valuesState$: ReadonlySignal<ValuesState>;
+    /** Nothing is locked unless a source says so (`HostedDataSourceBase`). */
+    readonly propertiesLocked$: ReadonlySignal<boolean>;
+    readonly rowsLocked$: ReadonlySignal<boolean>;
     propertyTypeCanSet(propertyId: string): boolean;
     propertyCanDuplicate(propertyId: string): boolean;
     propertyCanDelete(propertyId: string): boolean;

package/dist/_pkgs/affine-database-engine/core/data-source/base.js

@@ -5,6 +5,9 @@ export const DataSourceScope = createScope('data-source');
 export class DataSourceBase {
     constructor() {
         this.valuesState$ = signal(VALUES_READY);
+        /** Nothing is locked unless a source says so (`HostedDataSourceBase`). */
+        this.propertiesLocked$ = signal(false);
+        this.rowsLocked$ = signal(false);
         this.container = new Container();
         this.fixedProperties$ = computed(() => {
             return this.allPropertyMetas$.value