@formicoidea/labre-core 1.0.0 → 1.1.0

package/dist/_pkgs/affine-database-block/external-data-source.js

@@ -1,8 +1,9 @@
-import { FeatureFlagService } from '../affine-shared/services/index.js';
+import { DataSourcePickerProvider, FeatureFlagService, } from '../affine-shared/services/index.js';
 import { DataSourceBase, ViewManagerBase, } from '../affine-database-engine/index.js';
 import { DisposableGroup } from '../global/disposable/index.js';
 import { computed, signal } from '@preact/signals-core';
 import { deleteView, duplicateView, moveViewTo, updateView, } from './utils/block-utils.js';
+import { deleteViewThroughHost } from './view-deletion.js';
 import { databaseBlockViewConverts, databaseBlockViewMetaGet, databaseBlockViews, } from './views/index.js';
 /**
  * Intermediate base for `affine:database` data sources whose **view config**
@@ -87,10 +88,17 @@ export class HostedDataSourceBase extends DataSourceBase {
                 enable_table_virtual_scroll: featureFlagService.getFlag('enable_table_virtual_scroll') ?? false,
             };
         });
+        /**
+         * Refuses every edit on a writable store: a database with no source, under
+         * a host that requires one, shows its native rows read-only (ADR 0035
+         * amendment of 2026-10-29). Every write path of the view layer reads
+         * `readonly$` (cells, paste, drag, "New", view and property menus).
+         */
+        this.locked$ = signal(false);
         // Mobile edits too (ADR 0035 §1, B5): the table and kanban presets ship
         // their own touch renderers, chosen by `DataViewRootUILogic`.
         this.readonly$ = computed(() => {
-            return this._model.store.readonly;
+            return this._model.store.readonly || this.locked$.value;
         });
         this.viewConverts = databaseBlockViewConverts;
         this.viewMetas = databaseBlockViews;
@@ -185,8 +193,26 @@ export class HostedDataSourceBase extends DataSourceBase {
         return viewData.id;
     }
     viewDataDelete(viewId) {
-        this._model.store.captureSync();
-        deleteView(this._model, viewId);
+        deleteViewThroughHost({
+            model: this._model,
+            viewId,
+            picker: this.serviceGet(DataSourcePickerProvider),
+            removeNow: () => {
+                this._model.store.captureSync();
+                deleteView(this._model, viewId);
+            },
+            // The view manager moved on when the gesture was made; a removal the
+            // host made later must not leave a vanished view current.
+            afterRemove: () => {
+                const manager = this.viewManager;
+                const views = manager.views$.peek();
+                const current = manager.currentViewId$.peek();
+                const next = views[0];
+                if (current !== undefined && !views.includes(current) && next) {
+                    manager.setCurrentView(next);
+                }
+            },
+        });
     }
     viewDataDuplicate(id) {
         return duplicateView(this._model, id);

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

@@ -1,5 +1,6 @@
 export * from './adapters/index.js';
 export * from './commands.js';
+export { canCreateDatabase, createDatabaseByGesture, } from './configs/slash-menu.js';
 export * from './config.js';
 export * from './context/index.js';
 export * from './creation-menu.js';
@@ -17,3 +18,5 @@ export * from './view-creation.js';
 export * from './views/index.js';
 export * from '../affine-database-engine/index.js';
 export * from './linked-view.js';
+export * from './turn-into-source.js';
+export { DATABASE_CREATION_TITLE } from './translations.js';

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

@@ -1,5 +1,6 @@
 export * from './adapters/index.js';
 export * from './commands.js';
+export { canCreateDatabase, createDatabaseByGesture, } from './configs/slash-menu.js';
 export * from './config.js';
 export * from './context/index.js';
 export * from './creation-menu.js';
@@ -17,3 +18,7 @@ export * from './view-creation.js';
 export * from './views/index.js';
 export * from '../affine-database-engine/index.js';
 export * from './linked-view.js';
+export * from './turn-into-source.js';
+// The creation popover (`@labre/affine-database-editor`) titles itself with
+// the wording core declares for its "Connect a source" button.
+export { DATABASE_CREATION_TITLE } from './translations.js';

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

@@ -47,6 +47,65 @@ export declare function connectDatabaseToSource(std: BlockStdScope, model: Datab
     database: Pick<DataSourcePickerDatabase, 'id' | 'title'>;
     sourceId: string;
 }): boolean;
