@formicoidea/labre-core 0.61.0 → 1.1.0

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

@@ -2,13 +2,15 @@ import { CaptionedBlockComponent } from '../affine-components/caption/index.js';
 import { menu, popMenu, popupTargetFromElement, } from '../affine-components/context-menu/index.js';
 import { DropIndicator } from '../affine-components/drop-indicator/index.js';
 import { PeekViewProvider } from '../affine-components/peek/index.js';
+import { LoadingIcon } from '../affine-components/icons/index.js';
 import { toast } from '../affine-components/toast/index.js';
 import { EDGELESS_TOP_CONTENTEDITABLE_SELECTOR } from '../affine-shared/consts/index.js';
-import { BlockCommentManager, CommentProviderIdentifier, DocModeProvider, NotificationProvider, PropertiesPanelProvider, TelemetryProvider, TOAST_COPIED_TO_CLIPBOARD, translateKey, } from '../affine-shared/services/index.js';
+import { getScrollContainer } from '../affine-shared/utils/index.js';
+import { BlockCommentManager, CommentProviderIdentifier, DataSourcePickerProvider, DocModeProvider, NotificationProvider, PropertiesPanelProvider, TelemetryProvider, TOAST_COPIED_TO_CLIPBOARD, translateKey, } from '../affine-shared/services/index.js';
 import { getDropResult } from '../affine-widget-drag-handle/index.js';
-import { createRecordDetail, createUniComponentFromWebComponent, DataViewRootUILogic, DataViewEventTraceKey, defineUniComponent, ExternalGroupByConfigProvider, NewRowMenuOpenerKey, PropertiesPanelOpenerKey, renderUniLit, traceViewEvent, uniMap, ViewCreationOffKey, } from '../data-view/index.js';
-import { CalendarExternalSourceProvider } from '../data-view/view-presets/index.js';
-import { widgetPresets } from '../data-view/widget-presets/index.js';
+import { createRecordDetail, createUniComponentFromWebComponent, DataViewRootUILogic, DataViewEventTraceKey, defineUniComponent, ExternalGroupByConfigProvider, NewRowMenuOpenerKey, PageLayoutKey, PropertiesPanelOpenerKey, renderUniLit, traceViewEvent, uniMap, ViewCreationOffKey, } from '../affine-database-engine/index.js';
+import { CalendarExternalSourceProvider } from '../affine-database-engine/view-presets/index.js';
+import { widgetPresets } from '../affine-database-engine/widget-presets/index.js';
 import { Rect } from '../global/gfx/index.js';
 import { CommentIcon, CopyIcon, DeleteIcon, MoreHorizontalIcon, } from '@blocksuite/icons/lit';
 import { BlockSelection } from '../std/index.js';
@@ -20,15 +22,19 @@ import { html, nothing } from 'lit';
 import { keyed } from 'lit/directives/keyed.js';
 import { popSideDetail } from './components/layout.js';
 import { DatabaseConfigExtension } from './config.js';
+import { DatabaseCreationMenuIdentifier } from './creation-menu.js';
 import { EditorHostKey } from './context/host-context.js';
 import { DatabaseBlockDataSource } from './data-source.js';
 import { HostedDataSourceBase } from './external-data-source.js';
 import { databaseBlockStyles, databaseContentStyles, databaseHeaderBarStyles, databaseHeaderContainerStyles, databaseOpsStyles, databaseSourceMissingHintStyles, databaseSourceMissingStyles, databaseTitleRowStyles, databaseTitleStyles, databaseToolbarRowStyles, databaseViewBarContainerStyles, } from './database-block-styles.js';
 import { BlockRenderer } from './detail-panel/block-renderer.js';
 import { NoteRenderer } from './detail-panel/note-renderer.js';
+import { sourceRequirement } from './linked-view.js';
 import { DatabaseSelection } from './selection.js';
+import { isStandaloneDatabase } from './standalone-layout.js';
 import { databaseOpenRowRequest, DatabaseDataSourceProvider, DatabaseInitialViewProvider, DatabaseNewRowMenuProvider, DatabaseOpenRowProvider, openDatabasePropertiesPanel, rowOpenedParams, } from './service/index.js';
-import { DATABASE_NEW_RECORD_MORE, DATABASE_SOURCE_MISSING, DATABASE_SOURCE_MISSING_HINT, } from './translations.js';
+import { 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, } from './translations.js';
+import { canTurnIntoSource, moveDatabaseRowsIntoSource, } from './turn-into-source.js';
 import { currentViewStorage, initialViewId } from './utils/current-view.js';
 import { getSingleDocIdFromText } from './utils/title-doc.js';
 import { DatabaseViewCreationIdentifier } from './view-creation.js';
