@formicoidea/labre-core 0.61.0 → 1.1.0

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

@@ -0,0 +1,306 @@
+import { DataSourcePickerProvider, TelemetryProvider, } from '../affine-shared/services/index.js';
+import { nanoid, Text } from '../store/index.js';
+import { DatabaseDataSourceProvider } from './service/index.js';
+/**
+ * A view of a host database inserted into a document (ADR 0035 §5, §9c,
+ * issue B12): an `affine:database` block whose `externalSourceId` is the
+ * database the host listed and whose one view reads the chosen source
+ * (`sourceId`). No new prop, no new flavour: the shape every hosted database
+ * already has (labre ADR-0046 §3).
+ *
+ * The view's preset data comes from the preset's own `defaultData`, computed
+ * over the host's data source with the new view current, so a board groups by
+ * a property of the source it reads. One gesture, one undo step: the block
+ * and its view are written without a `captureSync` between them.
+ *
+ * Returns the new block's id, or `null` when nothing was written (read-only
+ * document, the anchor gone, no host data source).
+ */
+export function insertLinkedDatabaseView(std, options) {
+    const { store } = std;
+    if (store.readonly)
+        return null;
+    const { after, database, sourceId, viewType } = options;
+    if (!store.getBlock(after.id))
+        return null;
+    const provider = std.getOptional(DatabaseDataSourceProvider);
+    if (!provider)
+        return null;
+    store.captureSync();
+    const viewId = nanoid();
+    const [blockId] = store.addSiblingBlocks(after, [
+        {
+            flavour: 'affine:database',
+            externalSourceId: database.id,
+            title: new Text(database.title),
+            views: [{ id: viewId, name: '', mode: viewType, sourceId }],
+        },
+    ], 'after');
+    const model = blockId
+        ? store.getBlock(blockId)?.model
+        : undefined;
+    if (!blockId || !model)
+        return null;
+    const dataSource = provider.createDataSource(model);
+    try {
+        dataSource.viewManager.setCurrentView(viewId);
+        const view = {
+            ...defaultViewData(dataSource, viewType),
+            id: viewId,
+            sourceId,
+        };
+        store.transact(() => {
+            model.props.views = [view];
+        });
+    }
+    finally {
+        dataSource.dispose();
+    }
+    if (options.removeEmptyLine && after.text?.length === 0) {
+        store.deleteBlock(after);
+    }
+    std.getOptional(TelemetryProvider)?.track('BlockCreated', {
+        blockType: 'affine:database',
+    });
+    return blockId;
+}
+/**
+ * Turns the native database a creation entry just inserted into a view of a
+ * host source (ADR 0035 §5, amendment of 2026-10-28): the block takes the
+ * database's `externalSourceId`, its title when the block has none, an empty
+ * schema of its own, and its first view reads `sourceId`, with that view's
+ * data re-derived over the host's source; the native rows are deleted. The
+ * view keeps its id, mode and name: the reader sees the same view, now fed
+ * by the source.
+ *
+ * One gesture, one undo step: after a `captureSync`, every write sits in one
+ * `transact`, so one undo gives the native database back, rows included. The
+ * block rebuilds its own data source on `externalSourceId$`.
+ *
+ * Returns `false` and writes nothing on a read-only document, on a block
+ * already connected to a source (`externalSourceId`), without a host data
+ * source (`DatabaseDataSourceProvider`) or without a view to keep.
+ */
+export function connectDatabaseToSource(std, model, choice) {
+    const { store } = std;
+    if (store.readonly)
+        return false;
+    if (model.props.externalSourceId !== undefined)
+        return false;
+    const provider = std.getOptional(DatabaseDataSourceProvider);
+    if (!provider)
+        return false;
+    const [first] = model.props.views;
+    if (!first)
+        return false;
+    const { database, sourceId } = choice;
+    const view = { id: first.id, name: first.name, mode: first.mode };
+    store.captureSync();
+    store.transact(() => {
+        const title = model.props.title;
+        // The title is edited in place, not replaced: the block's title editor
+        // stays bound to the same text.
+        if (title.length === 0 && database.title)
+            title.insert(database.title, 0);
+        // The view names its source before its data is derived: a hosted source
+        // reads the current view's `sourceId` to know which schema it shows.
+        store.updateBlock(model, {
+            externalSourceId: database.id,
+            columns: [],
+            views: [{ ...view, sourceId }],
+        });
+        const dataSource = provider.createDataSource(model);
+        try {
+            dataSource.viewManager.setCurrentView(view.id);
+            store.updateBlock(model, {
+                views: [
+                    {
+                        ...defaultViewData(dataSource, view.mode),
+                        id: view.id,
+                        name: view.name,
+                        sourceId,
+                    },
+                ],
+            });
+        }
+        finally {
+            dataSource.dispose();
+        }
+        for (const row of [...model.children])
+            store.deleteBlock(row);
+    });
+    return true;
+}
+export function sourceRequirement(std, model, sourceMissing = false) {
+    if (std.getOptional(DataSourcePickerProvider)?.requireSource !== true) {
+        return 'none';
+    }
+    if (model.props.externalSourceId === undefined) {
+        return model.children.length === 0 ? 'connect' : 'read-only';
+    }
+    return sourceMissing ? 'connect' : 'none';
+}
+/**
+ * Re-points one view of a hosted database whose source the host no longer
+ * resolves (ADR 0035 amendment of 2026-10-29): the block takes the picked
+ * database's `externalSourceId` when it differs, and the view reads
+ * `sourceId` with its data re-derived over it (`defaultViewData`: its id
+ * and name kept, its layout too where the preset can build over the new
+ * source). The other views are left as they are. One undo step. Returns
+ * `false` and writes nothing on a read-only document, on a block with no
+ * source (`connectDatabaseToSource` connects those), without a host data
+ * source or without that view.
+ */
+export function reconnectDatabaseView(std, model, choice) {
+    const { store } = std;
+    if (store.readonly)
+        return false;
+    if (model.props.externalSourceId === undefined)
+        return false;
+    const provider = std.getOptional(DatabaseDataSourceProvider);
+    if (!provider)
+        return false;
+    const { database, sourceId, viewId } = choice;
+    const index = model.props.views.findIndex(view => view.id === viewId);
+    const current = model.props.views[index];
+    if (!current)
+        return false;
+    const view = { id: current.id, name: current.name, mode: current.mode };
+    const withView = (data) => model.props.views.map((old, i) => (i === index ? data : old));
+    store.captureSync();
+    store.transact(() => {
+        if (model.props.externalSourceId !== database.id) {
+            store.updateBlock(model, { externalSourceId: database.id });
+        }
+        store.updateBlock(model, { views: withView({ ...view, sourceId }) });
+        const dataSource = provider.createDataSource(model);
+        try {
+            dataSource.viewManager.setCurrentView(view.id);
+            store.updateBlock(model, {
+                views: withView({
+                    ...defaultViewData(dataSource, view.mode),
+                    id: view.id,
+                    name: view.name,
+                    sourceId,
+                }),
+            });
+        }
+        finally {
+            dataSource.dispose();
+        }
+    });
+    return true;
+}
+/**
+ * Whether "Create Table" (`convertToDatabase`) may run. Where no source is
+ * required, it moves the blocks into a native database, as in 1.0. Where
+ * one is, it turns them into a source of the host's (`createDatabaseFrom`,
+ * ADR 0035 amendment of 2026-10-29), and is hidden without that method: a
+ * native database would be shown read-only at once.
+ */
+export function canConvertToDatabase(std) {
+    const picker = std.getOptional(DataSourcePickerProvider);
+    return picker?.requireSource !== true || !!picker.createDatabaseFrom;
+}
+/**
+ * Moves a database with native rows into the host source just created from
+ * them (`createDatabaseFrom`, ADR 0035 amendment of 2026-10-29): the block
+ * takes the database's `externalSourceId`, its title when it has none, an
+ * empty schema of its own; EVERY view is kept by id, name and layout and
+ * reads `sourceId`, its data re-derived over the source (its filters, sorts
+ * and columns named native property ids, which the host's are not); the
+ * native rows are deleted. One undo step, which gives the native database
+ * back; the host's database stays. Returns `false` and writes nothing on a
+ * read-only document, on a block already connected, or without a host data
+ * source.
+ */
+export function moveDatabaseIntoSource(std, model, choice) {
+    const { store } = std;
+    if (store.readonly)
+        return false;
+    if (model.props.externalSourceId !== undefined)
+        return false;
+    const provider = std.getOptional(DatabaseDataSourceProvider);
+    if (!provider)
+        return false;
+    const { database, sourceId } = choice;
+    const views = model.props.views.map(view => ({
+        id: view.id,
+        name: view.name,
+        mode: view.mode,
+    }));
+    store.captureSync();
+    store.transact(() => {
+        const title = model.props.title;
+        if (title.length === 0 && database.title)
+            title.insert(database.title, 0);
+        store.updateBlock(model, {
+            externalSourceId: database.id,
+            columns: [],
+            views: views.map(view => ({ ...view, sourceId })),
+        });
+        const dataSource = provider.createDataSource(model);
+        try {
+            store.updateBlock(model, {
+                views: views.map(view => {
+                    dataSource.viewManager.setCurrentView(view.id);
+                    return {
+                        ...defaultViewData(dataSource, view.mode),
+                        id: view.id,
+                        name: view.name,
+                        sourceId,
+                    };
+                }),
+            });
+        }
+        finally {
+            dataSource.dispose();
+        }
+        for (const row of [...model.children])
+            store.deleteBlock(row);
+    });
+    return true;
+}
+/**
+ * A preset's default view data over `dataSource`, named and typed. A preset
+ * that cannot build one over this source (a board with no property to group
+ * by, the case of every freshly created host database) gives a table: the
+ * view still lands and the user turns it into a board once a property exists.
+ */
+function defaultViewData(dataSource, viewType) {
+    for (const type of [viewType, 'table']) {
+        try {
+            const meta = dataSource.viewMetaGet(type);
+            return {
+                ...meta.model.defaultData(dataSource.viewManager),
+                name: meta.model.defaultName,
+                mode: type,
+            };
+        }
+        catch {
+            continue;
+        }
+    }
+    return { name: '', mode: 'table' };
+}
+/**
+ * The creating slash entries once the host fills the picker (ADR 0035 §5):
+ * ask the host for a new database, then insert a view of its first source
+ * after `after`. Nothing is written until the host answers; `null`, or a
+ * database with no source, writes nothing.
+ */
+export function createHostedDatabaseView(std, picker, options) {
+    const create = picker.createDatabase;
+    if (!create || std.store.readonly)
+        return Promise.resolve(null);
+    return create.call(picker).then(database => {
+        const source = database?.sources[0];
+        if (!database || !source)
+            return null;
+        return insertLinkedDatabaseView(std, {
+            ...options,
+            database,
+            sourceId: source.id,
+        });
+    });
+}

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

