@formicoidea/labre-core 0.61.0 → 1.1.0

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

@@ -0,0 +1,82 @@
+/* ── A hosted source (ADR 0035 §7, issue B1) ───────────────────────────── */
+/** Drawn in place of a view whose `sourceId` the host cannot resolve. */
+export const DATABASE_SOURCE_MISSING = [
+    'com.labre.database.source-missing',
+    'Source not found',
+];
+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 = [
+    'com.labre.database.values.loading',
+    'Values are still loading…',
+];
+export const DATABASE_VALUES_ERROR = [
+    'com.labre.database.values.error',
+    'Values could not be loaded. Nothing was changed.',
+];
+// Retry is the resource status's own word (`RESOURCE_STATUS_RETRY`,
+// `@labre/affine-components/translations`): one chrome word, one key.
+/* ── The host menu beside "New" (ADR 0035, amendment of 2026-10-14) ──── */
+/** The chevron beside "New", as its label and tooltip. */
+export const DATABASE_NEW_RECORD_MORE = [
+    'com.labre.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;

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

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

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

@@ -1,7 +1,7 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
 import { DatabaseBlockModel } from '../affine-model/index.js';
 import { SlashMenuConfigExtension } from '../affine-widget-slash-menu/index.js';
-import { StandaloneCellMetaExtension } from '../data-view/index.js';
+import { StandaloneCellMetaExtension } from '../affine-database-engine/index.js';
 import { BlockViewExtension, FlavourExtension } from '../std/index.js';
 import { literal } from 'lit/static-html.js';
 import { z } from 'zod';

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

@@ -1,4 +1,4 @@
-import type { ViewMeta } from '../../data-view/index.js';
+import type { ViewMeta } from '../../affine-database-engine/index.js';
 /**
  * Every preset a stored `affine:database` view can be drawn with (ADR 0035
  * §6). Calendar stays here: calendar views were creatable until 0.48, so

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

@@ -1,4 +1,4 @@
-import { viewConverts, viewPresets } from '../../data-view/view-presets/index.js';
+import { viewConverts, viewPresets, } from '../../affine-database-engine/view-presets/index.js';
 /**
  * Every preset a stored `affine:database` view can be drawn with (ADR 0035
  * §6). Calendar stays here: calendar views were creatable until 0.48, so

package/dist/_pkgs/{data-view → affine-database-engine}/core/view/open-in.d.ts

@@ -19,7 +19,7 @@ export declare function viewOpenIn(data: object | undefined): DatabaseViewOpenIn
 export declare function viewOpenInSet(view: SingleView, openIn: DatabaseViewOpenIn): boolean;
 /**
  * Whether the source says its rows are pages (`rowsAreDocuments`, on the
- * hosted source of `blocks/database`, ADR 0035 §9a). Only then does a row
+ * hosted source of `database/block`, ADR 0035 §9a). Only then does a row
  * open where `openIn` says, so only then is the setting offered: a
  * block-backed row keeps the detail panel whatever the view stores. Read
  * structurally because the flag is declared above this package.

package/dist/_pkgs/{data-view → affine-database-engine}/core/view/open-in.js

@@ -28,7 +28,7 @@ export function viewOpenInSet(view, openIn) {
 }
 /**
  * Whether the source says its rows are pages (`rowsAreDocuments`, on the
- * hosted source of `blocks/database`, ADR 0035 §9a). Only then does a row
+ * hosted source of `database/block`, ADR 0035 §9a). Only then does a row
  * open where `openIn` says, so only then is the setting offered: a
  * block-backed row keeps the detail panel whatever the view stores. Read
  * structurally because the flag is declared above this package.

package/dist/_pkgs/{data-view → affine-database-engine}/core/view-manager/index.d.ts

@@ -6,3 +6,5 @@ export * from './view-manager.js';
 export * from './properties-panel-opener.js';
 export * from './view-creation.js';
 export * from './new-row-menu-opener.js';
+export * from './view-settings-menu.js';
+export * from './page-layout.js';

package/dist/_pkgs/{data-view → affine-database-engine}/core/view-manager/index.js

@@ -6,3 +6,5 @@ export * from './view-manager.js';
 export * from './properties-panel-opener.js';
 export * from './view-creation.js';
 export * from './new-row-menu-opener.js';
+export * from './view-settings-menu.js';
+export * from './page-layout.js';

package/dist/_pkgs/affine-database-engine/core/view-manager/page-layout.d.ts

@@ -0,0 +1,12 @@
+import type { ReadonlySignal } from '@preact/signals-core';
+/**
+ * Set on a data source (`serviceSet`) by the block that hosts its views:
+ * `true` while the views are the page itself (a database's full page, ADR
+ * 0035 amendment of 2026-10-28). A table then grows to its columns' width
+ * and its column header sticks natively to the page's scroller, which
+ * scrolls both ways; data-view's script leaves that header alone.
+ *
+ * Absent reads `false`, the 0.61 inline table. Set by the database block
+ * from facts it measures, never stored.
+ */
+export declare const PageLayoutKey: import("../../../global/di/types.js").ServiceIdentifier<ReadonlySignal<boolean>> & (<U extends ReadonlySignal<boolean> = ReadonlySignal<boolean>>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);

package/dist/_pkgs/affine-database-engine/core/view-manager/page-layout.js

@@ -0,0 +1,12 @@
+import { createIdentifier } from '../../../global/di/index.js';
+/**
+ * Set on a data source (`serviceSet`) by the block that hosts its views:
+ * `true` while the views are the page itself (a database's full page, ADR
+ * 0035 amendment of 2026-10-28). A table then grows to its columns' width
+ * and its column header sticks natively to the page's scroller, which
+ * scrolls both ways; data-view's script leaves that header alone.
+ *
+ * Absent reads `false`, the 0.61 inline table. Set by the database block
+ * from facts it measures, never stored.
+ */
+export const PageLayoutKey = createIdentifier('DataViewPageLayout');

package/dist/_pkgs/affine-database-engine/core/view-manager/view-settings-menu.d.ts

@@ -0,0 +1,32 @@
+import type { MenuConfig, PopupTarget } from '../../../affine-components/context-menu/index.js';
+import type { BlockStdScope } from '../../../std/index.js';
+import type { ExtensionType } from '../../../store/index.js';
+import type { Wording } from '../utils/wording.js';
+import type { DataViewUILogicBase } from '../view/data-view-base.js';
+/** What the view settings menu hands a {@link ViewSettingsMenu} when it opens. */
+export interface ViewSettingsMenuContext {
+    /** The editor the view is drawn in. */
+    std: BlockStdScope;
+    dataViewLogic: DataViewUILogicBase;
+    /** Where the view settings menu was popped: a setting's own menu pops there too. */
+    target: PopupTarget;
+    /** Reopens the view settings menu: a setting's "back". */
+    reopen(): void;
+    /** The view settings' own wordings, resolved through the editor's catalogue. */
+    wording: Wording;
+}
+/**
+ * Entries of the view settings menu that something above data-view knows
+ * how to offer (ADR 0035 amendment of 2026-10-28): the `core-database`
+ * bundle registers one from its tooling extension for "Source", which needs
+ * the data-source picker it alone reads. Drawn in the Layout group, after
+ * "Layout" (Notion's order: Layout, Source). A registry between library
+ * packages, never filled by a host, so it has no row in the seams table.
+ * Absent, or answering `undefined` for a view it does not handle, the menu
+ * is the 0.61 one.
+ */
+export interface ViewSettingsMenu {
+    items(context: ViewSettingsMenuContext): MenuConfig[] | undefined;
+}
+export declare const ViewSettingsMenuIdentifier: import("../../../global/di/types.js").ServiceIdentifier<ViewSettingsMenu> & (<U extends ViewSettingsMenu = ViewSettingsMenu>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
+export declare function ViewSettingsMenuExtension(menu: ViewSettingsMenu): ExtensionType;

package/dist/_pkgs/affine-database-engine/core/view-manager/view-settings-menu.js

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

package/dist/_pkgs/{data-view → affine-database-engine}/view-presets/table/pc/header/column-header.js

@@ -42,6 +42,7 @@ import { property, query } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
 import { styleMap } from 'lit/directives/style-map.js';
 import { html } from 'lit/static-html.js';
+import { PageLayoutKey } from '../../../../core/view-manager/page-layout.js';
 import { cellDivider } from '../../styles.js';
 import { tableStyle } from '../table-view-style.js';
 import {} from '../table-view-ui-logic.js';
@@ -97,10 +98,15 @@ let DatabaseColumnHeader = (() => {
                     if (!scrollContainer) {
                         return;
                     }
-                    // A host page that makes the header natively sticky (the full-page
-                    // database, ADR 0035 amendment of 2026-10-26) needs no follow-up:
-                    // this translate, a frame late, would double its offset.
-                    if (getComputedStyle(this).position === 'sticky') {
+                    // When the views are the page (`PageLayoutKey`, ADR 0035 amendments
+                    // of 2026-10-26 and 2026-10-28) the header is natively sticky: this
+                    // translate, a frame late, would double its offset. One left from
+                    // before the page layout applied is dropped.
+                    if (this.tableViewLogic.view.serviceGet(PageLayoutKey)?.peek()) {
+                        if (this.preMove !== 0) {
+                            this.preMove = 0;
+                            this.style.transform = '';
+                        }
                         return;
                     }
                     this.autoSetHeaderPosition(group, scrollContainer);

package/dist/_pkgs/{data-view → affine-database-engine}/view-presets/table/pc/table-view-style.js

@@ -7,6 +7,21 @@ export const tableViewStyle = css({
     '& *': {
         boxSizing: 'border-box',
     },
+    // The views are the page (`PageLayoutKey`, a database's full page): the
+    // table is as wide as its columns and the page scrolls sideways, so its
+    // own wrappers stop being scrollers and the column header sticks natively
+    // to the page's top (the header's script then leaves it alone).
+    '&[data-page-layout]': {
+        width: 'max-content',
+        minWidth: '100%',
+    },
+    '&[data-page-layout] .dv-table-wrapper, &[data-page-layout] .dv-table-scroll-container': {
+        overflow: 'visible',
+    },
+    '&[data-page-layout] affine-database-column-header': {
+        position: 'sticky',
+        top: 0,
+    },
 });
 export const tableWrapperStyle = css({
     overflowY: 'auto',

package/dist/_pkgs/{data-view → affine-database-engine}/view-presets/table/pc/table-view-ui-logic.js

@@ -6,6 +6,7 @@ import { repeat } from 'lit/directives/repeat.js';
 import { styleMap } from 'lit/directives/style-map.js';
 import { html } from 'lit/static-html.js';
 import { createUniComponentFromWebComponent, renderUniLit, } from '../../../core/index.js';
+import { PageLayoutKey } from '../../../core/view-manager/page-layout.js';
 import { DataViewUIBase, DataViewUILogicBase, } from '../../../core/view/data-view-base.js';
 import { TableClipboardController } from './controller/clipboard.js';
 import { TableDragController } from './controller/drag.js';
@@ -139,6 +140,8 @@ export class TableViewUI extends DataViewUIBase {
     ></affine-data-view-table-group>`;
     }
     render() {
+        // Read in the render, so the table follows the block's measure.
+        this.toggleAttribute('data-page-layout', !!this.logic.view.serviceGet(PageLayoutKey)?.value);
         const vPadding = this.logic.root.config.virtualPadding$.value;
         const wrapperStyle = styleMap({
             marginLeft: `-${vPadding}px`,

package/dist/_pkgs/{data-view → affine-database-engine}/widget-presets/tools/presets/view-options/view-options.d.ts

@@ -29,4 +29,11 @@ declare global {
         'data-view-header-tools-view-options': DataViewHeaderToolsViewOptions;
     }
 }
-export declare const popViewOptions: (target: PopupTarget, dataViewLogic: DataViewUILogicBase, onClose?: () => void, wording?: Wording) => void;
+/**
+ * The view settings menu. `std` (optional and last, so a 0.61 caller
+ * compiles unchanged) is the editor the view is drawn in: with it, the
+ * entries a {@link ViewSettingsMenuIdentifier} offers join the Layout group,
+ * after "Layout" (the `core-database` bundle's "Source"); without it, the
+ * 0.61 menu.
+ */
+export declare const popViewOptions: (target: PopupTarget, dataViewLogic: DataViewUILogicBase, onClose?: () => void, wording?: Wording, std?: BlockStdScope) => void;