@formicoidea/labre-core 0.61.0 → 1.1.0

package/dist/_pkgs/affine-components/context-menu/sub-menu.js

@@ -38,6 +38,7 @@ import { autoPlacement, autoUpdate, computePosition, offset, } from '@floating-u
 import { html, nothing } from 'lit';
 import { property } from 'lit/decorators.js';
 import { classMap } from 'lit/directives/class-map.js';
+import { ifDefined } from 'lit/directives/if-defined.js';
 import { MenuFocusable } from './focusable.js';
 import { Menu } from './menu.js';
 import { popMenu, popupTargetFromElement } from './menu-renderer.js';
@@ -121,7 +122,12 @@ let MenuSubMenu = (() => {
                 'affine-menu-button': true,
                 focused: this.isFocused$.value,
             });
-            return html ` <div class="${classString}">${this.data.content()}</div>`;
+            return html ` <div
+      class="${classString}"
+      data-testid=${ifDefined(this.data.testId)}
+    >
+      ${this.data.content()}
+    </div>`;
         }
         #data_accessor_storage;
         get data() { return this.#data_accessor_storage; }
@@ -182,7 +188,12 @@ let MobileSubMenu = (() => {
                 'mobile-menu-button': true,
                 focused: this.isFocused$.value,
             });
-            return html ` <div class="${classString}">${this.data.content()}</div>`;
+            return html ` <div
+      class="${classString}"
+      data-testid=${ifDefined(this.data.testId)}
+    >
+      ${this.data.content()}
+    </div>`;
         }
         #data_accessor_storage = __runInitializers(this, _data_initializers, void 0);
         get data() { return this.#data_accessor_storage; }
@@ -219,6 +230,7 @@ export const subMenuItems = {
             ${config.postfix}
             ${config.disableArrow ? nothing : ArrowRightSmallIcon()} `,
             class: config.class,
+            testId: config.testId,
             options: config.options,
         };
         return renderSubMenu(data, menu);

package/dist/_pkgs/{affine-block-database → affine-database-block}/adapters/notion-html.js

@@ -1,6 +1,6 @@
 import { DatabaseBlockSchema } from '../../affine-model/index.js';
 import { AdapterTextUtils, BlockNotionHtmlAdapterExtension, HastUtils, } from '../../affine-shared/adapters/index.js';
-import { getTagColor } from '../../data-view/index.js';
+import { getTagColor } from '../../affine-database-engine/index.js';
 import { nanoid } from '../../store/index.js';
 const ColumnClassMap = {
     typesSelect: 'select',

package/dist/_pkgs/{affine-block-database → affine-database-block}/commands.d.ts

@@ -5,7 +5,13 @@ export declare const insertDatabaseBlockCommand: Command<{
     viewType: string;
     place?: 'after' | 'before';
     removeEmptyLine?: boolean;
+    /**
+     * Empty rows the new database starts with, 3 when absent (0.48). The
+     * creation popover inserts none: the rows come with the source the
+     * reader picks (ADR 0035 amendment of 2026-10-28).
+     */
+    initialRows?: number;
 }, {
     insertedDatabaseBlockId: string;
 }>;
-export declare const initDatabaseBlock: (doc: Store, model: BlockModel, databaseId: string, viewType: string, isAppendNewRow?: boolean, std?: BlockStdScope) => void;
+export declare const initDatabaseBlock: (doc: Store, model: BlockModel, databaseId: string, viewType: string, isAppendNewRow?: boolean, std?: BlockStdScope, initialRows?: number) => void;

package/dist/_pkgs/{affine-block-database → affine-database-block}/commands.js

@@ -1,6 +1,6 @@
 import { DatabaseBlockDataSource, databaseViewInitTemplate, } from './data-source.js';
 export const insertDatabaseBlockCommand = (ctx, next) => {
-    const { selectedModels, viewType, place, removeEmptyLine, std } = ctx;
+    const { selectedModels, viewType, place, removeEmptyLine, initialRows, std } = ctx;
     if (!selectedModels?.length)
         return;
     const targetModel = place === 'before'
@@ -12,19 +12,19 @@ export const insertDatabaseBlockCommand = (ctx, next) => {
     const string = result[0];
     if (string == null)
         return;
-    initDatabaseBlock(std.store, targetModel, string, viewType, false, std);
+    initDatabaseBlock(std.store, targetModel, string, viewType, false, std, initialRows);
     if (removeEmptyLine && targetModel.text?.length === 0) {
         std.store.deleteBlock(targetModel);
     }
     next({ insertedDatabaseBlockId: string });
 };
-export const initDatabaseBlock = (doc, model, databaseId, viewType, isAppendNewRow = true, std) => {
+export const initDatabaseBlock = (doc, model, databaseId, viewType, isAppendNewRow = true, std, initialRows) => {
     const blockModel = doc.getBlock(databaseId)?.model;
     if (!blockModel) {
         return;
     }
     const datasource = new DatabaseBlockDataSource(blockModel);
-    databaseViewInitTemplate(datasource, viewType, std);
+    databaseViewInitTemplate(datasource, viewType, std, initialRows);
     if (isAppendNewRow) {
         const parent = doc.getParent(model);
         if (!parent)

package/dist/_pkgs/{affine-block-database → affine-database-block}/components/title/index.d.ts

@@ -1,4 +1,4 @@
-import type { DataViewUILogicBase } from '../../../data-view/index.js';
+import type { DataViewUILogicBase } from '../../../affine-database-engine/index.js';
 import { ShadowlessElement } from '../../../std/index.js';
 import type { Text } from '../../../store/index.js';
 import type { DatabaseBlockComponent } from '../../database-block.js';

package/dist/_pkgs/{affine-block-database → affine-database-block}/components/values-banner.d.ts

@@ -1,5 +1,5 @@
 import { type DatabaseAllEvents, type EventTraceFn } from '../../affine-shared/services/index.js';
-import { type DataSourceHydration } from '../../data-view/index.js';
+import { type DataSourceHydration } from '../../affine-database-engine/index.js';
 import { type BlockStdScope, ShadowlessElement } from '../../std/index.js';
 import { nothing } from 'lit';
 declare const DatabaseValuesBanner_base: typeof ShadowlessElement & import("../../global/utils/types.js").Constructor<import("../../global/lit/with-disposable.js").DisposableClass>;

package/dist/_pkgs/{affine-block-database → affine-database-block}/components/values-banner.js

@@ -34,7 +34,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import { RESOURCE_STATUS_RETRY } from '../../affine-components/translations.js';
 import { translateKey, } from '../../affine-shared/services/index.js';
-import { valuesBannerOf, valuesStateOf, VALUES_SLOW_AFTER_MS, } from '../../data-view/index.js';
+import { valuesBannerOf, valuesStateOf, VALUES_SLOW_AFTER_MS, } from '../../affine-database-engine/index.js';
 import { SignalWatcher, WithDisposable } from '../../global/lit/index.js';
 import { ShadowlessElement } from '../../std/index.js';
 import { effect, signal } from '@preact/signals-core';

package/dist/_pkgs/affine-database-block/configs/slash-menu.d.ts

@@ -0,0 +1,31 @@
+import type { SlashMenuConfig } from '../../affine-widget-slash-menu/index.js';
+import type { BlockStdScope } from '../../std/index.js';
+/**
+ * With a data-source picker the host owns database creation (ADR 0035 §5):
+ * its `createDatabase` is the only way in, and without it no entry creates
+ * one. Without a picker, a native inline database, as in 0.48.
+ */
+export declare function canCreateDatabase(std: BlockStdScope): boolean;
+/**
+ * Three ways in, by what is registered (ADR 0035 §5, amendment of
+ * 2026-10-28):
+ *
+ * - a picker and the bundle's creation menu: the database lands at once,
+ *   native and with no row, and the menu opens over it to connect it to a
+ *   source (`connectDatabaseToSource`). Dismissed, the native database stays
+ *   and renders: nothing is lost by closing the popover;
+ * - a picker alone (a core-only host): the host's `createDatabase` first,
+ *   then a view of its first source, as in 0.61;
+ * - no picker: a native inline database with 3 rows, as in 0.48.
+ *
+ * The one creation gesture: the slash entries and the mobile keyboard
+ * toolbar's "Table view" / "Kanban view" both run it (ADR 0035 amendment of
+ * 2026-10-29), so neither inserts native rows a host's picker would not see.
+ */
+export declare function createDatabaseByGesture(std: BlockStdScope, viewType: string): void;
+/**
+ * The slash entries that CREATE a database, registered by the gated
+ * `DatabaseViewExtension` only. No Calendar entry after 0.48 (ADR 0035 §6):
+ * a calendar is no longer created anywhere, a stored one still renders.
+ */
+export declare const databaseSlashMenuConfig: SlashMenuConfig;

package/dist/_pkgs/affine-database-block/configs/slash-menu.js

@@ -0,0 +1,135 @@
+import { getSelectedModelsCommand } from '../../affine-shared/commands/index.js';
+import { DataSourcePickerProvider, TelemetryProvider, } from '../../affine-shared/services/index.js';
+import { isInsideBlockByFlavour } from '../../affine-shared/utils/index.js';
+import { viewPresets } from '../../affine-database-engine/view-presets/index.js';
+import { DatabaseKanbanViewIcon, DatabaseTableViewIcon, } from '@blocksuite/icons/lit';
+import { insertDatabaseBlockCommand } from '../commands.js';
+import { DatabaseCreationMenuIdentifier } from '../creation-menu.js';
+import { createHostedDatabaseView } from '../linked-view.js';
+import { KanbanViewTooltip, TableViewTooltip } from './tooltips.js';
+/**
+ * With a data-source picker the host owns database creation (ADR 0035 §5):
+ * its `createDatabase` is the only way in, and without it no entry creates
+ * one. Without a picker, a native inline database, as in 0.48.
+ */
+export function canCreateDatabase(std) {
+    const picker = std.getOptional(DataSourcePickerProvider);
+    return !picker || !!picker.createDatabase;
+}
+/**
+ * A native database after the selection, replacing the slash entry's empty
+ * line, reported once as `BlockCreated`. Returns its id, or `undefined` when
+ * nothing was inserted.
+ */
+function insertNativeDatabase(std, viewType, initialRows) {
+    let inserted;
+    std.command
+        .chain()
+        .pipe(getSelectedModelsCommand)
+        .pipe(insertDatabaseBlockCommand, {
+        viewType,
+        place: 'after',
+        removeEmptyLine: true,
+        initialRows,
+    })
+        .pipe(({ insertedDatabaseBlockId }) => {
+        if (insertedDatabaseBlockId) {
+            inserted = insertedDatabaseBlockId;
+            const telemetry = std.getOptional(TelemetryProvider);
+            telemetry?.track('BlockCreated', {
+                blockType: 'affine:database',
+            });
+        }
+    })
+        .run();
+    return inserted;
+}
+/**
+ * Three ways in, by what is registered (ADR 0035 §5, amendment of
+ * 2026-10-28):
+ *
+ * - a picker and the bundle's creation menu: the database lands at once,
+ *   native and with no row, and the menu opens over it to connect it to a
+ *   source (`connectDatabaseToSource`). Dismissed, the native database stays
+ *   and renders: nothing is lost by closing the popover;
+ * - a picker alone (a core-only host): the host's `createDatabase` first,
+ *   then a view of its first source, as in 0.61;
+ * - no picker: a native inline database with 3 rows, as in 0.48.
+ *
+ * The one creation gesture: the slash entries and the mobile keyboard
+ * toolbar's "Table view" / "Kanban view" both run it (ADR 0035 amendment of
+ * 2026-10-29), so neither inserts native rows a host's picker would not see.
+ */
+export function createDatabaseByGesture(std, viewType) {
+    if (!canCreateDatabase(std))
+        return;
+    const picker = std.getOptional(DataSourcePickerProvider);
+    if (!picker) {
+        insertNativeDatabase(std, viewType);
+        return;
+    }
+    const menu = std.getOptional(DatabaseCreationMenuIdentifier);
+    if (!menu) {
+        const [, { selectedModels }] = std.command.exec(getSelectedModelsCommand);
+        const after = selectedModels?.at(-1);
+        if (!after)
+            return;
+        createHostedDatabaseView(std, picker, {
+            after,
+            viewType,
+            removeEmptyLine: true,
+        }).catch(console.error);
+        return;
+    }
+    const blockId = insertNativeDatabase(std, viewType, 0);
+    if (!blockId)
+        return;
+    std.host.updateComplete
+        .then(() => {
+        const anchor = std.view.getBlock(blockId);
+        if (anchor)
+            menu.open({ std, blockId, anchor });
+    })
+        .catch(console.error);
+}
+function createDatabaseAction(viewType) {
+    return ({ std }) => createDatabaseByGesture(std, viewType);
+}
+/**
+ * The slash entries that CREATE a database, registered by the gated
+ * `DatabaseViewExtension` only. No Calendar entry after 0.48 (ADR 0035 §6):
+ * a calendar is no longer created anywhere, a stored one still renders.
+ */
+export const databaseSlashMenuConfig = {
+    disableWhen: ({ model }) => model.flavour === 'affine:database',
+    items: [
+        {
+            name: 'Table View',
+            description: 'Display items in a table format.',
+            searchAlias: ['database'],
+            icon: DatabaseTableViewIcon(),
+            tooltip: {
+                figure: TableViewTooltip,
+                caption: 'Table View',
+            },
+            group: '7_Database@0',
+            when: ({ model, std }) => !isInsideBlockByFlavour(model.store, model, 'affine:edgeless-text') &&
+                canCreateDatabase(std),
+            action: createDatabaseAction(viewPresets.tableViewMeta.type),
+        },
+        {
+            name: 'Kanban View',
+            description: 'Visualize data in a dashboard.',
+            searchAlias: ['database'],
+            icon: DatabaseKanbanViewIcon(),
+            tooltip: {
+                figure: KanbanViewTooltip,
+                caption: 'Kanban View',
+            },
+            group: '7_Database@2',
+            when: ({ model, std }) => !isInsideBlockByFlavour(model.store, model, 'affine:edgeless-text') &&
+                canCreateDatabase(std),
+            action: createDatabaseAction(viewPresets.kanbanViewMeta.type),
+        },
+    ],
+};

package/dist/_pkgs/affine-database-block/creation-menu.d.ts

@@ -0,0 +1,30 @@
+import type { BlockStdScope } from '../std/index.js';
+import type { ExtensionType } from '../store/index.js';
+/** What "Table View" / "Kanban View" hand the menu once the block is drawn. */
+export interface DatabaseCreationRequest {
+    std: BlockStdScope;
+    /** The native database the entry just inserted, still with no row. */
+    blockId: string;
+    /** The block's element, to hang the menu from. */
+    anchor: HTMLElement;
+    /**
+     * The view to connect, when the block already has a source the host no
+     * longer resolves ("Connect a source" of its empty view, ADR 0035
+     * amendment of 2026-10-29). Absent: the block's first view.
+     */
+    viewId?: string;
+}
+/**
+ * What a database creation entry opens over the block it just inserted
+ * (ADR 0035 §5, amendment of 2026-10-28): the `core-database` bundle
+ * registers one from its tooling extension to offer the host's sources in a
+ * popover. Like `AddViewMenuIdentifier` (data-view), it is a registry between
+ * library packages, never filled by a host, so it has no row in the seams
+ * table. Read only when the host fills the data-source picker; absent, the
+ * entries ask the host's `createDatabase` first, as in 0.61.
+ */
+export interface DatabaseCreationMenu {
+    open(request: DatabaseCreationRequest): void;
+}
+export declare const DatabaseCreationMenuIdentifier: import("../global/di/types.js").ServiceIdentifier<DatabaseCreationMenu> & (<U extends DatabaseCreationMenu = DatabaseCreationMenu>(variant: import("../global/di/types.js").ServiceVariant) => import("../global/di/types.js").ServiceIdentifier<U>);
+export declare function DatabaseCreationMenuExtension(menu: DatabaseCreationMenu): ExtensionType;

package/dist/_pkgs/affine-database-block/creation-menu.js

@@ -0,0 +1,9 @@
+import { createIdentifier } from '../global/di/index.js';
+export const DatabaseCreationMenuIdentifier = createIdentifier('AffineDatabaseCreationMenu');
+export function DatabaseCreationMenuExtension(menu) {
+    return {
+        setup: di => {
+            di.override(DatabaseCreationMenuIdentifier, () => menu);
+        },
+    };
+}

package/dist/_pkgs/{affine-block-database → affine-database-block}/data-source.d.ts

@@ -1,6 +1,6 @@
 import type { ColumnDataType, DatabaseBlockModel } from '../affine-model/index.js';
 import { type InsertToPosition } from '../affine-shared/utils/index.js';
-import { type PropertyMetaConfig, type TypeInstance } from '../data-view/index.js';
+import { type PropertyMetaConfig, type TypeInstance } from '../affine-database-engine/index.js';
 import type { BlockStdScope, EditorHost } from '../std/index.js';
 import { HostedDataSourceBase } from './external-data-source.js';
 type SpacialProperty = {
@@ -81,8 +81,16 @@ export declare class DatabaseBlockDataSource extends HostedDataSourceBase {
 }
 /**
  * `std` names the first view in the author's language (`viewDefaultName`),
- * at the gesture; absent, the preset's English name, as in 0.48.
+ * at the gesture; absent, the preset's English name, as in 0.48. `rows` empty
+ * rows come with it: 3 as in 0.48, none for a database whose source is still
+ * to be chosen (the creation popover, ADR 0035 amendment of 2026-10-28).
+ */
+export declare const databaseViewInitTemplate: (datasource: DatabaseBlockDataSource, viewType: string, std?: BlockStdScope, rows?: number) => void;
+/**
+ * "Create Table": the selected blocks become a database's rows. Under a host
+ * that requires a source they become a source of the host's instead
+ * (`turnBlocksIntoSource`, ADR 0035 amendment of 2026-10-29), never a
+ * native database it would show read-only.
  */
-export declare const databaseViewInitTemplate: (datasource: DatabaseBlockDataSource, viewType: string, std?: BlockStdScope) => void;
 export declare const convertToDatabase: (host: EditorHost, viewType: string) => void;
 export {};

package/dist/_pkgs/{affine-block-database → affine-database-block}/data-source.js

@@ -1,12 +1,13 @@
 import { getSelectedModelsCommand } from '../affine-shared/commands/index.js';
 import { insertPositionToIndex, } from '../affine-shared/utils/index.js';
-import { viewDefaultName, } from '../data-view/index.js';
-import { propertyPresets } from '../data-view/property-presets/index.js';
+import { viewDefaultName, } from '../affine-database-engine/index.js';
+import { propertyPresets } from '../affine-database-engine/property-presets/index.js';
 import {} from '../store/index.js';
 import { computed, signal } from '@preact/signals-core';
 import { getIcon } from './block-icons.js';
 import { HostedDataSourceBase } from './external-data-source.js';
 import { databaseBlockProperties, databasePropertyConverts, } from './properties/index.js';
+import { canTurnIntoSource, turnBlocksIntoSource } from './turn-into-source.js';
 import { addProperty, copyCellsByProperty, deleteRows, getCell, getProperty, updateCell, updateCells, updateProperty, } from './utils/block-utils.js';
 /**
  * The inline blob source: rows are the block's children, cells/columns live in
@@ -395,14 +396,22 @@ export class DatabaseBlockDataSource extends HostedDataSourceBase {
 }
 /**
  * `std` names the first view in the author's language (`viewDefaultName`),
- * at the gesture; absent, the preset's English name, as in 0.48.
+ * at the gesture; absent, the preset's English name, as in 0.48. `rows` empty
+ * rows come with it: 3 as in 0.48, none for a database whose source is still
+ * to be chosen (the creation popover, ADR 0035 amendment of 2026-10-28).
  */
-export const databaseViewInitTemplate = (datasource, viewType, std) => {
-    Array.from({ length: 3 }).forEach(() => {
+export const databaseViewInitTemplate = (datasource, viewType, std, rows = 3) => {
+    Array.from({ length: rows }).forEach(() => {
         datasource.rowAdd('end');
     });
     datasource.viewManager.viewAdd(viewType, viewDefaultName(datasource.viewMetaGet(viewType), std));
 };
+/**
+ * "Create Table": the selected blocks become a database's rows. Under a host
+ * that requires a source they become a source of the host's instead
+ * (`turnBlocksIntoSource`, ADR 0035 amendment of 2026-10-29), never a
+ * native database it would show read-only.
+ */
 export const convertToDatabase = (host, viewType) => {
     const [_, ctx] = host.std.command.exec(getSelectedModelsCommand, {
         types: ['block', 'text'],
@@ -411,6 +420,15 @@ export const convertToDatabase = (host, viewType) => {
     const firstModel = selectedModels?.[0];
     if (!firstModel)
         return;
+    if (canTurnIntoSource(host.std)) {
+        turnBlocksIntoSource(host.std, selectedModels, viewType)
+            .then(written => {
+            if (written)
+                host.selection.clear();
+        })
+            .catch(console.error);
+        return;
+    }
     host.store.captureSync();
     const parentModel = host.store.getParent(firstModel);
     if (!parentModel) {

package/dist/_pkgs/{affine-block-database → affine-database-block}/database-block-styles.js

@@ -1,11 +1,21 @@
 import { css } from '@emotion/css';
 import { cssVarV2 } from '@toeverything/theme/v2';
+// The block paints no background of its own: the page's shows through, as
+// for a note, so a host whose page colour is not
+// `--affine-background-primary-color` never sees a second card (the
+// playground did, in dark mode). The sticky column header keeps that token,
+// the page background every host sets.
 export const databaseBlockStyles = css({
     display: 'block',
     borderRadius: '8px',
-    backgroundColor: 'var(--affine-background-primary-color)',
     padding: '8px',
     margin: '8px -8px -8px',
+    // Drawn as the page (`isStandaloneDatabase`): the view bar sits under the
+    // page heading, without the inline block's top margin and padding.
+    '&[data-standalone]': {
+        marginTop: 0,
+        paddingTop: 0,
+    },
 });
 export const databaseBlockSelectedStyles = css({
     backgroundColor: 'var(--affine-hover-color)',
@@ -39,12 +49,23 @@ export const databaseHeaderContainerStyles = css({
     marginBottom: '16px',
     display: 'flex',
     flexDirection: 'column',
+    // Drawn as the page, which scrolls sideways under a wide table: the view
+    // bar stays in view, a viewport wide.
+    'affine-database[data-standalone] &': {
+        position: 'sticky',
+        left: 'var(--affine-editor-side-padding, 24px)',
+        width: 'calc(100cqw - 2 * var(--affine-editor-side-padding, 24px))',
+    },
 });
 export const databaseTitleRowStyles = css({
     display: 'flex',
     gap: '12px',
     marginBottom: '8px',
     alignItems: 'center',
+    // Drawn as the page, the page heading above is the database's name.
+    'affine-database[data-standalone] &': {
+        display: 'none',
+    },
 });
 // Too narrow for the tabs and the tools side by side (a phone, P7), the tools
 // drop to a line of their own, on the right, instead of squeezing the
@@ -65,7 +86,6 @@ export const databaseViewBarContainerStyles = css({
 });
 export const databaseContentStyles = css({
     position: 'relative',
-    backgroundColor: 'var(--affine-background-primary-color)',
     borderRadius: '4px',
 });
 export const databaseSourceMissingStyles = css({

package/dist/_pkgs/{affine-block-database → affine-database-block}/database-block.d.ts

@@ -1,7 +1,7 @@
 import { CaptionedBlockComponent } from '../affine-components/caption/index.js';
 import { DropIndicator } from '../affine-components/drop-indicator/index.js';
 import type { DatabaseBlockModel } from '../affine-model/index.js';
-import { type DataSourceBase, type DataViewWidget, type SingleView } from '../data-view/index.js';
+import { type DataSourceBase, type DataViewWidget, type SingleView } from '../affine-database-engine/index.js';
 import { type BlockComponent } from '../std/index.js';
 import type { DatabaseViewExtensionOptions } from './view.js';
 export declare class DatabaseBlockComponent extends CaptionedBlockComponent<DatabaseBlockModel> {
@@ -39,10 +39,50 @@ export declare class DatabaseBlockComponent extends CaptionedBlockComponent<Data
     private readonly toolsWidget;
     private readonly viewSelection$;
     private readonly virtualPadding$;
+    /**
+     * Whether this block is drawn as the page itself (`isStandaloneDatabase`,
+     * ADR 0035 amendment of 2026-10-28): handed to data-view as
+     * `PageLayoutKey` and reflected as `data-standalone` for the block's own
+     * styles. Measured from the DOM, never stored: nothing is written when it
+     * changes.
+     */
+    readonly standalone$: import("@preact/signals-core").Signal<boolean>;
+    refreshStandalone(): void;
+    /**
+     * Re-measures when a block mounts or leaves (the parent test), and when a
+     * page heading arrives in the scroll container, leaves it or names
+     * another body block (the title test). Every `<doc-title>` of the
+     * container is watched, so a title whose `body-block-id` is set after it
+     * mounted is seen too.
+     */
+    private watchStandalone;
     get optionsConfig(): DatabaseViewExtensionOptions;
     get isCommentHighlighted(): boolean;
     get topContenteditableElement(): BlockComponent<import("../store/index.js").BlockModel<object>, import("../std/index.js").BlockService, string> | null;
     private readonly renderSourceMissing;
+    /**
+     * A database a host that requires a source must connect first
+     * (`sourceRequirement` is `'connect'`, ADR 0035 amendment of 2026-10-29):
+     * no source and no row, or a hosted source the host no longer resolves.
+     * Drawn in place of the tools and the body: no row, no "New", no cell to
+     * type or paste into, so nothing is written. A hosted block keeps its view
+     * bar, since another of its views may still read a source. The button
+     * reopens the creation popover over the block, for the current view; a
+     * read-only document, or a host without the bundle's creation menu, gets
+     * the notice alone. Takes precedence over "Source not found" (§7).
+     */
+    private readonly renderSourceRequired;
+    /** "Move into a database" is waiting for the host: one call at a time. */
+    private readonly moving$;
+    private readonly moveIntoSource;
+    /**
+     * Native rows under a host that requires a source (`sourceRequirement` is
+     * `'read-only'`): the rows render, locked (`locked$`), with this notice and,
+     * where the host turns content into a source (`createDatabaseFrom`) and
+     * the document is writable, "Move into a database"; a spinner while the
+     * host answers.
+     */
+    private renderReadOnlyNotice;
     private renderDatabaseOps;
     connectedCallback(): void;
     disconnectedCallback(): void;