@@ -1,6 +1,6 @@
-import { createPropertyConvert, getTagColor, } from '../../data-view/index.js';
-import { presetPropertyConverts } from '../../data-view/property-presets/index.js';
-import { propertyModelPresets } from '../../data-view/property-presets/pure-index.js';
+import { createPropertyConvert, getTagColor, } from '../../affine-database-engine/index.js';
+import { presetPropertyConverts } from '../../affine-database-engine/property-presets/index.js';
+import { propertyModelPresets } from '../../affine-database-engine/property-presets/pure-index.js';
 import { clamp } from '../../global/gfx/index.js';
 import { nanoid, Text } from '../../store/index.js';
 import { richTextPropertyModelConfig } from './rich-text/define.js';

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/created-time/cell-renderer.d.ts

@@ -1,4 +1,4 @@
-import { BaseCellRenderer } from '../../../data-view/index.js';
+import { BaseCellRenderer } from '../../../affine-database-engine/index.js';
 export declare class CreatedTimeCell extends BaseCellRenderer<number, number> {
     renderContent(): import("lit-html").TemplateResult<1>;
     connectedCallback(): void;

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/created-time/cell-renderer.js

@@ -1,4 +1,4 @@
-import { BaseCellRenderer, createFromBaseCellRenderer, createIcon, } from '../../../data-view/index.js';
+import { BaseCellRenderer, createFromBaseCellRenderer, createIcon, } from '../../../affine-database-engine/index.js';
 import { css } from '@emotion/css';
 import { format } from 'date-fns/format';
 import { html } from 'lit';

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/created-time/define.js

@@ -1,4 +1,4 @@
-import { propertyType, t } from '../../../data-view/index.js';
+import { propertyType, t } from '../../../affine-database-engine/index.js';
 import { format } from 'date-fns/format';
 import zod from 'zod';
 export const createdTimeColumnType = propertyType('created-time');

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

@@ -1,4 +1,4 @@
-import { propertyPresets } from '../../data-view/property-presets/index.js';
+import { propertyPresets } from '../../affine-database-engine/property-presets/index.js';
 import { createdTimeColumnConfig } from './created-time/cell-renderer.js';
 import { linkColumnConfig } from './link/cell-renderer.js';
 import { richTextColumnConfig } from './rich-text/cell-renderer.js';

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/link/cell-renderer.d.ts

@@ -1,4 +1,4 @@
-import { BaseCellRenderer } from '../../../data-view/index.js';
+import { BaseCellRenderer } from '../../../affine-database-engine/index.js';
 import { type PropertyValues } from 'lit';
 export declare class LinkCell extends BaseCellRenderer<string, string> {
     protected firstUpdated(_changedProperties: PropertyValues): void;

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/link/cell-renderer.js

@@ -1,7 +1,7 @@
 import { RefNodeSlotsProvider } from '../../../affine-inline-reference/index.js';
 import { ParseDocUrlProvider } from '../../../affine-shared/services/index.js';
 import { isSafeLinkUrl, isValidUrl, normalizeUrl, stopPropagation, } from '../../../affine-shared/utils/index.js';
-import { BaseCellRenderer, createFromBaseCellRenderer, createIcon, } from '../../../data-view/index.js';
+import { BaseCellRenderer, createFromBaseCellRenderer, createIcon, } from '../../../affine-database-engine/index.js';
 import { EditIcon } from '@blocksuite/icons/lit';
 import { computed } from '@preact/signals-core';
 import { html, nothing } from 'lit';

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/link/define.js

@@ -1,4 +1,4 @@
-import { propertyType, t } from '../../../data-view/index.js';
+import { propertyType, t } from '../../../affine-database-engine/index.js';
 import zod from 'zod';
 export const linkColumnType = propertyType('link');
 export const linkPropertyModelConfig = linkColumnType.modelConfig({

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

@@ -1,4 +1,4 @@
-import type { PropertyModel } from '../../data-view/index.js';
+import type { PropertyModel } from '../../affine-database-engine/index.js';
 export declare const databaseBlockModels: {
     [k: string]: PropertyModel;
 };

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

@@ -1,4 +1,4 @@
-import { propertyModelPresets } from '../../data-view/property-presets/pure-index.js';
+import { propertyModelPresets } from '../../affine-database-engine/property-presets/pure-index.js';
 import { linkPropertyModelConfig } from './link/define.js';
 import { richTextPropertyModelConfig } from './rich-text/define.js';
 import { titlePropertyModelConfig } from './title/define.js';

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/rich-text/cell-renderer.d.ts

@@ -1,5 +1,5 @@
 import type { AffineInlineEditor, AffineTextAttributes } from '../../../affine-shared/types/index.js';
-import { BaseCellRenderer } from '../../../data-view/index.js';
+import { BaseCellRenderer } from '../../../affine-database-engine/index.js';
 import type { DeltaInsert } from '../../../store/index.js';
 import { Text } from '../../../store/index.js';
 export declare class RichTextCell extends BaseCellRenderer<Text, string> {

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/rich-text/cell-renderer.js

@@ -1,7 +1,7 @@
 import { DefaultInlineManagerExtension } from '../../../affine-inline-preset/index.js';
 import { ParseDocUrlProvider, TelemetryProvider, } from '../../../affine-shared/services/index.js';
 import { getViewportElement } from '../../../affine-shared/utils/index.js';
-import { BaseCellRenderer, createFromBaseCellRenderer, createIcon, } from '../../../data-view/index.js';
+import { BaseCellRenderer, createFromBaseCellRenderer, createIcon, } from '../../../affine-database-engine/index.js';
 import { IS_MAC } from '../../../global/env/index.js';
 import { Text } from '../../../store/index.js';
 import { computed, effect, signal } from '@preact/signals-core';

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/rich-text/define.js

@@ -1,4 +1,4 @@
-import { propertyType, t } from '../../../data-view/index.js';
+import { propertyType, t } from '../../../affine-database-engine/index.js';
 import { Text } from '../../../store/index.js';
 import * as Y from 'yjs';
 import zod from 'zod';

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

@@ -1,4 +1,4 @@
-import type { PropertyMetaConfig } from '../../../data-view/index.js';
+import type { PropertyMetaConfig } from '../../../affine-database-engine/index.js';
 /**
  * The text column of a hosted source whose values are plain JSON (ADR 0035
  * amendment of 2026-10-14): data-view's plain-text preset, type `text`, value

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/text/hosted.js

@@ -1,4 +1,4 @@
-import { propertyPresets } from '../../../data-view/property-presets/index.js';
+import { propertyPresets } from '../../../affine-database-engine/property-presets/index.js';
 import { richTextPropertyModelConfig } from '../rich-text/define.js';
 const { textPropertyConfig } = propertyPresets;
 /**

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/title/cell-renderer.js

@@ -1,5 +1,5 @@
-import { createFromBaseCellRenderer, createIcon, uniMap, } from '../../../data-view/index.js';
-import { TableSingleView } from '../../../data-view/view-presets/index.js';
+import { createFromBaseCellRenderer, createIcon, uniMap, } from '../../../affine-database-engine/index.js';
+import { TableSingleView } from '../../../affine-database-engine/view-presets/index.js';
 import { titlePropertyModelConfig } from './define.js';
 import { HeaderAreaTextCell } from './text.js';
 export const titleColumnConfig = titlePropertyModelConfig.createPropertyMeta({

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/title/define.js

@@ -1,4 +1,4 @@
-import { propertyType, t } from '../../../data-view/index.js';
+import { propertyType, t } from '../../../affine-database-engine/index.js';
 import { Text } from '../../../store/index.js';
 import { Doc } from 'yjs';
 import zod from 'zod';

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

@@ -1,4 +1,4 @@
-import { type PropertyMetaConfig } from '../../../data-view/index.js';
+import { type PropertyMetaConfig } from '../../../affine-database-engine/index.js';
 /**
  * The title column of a hosted source whose rows are documents (ADR 0035
  * §9f, issue B15): the row's title as a plain string from the source's own

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/title/hosted.js

@@ -1,5 +1,5 @@
-import { createIcon, t } from '../../../data-view/index.js';
-import { propertyPresets } from '../../../data-view/property-presets/index.js';
+import { createIcon, t, } from '../../../affine-database-engine/index.js';
+import { propertyPresets } from '../../../affine-database-engine/property-presets/index.js';
 import zod from 'zod';
 import { titleColumnType, titlePropertyModelConfig } from './define.js';
 /**

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

@@ -1,4 +1,4 @@
-import { BaseCellRenderer } from '../../../data-view/index.js';
+import { BaseCellRenderer } from '../../../affine-database-engine/index.js';
 export declare class IconCell extends BaseCellRenderer<string> {
     static styles: import("lit").CSSResult;
     render(): import("lit-html").TemplateResult<1>;

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/title/icon.js

@@ -1,4 +1,4 @@
-import { BaseCellRenderer } from '../../../data-view/index.js';
+import { BaseCellRenderer } from '../../../affine-database-engine/index.js';
 import { css, html } from 'lit';
 export class IconCell extends BaseCellRenderer {
     static { this.styles = css `

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

@@ -1,4 +1,4 @@
-import { BaseCellRenderer } from '../../../data-view/index.js';
+import { BaseCellRenderer } from '../../../affine-database-engine/index.js';
 import type { DeltaInsert, Text } from '../../../store/index.js';
 export declare class HeaderAreaTextCell extends BaseCellRenderer<Text, string> {
     activity: boolean;

package/dist/_pkgs/{affine-block-database → affine-database-block}/properties/title/text.js

@@ -35,7 +35,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 import { DefaultInlineManagerExtension } from '../../../affine-inline-preset/index.js';
 import { ParseDocUrlProvider, TelemetryProvider, } from '../../../affine-shared/services/index.js';
 import { getViewportElement } from '../../../affine-shared/utils/index.js';
-import { BaseCellRenderer } from '../../../data-view/index.js';
+import { BaseCellRenderer } from '../../../affine-database-engine/index.js';
 import { IS_MAC } from '../../../global/env/index.js';
 import { LinkedPageIcon } from '@blocksuite/icons/lit';
 import { computed, signal } from '@preact/signals-core';

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

@@ -1,4 +1,4 @@
-import type { DataViewSelection } from '../data-view/index.js';
+import type { DataViewSelection } from '../affine-database-engine/index.js';
 import { BaseSelection } from '../store/index.js';
 export declare class DatabaseSelection extends BaseSelection {
     static group: string;

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

@@ -1,4 +1,4 @@
-import { KanbanViewSelectionWithTypeSchema, TableViewSelectionWithTypeSchema, } from '../data-view/view-presets/index.js';
+import { KanbanViewSelectionWithTypeSchema, TableViewSelectionWithTypeSchema, } from '../affine-database-engine/view-presets/index.js';
 import { BaseSelection, SelectionExtension } from '../store/index.js';
 import { z } from 'zod';
 const ViewSelectionSchema = z.union([

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

@@ -1,5 +1,5 @@
 import type { DatabaseBlockModel } from '../../affine-model/index.js';
-import type { DataSourceBase, PropertyMetaConfig } from '../../data-view/index.js';
+import type { DataSourceBase, PropertyMetaConfig } from '../../affine-database-engine/index.js';
 export interface DatabaseBlockConfigService {
     propertiesPresets: PropertyMetaConfig[];
 }

package/dist/_pkgs/affine-database-block/standalone-layout.d.ts

@@ -0,0 +1,22 @@
+/** What the measure reads of the database block element. */
+export type StandaloneCandidate = HTMLElement & {
+    readonly rootComponent: Element | null;
+};
+/**
+ * Whether a database block is drawn as the page itself rather than inside a
+ * text (ADR 0035 amendment of 2026-10-28): a full page whose heading is the
+ * database's name and whose only scroller holds both.
+ *
+ * Two facts measured in the DOM, never stored and never read from a prop:
+ * - the block's parent block element is the root component: inline, a
+ *   database always sits in a note; the full page's root
+ *   (`affine-database-page-root`) renders the block directly;
+ * - its scroll container holds a `<doc-title>` whose `body-block-id` names
+ *   this block (`<doc-title .bodyBlockId>`, reflected): the page heading the
+ *   host composed above it. Without one, the page renders the database as
+ *   inline, its own title row shown.
+ *
+ * The parent test comes first: it fails at once for every inline database,
+ * so a text page never pays for the scroll-container walk.
+ */
+export declare function isStandaloneDatabase(element: StandaloneCandidate, blockId: string): boolean;

package/dist/_pkgs/affine-database-block/standalone-layout.js

@@ -0,0 +1,27 @@
+import { getScrollContainer } from '../affine-shared/utils/index.js';
+/**
+ * Whether a database block is drawn as the page itself rather than inside a
+ * text (ADR 0035 amendment of 2026-10-28): a full page whose heading is the
+ * database's name and whose only scroller holds both.
+ *
+ * Two facts measured in the DOM, never stored and never read from a prop:
+ * - the block's parent block element is the root component: inline, a
+ *   database always sits in a note; the full page's root
+ *   (`affine-database-page-root`) renders the block directly;
+ * - its scroll container holds a `<doc-title>` whose `body-block-id` names
+ *   this block (`<doc-title .bodyBlockId>`, reflected): the page heading the
+ *   host composed above it. Without one, the page renders the database as
+ *   inline, its own title row shown.
+ *
+ * The parent test comes first: it fails at once for every inline database,
+ * so a text page never pays for the scroll-container walk.
+ */
+export function isStandaloneDatabase(element, blockId) {
+    const root = element.rootComponent;
+    if (!root)
+        return false;
+    if (element.parentElement?.closest('[data-block-id]') !== root)
+        return false;
+    const container = getScrollContainer(element);
+    return !!container.querySelector(`doc-title[body-block-id="${CSS.escape(blockId)}"]`);
+}

package/dist/_pkgs/affine-database-block/translations.d.ts

@@ -0,0 +1,28 @@
+import type { ChromeWording } from '../affine-shared/services/index.js';
+/** Drawn in place of a view whose `sourceId` the host cannot resolve. */
+export declare const DATABASE_SOURCE_MISSING: ChromeWording;
+export declare const DATABASE_SOURCE_MISSING_HINT: ChromeWording;
+/**
+ * Drawn in place of a database that waits for its source, when the host
+ * requires one (`requireSource`, ADR 0035 amendment of 2026-10-29).
+ */
+export declare const DATABASE_SOURCE_REQUIRED: ChromeWording;
+export declare const DATABASE_SOURCE_REQUIRED_HINT: ChromeWording;
+/** Over native rows shown read-only, under the same host. */
+export declare const DATABASE_SOURCE_REQUIRED_READ_ONLY: ChromeWording;
+/**
+ * The creation popover's title (`@labre/affine-database-editor`) and the
+ * button of a database waiting for its source: one chrome word, one key,
+ * declared in core, the lowest reader.
+ */
+export declare const DATABASE_CREATION_TITLE: ChromeWording;
+/** Over native rows shown read-only: moves them into a new host database. */
+export declare const DATABASE_MOVE_INTO_SOURCE: ChromeWording;
+export declare const DATABASE_TURN_INTO_FAILED: ChromeWording;
+export declare const DATABASE_TURN_INTO_NESTED: ChromeWording;
+/** After 3 s of loading (`VALUES_SLOW_AFTER_MS`). */
+export declare const DATABASE_VALUES_LOADING: ChromeWording;
+export declare const DATABASE_VALUES_ERROR: ChromeWording;
+/** The chevron beside "New", as its label and tooltip. */
+export declare const DATABASE_NEW_RECORD_MORE: ChromeWording;
+export declare const DATABASE_WORDINGS: readonly ChromeWording[];