+/**
+ * What a database shows under a host that requires a source
+ * (`requireSource`, ADR 0035 amendment of 2026-10-29, product owner's
+ * decision of the same day). The SOURCE decides, never the row count:
+ *
+ * - `'none'`: the host does not require one, or the block reads a source it
+ *   resolves. A hosted database with no row is an ordinary empty table.
+ * - `'connect'`: no source and no row (the creation gesture left
+ *   unfinished), or a hosted source the host no longer resolves (the source
+ *   or its base deleted). An empty view offering "Connect a source".
+ * - `'read-only'`: no source but native rows (a database written before
+ *   1.0, by a host without a picker, or pasted from one). The rows render,
+ *   since documents render forever, and nothing native can be edited.
+ *
+ * Nothing is stored: a native database and the gesture left unfinished are
+ * the same bytes, so neither may be edited natively.
+ */
+export type SourceRequirement = 'none' | 'connect' | 'read-only';
+export declare function sourceRequirement(std: BlockStdScope, model: DatabaseBlockModel, sourceMissing?: boolean): SourceRequirement;
+/**
+ * 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 declare function reconnectDatabaseView(std: BlockStdScope, model: DatabaseBlockModel, choice: {
+    database: Pick<DataSourcePickerDatabase, 'id'>;
+    sourceId: string;
+    viewId: string;
+}): boolean;
+/**
+ * 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 declare function canConvertToDatabase(std: BlockStdScope): boolean;
+/**
+ * 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 declare function moveDatabaseIntoSource(std: BlockStdScope, model: DatabaseBlockModel, choice: {
+    database: Pick<DataSourcePickerDatabase, 'id' | 'title'>;
+    sourceId: string;
+}): boolean;
 /**
  * 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

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

@@ -1,4 +1,4 @@
-import { TelemetryProvider, } from '../affine-shared/services/index.js';
+import { DataSourcePickerProvider, TelemetryProvider, } from '../affine-shared/services/index.js';
 import { nanoid, Text } from '../store/index.js';
 import { DatabaseDataSourceProvider } from './service/index.js';
 /**
@@ -131,6 +131,136 @@ export function connectDatabaseToSource(std, model, choice) {
     });
     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

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

@@ -2,6 +2,24 @@ 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;

package/dist/_pkgs/affine-database-block/translations.js

@@ -8,6 +8,46 @@ export const DATABASE_SOURCE_MISSING_HINT = [
     'com.labre.database.source-missing.hint',
     'The source this view reads was deleted or cannot be reached. Pick another view.',
 ];
+/**
+ * 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 const DATABASE_SOURCE_REQUIRED = [
+    'com.labre.database.source-required',
+    'No source connected',
+];
+export const DATABASE_SOURCE_REQUIRED_HINT = [
+    'com.labre.database.source-required.hint',
+    'Connect a source to show its rows here.',
+];
+/** Over native rows shown read-only, under the same host. */
+export const DATABASE_SOURCE_REQUIRED_READ_ONLY = [
+    'com.labre.database.source-required.read-only',
+    'This table has no source: its rows are read-only.',
+];
+/**
+ * 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 const DATABASE_CREATION_TITLE = [
+    'com.labre.database.creation.title',
+    'Connect a source',
+];
+/* ── Turning a table into a source (ADR 0035, amendment of 2026-10-29) ── */
+/** Over native rows shown read-only: moves them into a new host database. */
+export const DATABASE_MOVE_INTO_SOURCE = [
+    'com.labre.database.turn-into.move',
+    'Move into a database',
+];
+export const DATABASE_TURN_INTO_FAILED = [
+    'com.labre.database.turn-into.failed',
+    'The table could not be created. Nothing was changed.',
+];
+export const DATABASE_TURN_INTO_NESTED = [
+    'com.labre.database.turn-into.nested',
+    'Rows with nested blocks cannot be moved here. Nothing was changed.',
+];
 /* ── Cell hydration (ADR 0035 §9e, issue B2) ───────────────────────────── */
 /** After 3 s of loading (`VALUES_SLOW_AFTER_MS`). */
 export const DATABASE_VALUES_LOADING = [
@@ -27,9 +67,16 @@ export const DATABASE_NEW_RECORD_MORE = [
     'Templates and options',
 ];
 export const DATABASE_WORDINGS = [
+    DATABASE_CREATION_TITLE,
+    DATABASE_MOVE_INTO_SOURCE,
     DATABASE_NEW_RECORD_MORE,
     DATABASE_SOURCE_MISSING,
     DATABASE_SOURCE_MISSING_HINT,
+    DATABASE_SOURCE_REQUIRED,
+    DATABASE_SOURCE_REQUIRED_HINT,
+    DATABASE_SOURCE_REQUIRED_READ_ONLY,
+    DATABASE_TURN_INTO_FAILED,
+    DATABASE_TURN_INTO_NESTED,
     DATABASE_VALUES_ERROR,
     DATABASE_VALUES_LOADING,
 ];

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

@@ -0,0 +1,38 @@
+import type { DatabaseBlockModel } from '../affine-model/index.js';
+import { type DataSourcePickerContent } from '../affine-shared/services/index.js';
+import type { BlockStdScope } from '../std/index.js';
+import type { BlockModel } from '../store/index.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 declare const TURN_INTO_TITLE_PROPERTY = "title";
+/** The blocks, less those nested in another of them: they ride in its body. */
+export declare function outermostBlocks(blocks: readonly BlockModel[]): BlockModel[];
+/** One row per block, its title the block's text, its body its children. */
+export declare function blocksContent(std: BlockStdScope, blocks: readonly BlockModel[]): DataSourcePickerContent;
+/**
+ * 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 declare function databaseContent(std: BlockStdScope, model: DatabaseBlockModel): DataSourcePickerContent;
+/** Whether the host turns content into a source where one is required. */
+export declare function canTurnIntoSource(std: BlockStdScope): boolean;
+/**
+ * "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 declare function turnBlocksIntoSource(std: BlockStdScope, selected: readonly BlockModel[], viewType: string): Promise<boolean>;
+/**
+ * "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 declare function moveDatabaseRowsIntoSource(std: BlockStdScope, model: DatabaseBlockModel): Promise<boolean>;

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;