@@ -144,6 +150,7 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
             ${renderUniLit(this.toolsWidget, props)}
           </div>
           ${renderUniLit(widgetPresets.quickSettingBar, props)}
+          ${this.renderReadOnlyNotice()}
           <affine-database-values-banner
             .dataSource="${this.dataSource}"
             .std="${this.std}"
@@ -239,6 +246,14 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
             return databaseSelection?.viewSelection;
         });
         this.virtualPadding$ = signal(0);
+        /**
+         * 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.
+         */
+        this.standalone$ = signal(false);
         // ADR 0035 §7: a view whose source the host cannot resolve keeps the title
         // and the view bar, so another view can be picked, and draws this instead of
         // its tools and body: nothing to filter, add or edit, and nothing rewritten.
@@ -267,12 +282,84 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
         </div>
       </div>`;
         };
+        /**
+         * 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).
+         */
+        this.renderSourceRequired = (dataViewLogic) => {
+            const dataSource = this.dataSource;
+            const sourceMissing = dataSource instanceof HostedDataSourceBase &&
+                dataSource.sourceMissing$.value;
+            if (sourceRequirement(this.std, this.model, sourceMissing) !== 'connect') {
+                return undefined;
+            }
+            const hosted = this.model.props.externalSourceId !== undefined;
+            const creationMenu = this.std.getOptional(DatabaseCreationMenuIdentifier);
+            const connect = creationMenu && !this.store.readonly$.value
+                ? () => creationMenu.open({
+                    std: this.std,
+                    blockId: this.blockId,
+                    anchor: this,
+                    viewId: dataViewLogic.view.id,
+                })
+                : undefined;
+            return html `<div class="${databaseHeaderContainerStyles}">
+        <div class="${databaseTitleRowStyles}">
+          ${this.renderTitle(dataViewLogic)}
+        </div>
+        ${hosted
+                ? html `<div
+              class="${databaseToolbarRowStyles} ${databaseHeaderBarStyles}"
+            >
+              ${this.renderViewBar({ dataViewLogic })}
+            </div>`
+                : nothing}
+      </div>
+      <div
+        class="${databaseSourceMissingStyles}"
+        data-testid="database-source-required"
+        role="status"
+      >
+        <div>${translateKey(this.std, ...DATABASE_SOURCE_REQUIRED)}</div>
+        <div class="${databaseSourceMissingHintStyles}">
+          ${translateKey(this.std, ...DATABASE_SOURCE_REQUIRED_HINT)}
+        </div>
+        ${connect
+                ? html `<data-view-component-button
+              data-testid="database-source-required-connect"
+              hoverType="border"
+              .onClick="${connect}"
+              .text="${translateKey(this.std, ...DATABASE_CREATION_TITLE)}"
+            ></data-view-component-button>`
+                : nothing}
+      </div>`;
+        };
+        /** "Move into a database" is waiting for the host: one call at a time. */
+        this.moving$ = signal(false);
+        this.moveIntoSource = () => {
+            if (this.moving$.peek())
+                return;
+            this.moving$.value = true;
+            moveDatabaseRowsIntoSource(this.std, this.model)
+                .catch(console.error)
+                .finally(() => {
+                this.moving$.value = false;
+            });
+        };
         this.#useZeroWidth_accessor_storage = true;
     }
     _buildDataSource() {
         const initFn = (dataSource) => {
             dataSource.serviceSet(EditorHostKey, this.host);
             dataSource.serviceSet(DataViewEventTraceKey, this.traceDatabaseEvent);
+            dataSource.serviceSet(PageLayoutKey, this.standalone$);
             // With a host properties panel, the view options' "Properties" opens
             // it (ADR 0035 §9b); without, the data-view's popover stays.
             if (this.std.getOptional(PropertiesPanelProvider)) {
@@ -292,6 +379,12 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
                     },
                 });
             }
+            // A view of a host database is deleted through the host's request
+            // (`deleteView`, ADR 0035 amendment of 2026-10-29); the data source
+            // reads the picker from its own scope, below the editor's.
+            const picker = this.std.getOptional(DataSourcePickerProvider);
+            if (picker)
+                dataSource.serviceSet(DataSourcePickerProvider, picker);
             // `{ database: false }` takes view creation away, never the views.
             if (!this.std.getOptional(DatabaseViewCreationIdentifier)) {
                 dataSource.serviceSet(ViewCreationOffKey, true);
@@ -314,6 +407,12 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
         const id = initialViewId(this.model.id, viewId => dataSource.viewManager.viewGet(viewId) != null, this.std.getOptional(DatabaseInitialViewProvider));
         if (id)
             dataSource.viewManager.setCurrentView(id);
+        // A native database under a host that requires a source is never edited
+        // natively, whatever its row count (`sourceRequirement`).
+        if (dataSource instanceof DatabaseBlockDataSource &&
+            sourceRequirement(this.std, this.model) !== 'none') {
+            dataSource.locked$.value = true;
+        }
         return dataSource;
     }
     get dataSource() {
@@ -366,6 +465,41 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
         })}
     </div>`;
     }
+    refreshStandalone() {
+        const standalone = isStandaloneDatabase(this, this.blockId);
+        this.toggleAttribute('data-standalone', standalone);
+        this.standalone$.value = standalone;
+    }
+    /**
+     * 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.
+     */
+    watchStandalone() {
+        const observer = new MutationObserver(() => {
+            this.refreshStandalone();
+            observe();
+        });
+        const observe = () => {
+            observer.disconnect();
+            const container = getScrollContainer(this);
+            observer.observe(container, { childList: true });
+            container.querySelectorAll('doc-title').forEach(title => {
+                observer.observe(title, {
+                    attributes: true,
+                    attributeFilter: ['body-block-id'],
+                });
+            });
+        };
+        observe();
+        this.disposables.add(() => observer.disconnect());
+        this.disposables.add(this.std.view.viewUpdated.subscribe(({ type }) => {
+            if (type === 'block')
+                this.refreshStandalone();
+        }));
+    }
     get optionsConfig() {
         return {
             configure: (_model, options) => options,
@@ -383,6 +517,40 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
         }
         return this.rootComponent;
     }
+    /**
+     * 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.
+     */
+    renderReadOnlyNotice() {
+        if (sourceRequirement(this.std, this.model) !== 'read-only') {
+            return nothing;
+        }
+        const canMove = canTurnIntoSource(this.std) && !this.store.readonly$.value;
+        const moving = this.moving$.value;
+        return html `<div
+      class="${databaseSourceMissingStyles}"
+      data-testid="database-source-required-read-only"
+      role="status"
+    >
+      <div>${translateKey(this.std, ...DATABASE_SOURCE_REQUIRED)}</div>
+      <div class="${databaseSourceMissingHintStyles}">
+        ${translateKey(this.std, ...DATABASE_SOURCE_REQUIRED_READ_ONLY)}
+      </div>
+      ${canMove
+            ? html `<data-view-component-button
+            data-testid="database-source-required-move"
+            hoverType="border"
+            aria-busy="${moving}"
+            .icon="${moving ? LoadingIcon() : undefined}"
+            .onClick="${this.moveIntoSource}"
+            .text="${translateKey(this.std, ...DATABASE_MOVE_INTO_SOURCE)}"
+          ></data-view-component-button>`
+            : nothing}
+    </div>`;
+    }
     renderDatabaseOps() {
         if (this.dataSource.readonly$.value) {
             return nothing;
@@ -400,6 +568,8 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
         this.setAttribute(RANGE_SYNC_EXCLUDE_ATTR, 'true');
         this.classList.add(databaseBlockStyles);
         this.listenFullWidthChange();
+        this.refreshStandalone();
+        this.watchStandalone();
         // Rebuild the source whenever the block is re-pointed at (or detached from)
         // an external collection. The first (synchronous) emission is skipped: the
         // source is still lazy at this point, so there is nothing to rebuild.
@@ -461,7 +631,7 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
             setSelection: this.setSelection,
             dataSource: this.dataSource,
             headerWidget: this.headerWidget,
-            viewPlaceholder: this.renderSourceMissing,
+            viewPlaceholder: logic => this.renderSourceRequired(logic) ?? this.renderSourceMissing(logic),
             onDrag: this.onDrag,
             clipboard: this.std.clipboard,
             dnd: this.std.dnd,

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

@@ -1,5 +1,5 @@
-import type { DetailSlotProps } from '../../data-view/index.js';
-import type { KanbanSingleView, TableSingleView } from '../../data-view/view-presets/index.js';
+import type { DetailSlotProps } from '../../affine-database-engine/index.js';
+import type { KanbanSingleView, TableSingleView } from '../../affine-database-engine/view-presets/index.js';
 import type { EditorHost } from '../../std/index.js';
 import { ShadowlessElement } from '../../std/index.js';
 declare const BlockRenderer_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}/detail-panel/note-renderer.d.ts

@@ -1,5 +1,5 @@
 import { type DatabaseBlockModel } from '../../affine-model/index.js';
-import type { DetailSlotProps, SingleView } from '../../data-view/index.js';
+import type { DetailSlotProps, SingleView } from '../../affine-database-engine/index.js';
 import { type EditorHost, ShadowlessElement } from '../../std/index.js';
 declare const NoteRenderer_base: typeof ShadowlessElement & import("../../global/utils/types.js").Constructor<import("../../global/lit/with-disposable.js").DisposableClass>;
 export declare class NoteRenderer extends NoteRenderer_base implements DetailSlotProps {

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

@@ -1,6 +1,6 @@
 import type { DatabaseBlockModel } from '../affine-model/index.js';
 import type { InsertToPosition } from '../affine-shared/utils/index.js';
-import { type DatabaseFlags, DataSourceBase, type DataViewDataType, type PropertyMetaConfig, type TypeInstance, type ViewManager, type ViewMeta } from '../data-view/index.js';
+import { type DatabaseFlags, DataSourceBase, type DataViewDataType, type PropertyMetaConfig, type TypeInstance, type ViewManager, type ViewMeta } from '../affine-database-engine/index.js';
 import { DisposableGroup } from '../global/disposable/index.js';
 import { type ReadonlySignal } from '@preact/signals-core';
 /**
@@ -114,6 +114,13 @@ export declare abstract class HostedDataSourceBase extends DataSourceBase {
     propertyDataGet(propertyId: string): Record<string, unknown>;
     propertyDataTypeGet(propertyId: string): TypeInstance | undefined;
     featureFlags$: ReadonlySignal<DatabaseFlags>;
+    /**
+     * 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).
+     */
+    readonly locked$: import("@preact/signals-core").Signal<boolean>;
     readonly$: ReadonlySignal<boolean>;
     viewConverts: import("./index.js").ViewConvertConfig[];
     viewMetas: ViewMeta[];

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

@@ -1,8 +1,9 @@
-import { FeatureFlagService } from '../affine-shared/services/index.js';
-import { DataSourceBase, ViewManagerBase, } from '../data-view/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-block-database → affine-database-block}/index.d.ts

@@ -1,7 +1,9 @@
 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';
 export * from './data-source.js';
 export * from './database-block.js';
 export * from './external-data-source.js';
@@ -14,5 +16,7 @@ export * from './service/index.js';
 export * from './utils/block-utils.js';
 export * from './view-creation.js';
 export * from './views/index.js';
-export * from '../data-view/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-block-database → affine-database-block}/index.js

@@ -1,7 +1,9 @@
 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';
 export * from './data-source.js';
 export * from './database-block.js';
 export * from './external-data-source.js';
@@ -14,5 +16,9 @@ export * from './service/index.js';
 export * from './utils/block-utils.js';
 export * from './view-creation.js';
 export * from './views/index.js';
-export * from '../data-view/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

@@ -0,0 +1,119 @@
+import type { DatabaseBlockModel } from '../affine-model/index.js';
+import { type DataSourcePickerDatabase, type DataSourcePickerService } from '../affine-shared/services/index.js';
+import type { BlockStdScope } from '../std/index.js';
+import { type BlockModel } from '../store/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 declare function insertLinkedDatabaseView(std: BlockStdScope, options: {
+    /** The block the view goes after. */
+    after: BlockModel;
+    database: Pick<DataSourcePickerDatabase, 'id' | 'title'>;
+    sourceId: string;
+    viewType: string;
+    /** Drop `after` when it is an empty paragraph (a slash entry's line). */
+    removeEmptyLine?: boolean;
+}): string | null;
+/**
+ * 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 declare function connectDatabaseToSource(std: BlockStdScope, model: DatabaseBlockModel, choice: {
+    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
+ * after `after`. Nothing is written until the host answers; `null`, or a
+ * database with no source, writes nothing.
+ */
+export declare function createHostedDatabaseView(std: BlockStdScope, picker: DataSourcePickerService, options: {
+    after: BlockModel;
+    viewType: string;
+    removeEmptyLine?: boolean;
+}): Promise<string | null>;