@formicoidea/labre-core 0.47.1 → 0.49.0

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

@@ -0,0 +1,109 @@
+import { 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;
+}
+/**
+ * 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/properties/index.d.ts

@@ -1,4 +1,6 @@
 export * from './converts.js';
+export { hostedTextColumnConfig } from './text/hosted.js';
+export { hostedTitleColumnConfig } from './title/hosted.js';
 export declare const databaseBlockProperties: {
     checkboxColumnConfig: import("../index.js").PropertyMetaConfig<"checkbox", {}, boolean, boolean>;
     dateColumnConfig: import("../index.js").PropertyMetaConfig<"date", {}, number | null, number | null>;

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

@@ -4,6 +4,8 @@ import { linkColumnConfig } from './link/cell-renderer.js';
 import { richTextColumnConfig } from './rich-text/cell-renderer.js';
 import { titleColumnConfig } from './title/cell-renderer.js';
 export * from './converts.js';
+export { hostedTextColumnConfig } from './text/hosted.js';
+export { hostedTitleColumnConfig } from './title/hosted.js';
 const { checkboxPropertyConfig, datePropertyConfig, multiSelectPropertyConfig, numberPropertyConfig, progressPropertyConfig, selectPropertyConfig, } = propertyPresets;
 export const databaseBlockProperties = {
     checkboxColumnConfig: checkboxPropertyConfig,

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

@@ -0,0 +1,15 @@
+import type { PropertyMetaConfig } from '../../../data-view/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
+ * a string, drawn and edited by the table's plain-text cell (no second
+ * drawing), offered by "+ property" and "Type".
+ *
+ * The preset itself stays `hide: true` and out of `databaseBlockProperties`:
+ * the inline database's Text is `rich-text` (a `Text` per cell), and offering
+ * both would put two "Text" types in its menus and let it store a column type
+ * a 0.48 client does not draw. Only a source that lists this meta in its
+ * `getPropertyMetas` and answers it from `propertyMetaGet('text')` offers it.
+ * Named as the inline Text column: one wording for one notion.
+ */
+export declare const hostedTextColumnConfig: PropertyMetaConfig;

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

@@ -0,0 +1,24 @@
+import { propertyPresets } from '../../../data-view/property-presets/index.js';
+import { richTextPropertyModelConfig } from '../rich-text/define.js';
+const { textPropertyConfig } = propertyPresets;
+/**
+ * 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
+ * a string, drawn and edited by the table's plain-text cell (no second
+ * drawing), offered by "+ property" and "Type".
+ *
+ * The preset itself stays `hide: true` and out of `databaseBlockProperties`:
+ * the inline database's Text is `rich-text` (a `Text` per cell), and offering
+ * both would put two "Text" types in its menus and let it store a column type
+ * a 0.48 client does not draw. Only a source that lists this meta in its
+ * `getPropertyMetas` and answers it from `propertyMetaGet('text')` offers it.
+ * Named as the inline Text column: one wording for one notion.
+ */
+export const hostedTextColumnConfig = {
+    ...textPropertyConfig,
+    config: {
+        ...textPropertyConfig.config,
+        name: richTextPropertyModelConfig.config.name,
+        hide: false,
+    },
+};

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

@@ -0,0 +1,16 @@
+import { type PropertyMetaConfig } from '../../../data-view/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
+ * store, so drawing a base never loads a row's document.
+ *
+ * The same `title` type as the inline title column, so a stored column, a
+ * view's `header.titleColumn` and the fixed-property rules read it unchanged;
+ * only its value is a string instead of the row block's `Text`. Drawn and
+ * edited by data-view's plain-text cell, the table's own (no second drawing);
+ * a committed edit reaches the source's `cellValueChange` as a string, and the
+ * source writes it to its store. A source answers it from `propertyMetaGet`
+ * when `rowsAreDocuments` (`HostedDataSourceBase`).
+ */
+export declare const hostedTitlePropertyModelConfig: import("../../index.js").PropertyModel<"title", {}, string, string>;
+export declare const hostedTitleColumnConfig: PropertyMetaConfig;

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

@@ -0,0 +1,42 @@
+import { createIcon, t } from '../../../data-view/index.js';
+import { propertyPresets } from '../../../data-view/property-presets/index.js';
+import zod from 'zod';
+import { titleColumnType, titlePropertyModelConfig } from './define.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
+ * store, so drawing a base never loads a row's document.
+ *
+ * The same `title` type as the inline title column, so a stored column, a
+ * view's `header.titleColumn` and the fixed-property rules read it unchanged;
+ * only its value is a string instead of the row block's `Text`. Drawn and
+ * edited by data-view's plain-text cell, the table's own (no second drawing);
+ * a committed edit reaches the source's `cellValueChange` as a string, and the
+ * source writes it to its store. A source answers it from `propertyMetaGet`
+ * when `rowsAreDocuments` (`HostedDataSourceBase`).
+ */
+export const hostedTitlePropertyModelConfig = titleColumnType.modelConfig({
+    // One wording and one data shape with the inline title column.
+    name: titlePropertyModelConfig.config.name,
+    propertyData: titlePropertyModelConfig.config.propertyData,
+    jsonValue: {
+        schema: zod.string(),
+        type: () => t.string.instance(),
+        isEmpty: ({ value }) => !value,
+    },
+    rawValue: {
+        schema: zod.string(),
+        default: () => '',
+        toString: ({ value }) => value ?? '',
+        fromString: ({ value }) => ({ value }),
+        toJson: ({ value }) => value ?? '',
+        fromJson: ({ value }) => value,
+    },
+    fixed: titlePropertyModelConfig.config.fixed,
+});
+// Typed as the meta a source's `propertyMetaGet` returns, so a host returns
+// it as is.
+export const hostedTitleColumnConfig = hostedTitlePropertyModelConfig.createPropertyMeta({
+    icon: createIcon('TitleIcon'),
+    cellRenderer: propertyPresets.textPropertyConfig.renderer.cellRenderer,
+});

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

@@ -14,3 +14,6 @@ export interface DatabaseDataSourceProvider {
     createDataSource(model: DatabaseBlockModel, init?: (ds: DataSourceBase) => void): DataSourceBase;
 }
 export declare const DatabaseDataSourceProvider: import("../../global/di/types.js").ServiceIdentifier<DatabaseDataSourceProvider> & (<U extends DatabaseDataSourceProvider = DatabaseDataSourceProvider>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
+export * from './open-row.js';
+export * from './properties-panel.js';
+export * from './new-row-menu.js';

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

@@ -1,3 +1,6 @@
 import { createIdentifier } from '../../global/di/index.js';
 export const DatabaseBlockConfigService = createIdentifier('AffineDatabaseBlockConfigService');
 export const DatabaseDataSourceProvider = createIdentifier('affine:database-data-source-provider');
+export * from './open-row.js';
+export * from './properties-panel.js';
+export * from './new-row-menu.js';

package/dist/_pkgs/affine-block-database/service/new-row-menu.d.ts

@@ -0,0 +1,49 @@
+import type { ExtensionType } from '../../store/index.js';
+/**
+ * What a database asks the host to open beside its "New" button (ADR 0035
+ * amendment of 2026-10-14, labre PRD REQ-DB-6, 14 and 15):
+ *
+ * - `anchor`: the chevron the menu hangs from;
+ * - `blockId`: the `affine:database` block that hosts the view, so the host
+ *   can tell a base's own page from an inline view of it;
+ * - `viewId`: the view the gesture came from.
+ *
+ * Only widens: a new field is optional.
+ */
+export interface DatabaseNewRowMenuRequest {
+    anchor: HTMLElement;
+    blockId: string;
+    viewId: string;
+}
+/**
+ * The host's menu of ways to add a row (its templates, a default to pick):
+ * the library draws the chevron and asks, the host draws the menu and does
+ * the work. The main part of "New" never reaches it: it adds a row through
+ * the source's `rowAdd`, as without the seam, which is where a host applies
+ * its default template.
+ */
+export interface DatabaseNewRowMenuService {
+    open(request: DatabaseNewRowMenuRequest): void;
+    /**
+     * Whether this block and view have a menu to open (a base's own page
+     * does, an inline table of it may not). Asked each time "New" renders, so
+     * the answer may change; answer from what you already hold, it runs on
+     * every render. Absent, every view has one, as in the first release of
+     * the seam. `false` draws the single "New" of 0.48.
+     */
+    canOpen?(request: DatabaseNewRowMenuTarget): boolean;
+}
+/** Which "New" asks: the request without its anchor, not drawn yet. */
+export type DatabaseNewRowMenuTarget = Omit<DatabaseNewRowMenuRequest, 'anchor'>;
+export declare const DatabaseNewRowMenuProvider: import("../../global/di/types.js").ServiceIdentifier<DatabaseNewRowMenuService> & (<U extends DatabaseNewRowMenuService = DatabaseNewRowMenuService>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
+/**
+ * Host seam: the host opens a menu beside every view's "New", or `null` to
+ * say it does not.
+ *
+ * Absent or `null`, "New" is the single button of 0.48 in every view (table,
+ * kanban, gallery, list, calendar) and on the full page: no chevron.
+ *
+ * `di.override`, so a later registration wins and registering twice never
+ * throws at boot.
+ */
+export declare function DatabaseNewRowMenuExtension(service: DatabaseNewRowMenuService | null): ExtensionType;

package/dist/_pkgs/affine-block-database/service/new-row-menu.js

@@ -0,0 +1,21 @@
+import { createIdentifier } from '../../global/di/index.js';
+export const DatabaseNewRowMenuProvider = createIdentifier('LabreDatabaseNewRowMenu');
+/**
+ * Host seam: the host opens a menu beside every view's "New", or `null` to
+ * say it does not.
+ *
+ * Absent or `null`, "New" is the single button of 0.48 in every view (table,
+ * kanban, gallery, list, calendar) and on the full page: no chevron.
+ *
+ * `di.override`, so a later registration wins and registering twice never
+ * throws at boot.
+ */
+export function DatabaseNewRowMenuExtension(service) {
+    return {
+        setup: di => {
+            // `null` rides through on purpose: `getOptional` then reports no menu
+            // and "New" draws no chevron.
+            di.override(DatabaseNewRowMenuProvider, () => service);
+        },
+    };
+}

package/dist/_pkgs/affine-block-database/service/open-row.d.ts

@@ -0,0 +1,77 @@
+import { type DatabaseViewOpenIn } from '../../affine-model/index.js';
+import type { ExtensionType } from '../../store/index.js';
+/**
+ * What a database asks the host to open (ADR 0035 §9a, issue B9).
+ *
+ * - `docId`: the row, which is a document: the seam is only read when the
+ *   source says its rows are documents (`rowsAreDocuments`), and such a
+ *   source's row id IS the document id.
+ * - `mode`: the view's stored `openIn`, `side` when absent (ADR 0035 §8);
+ *   a Ctrl/Cmd click sends `full`.
+ * - `newTab`: `true` for a Ctrl/Cmd click, which also sends `full`.
+ * - `viewId` and `blockId`: the view the row was opened from and the
+ *   `affine:database` block that hosts it, so the host can tell a base's
+ *   own page from an inline view of it.
+ *
+ * Only widens: a new field is optional.
+ */
+export interface DatabaseOpenRowRequest {
+    docId: string;
+    mode: DatabaseViewOpenIn;
+    newTab: boolean;
+    viewId: string;
+    blockId: string;
+}
+/**
+ * The host's way of opening a database row that is a document (ADR 0035
+ * §9a): a side preview, a centred window or the full page, as the view's
+ * "Open pages in" says. The library keeps no "is it open" state and draws
+ * nothing for the row itself: the host routes, the library asks.
+ */
+export interface DatabaseOpenRowService {
+    open(request: DatabaseOpenRowRequest): void;
+}
+export declare const DatabaseOpenRowProvider: import("../../global/di/types.js").ServiceIdentifier<DatabaseOpenRowService> & (<U extends DatabaseOpenRowService = DatabaseOpenRowService>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
+/**
+ * Host seam: the host opens database rows, or `null` to say it does not.
+ *
+ * Absent or `null`, a row opens through the peek view (or the side detail
+ * without one), exactly as in 0.48, and the view's `openIn` has no effect. A
+ * row that is a block (an inline database) always takes that path: there is
+ * no document to open.
+ *
+ * `di.override`, so a later registration wins and registering twice never
+ * throws at boot.
+ */
+export declare function DatabaseOpenRowExtension(service: DatabaseOpenRowService | null): ExtensionType;
+/**
+ * The request for one row-open gesture, or `null` when the host does not
+ * open this row (no opener, or rows that are blocks): the one rule every
+ * view goes through, since every preset opens a row with
+ * `DataViewRootUILogic.openDetailPanel`, which lands in the database block.
+ */
+export declare function databaseOpenRowRequest(input: {
+    hasOpener: boolean;
+    rowsAreDocuments: boolean;
+    rowId: string;
+    viewId: string;
+    blockId: string;
+    /** The view's stored `openIn`, read as stored: unknown values too. */
+    openIn: unknown;
+    newTab?: boolean;
+}): DatabaseOpenRowRequest | null;
+/**
+ * `DatabaseRowOpened` for one row-open gesture (telemetry README,
+ * "Databases"): the mode the row opens in, the host's when it opens it,
+ * `side` for the library's own peek or detail; ids only, never the row.
+ */
+export declare function rowOpenedParams(request: DatabaseOpenRowRequest | null, rowsAreDocuments: boolean, newTab: boolean | undefined): {
+    mode: DatabaseViewOpenIn;
+    newTab: boolean;
+    rowKind: 'document' | 'block';
+};
+/**
+ * A stored `openIn` as this client reads it: absent, or a value appended by a
+ * later client, reads `side` (append-only, ADR 0035 §8).
+ */
+export declare function openInOf(stored: unknown): DatabaseViewOpenIn;

package/dist/_pkgs/affine-block-database/service/open-row.js

@@ -0,0 +1,62 @@
+import { DATABASE_VIEW_OPEN_IN, } from '../../affine-model/index.js';
+import { createIdentifier } from '../../global/di/index.js';
+export const DatabaseOpenRowProvider = createIdentifier('LabreDatabaseOpenRow');
+/**
+ * Host seam: the host opens database rows, or `null` to say it does not.
+ *
+ * Absent or `null`, a row opens through the peek view (or the side detail
+ * without one), exactly as in 0.48, and the view's `openIn` has no effect. A
+ * row that is a block (an inline database) always takes that path: there is
+ * no document to open.
+ *
+ * `di.override`, so a later registration wins and registering twice never
+ * throws at boot.
+ */
+export function DatabaseOpenRowExtension(service) {
+    return {
+        setup: di => {
+            // `null` rides through on purpose: `getOptional` then reports no
+            // opener and the row keeps the library's own detail panel.
+            di.override(DatabaseOpenRowProvider, () => service);
+        },
+    };
+}
+/**
+ * The request for one row-open gesture, or `null` when the host does not
+ * open this row (no opener, or rows that are blocks): the one rule every
+ * view goes through, since every preset opens a row with
+ * `DataViewRootUILogic.openDetailPanel`, which lands in the database block.
+ */
+export function databaseOpenRowRequest(input) {
+    if (!input.hasOpener || !input.rowsAreDocuments)
+        return null;
+    const newTab = input.newTab === true;
+    return {
+        docId: input.rowId,
+        mode: newTab ? 'full' : openInOf(input.openIn),
+        newTab,
+        viewId: input.viewId,
+        blockId: input.blockId,
+    };
+}
+/**
+ * `DatabaseRowOpened` for one row-open gesture (telemetry README,
+ * "Databases"): the mode the row opens in, the host's when it opens it,
+ * `side` for the library's own peek or detail; ids only, never the row.
+ */
+export function rowOpenedParams(request, rowsAreDocuments, newTab) {
+    return {
+        mode: request?.mode ?? 'side',
+        newTab: newTab === true,
+        rowKind: rowsAreDocuments ? 'document' : 'block',
+    };
+}
+/**
+ * A stored `openIn` as this client reads it: absent, or a value appended by a
+ * later client, reads `side` (append-only, ADR 0035 §8).
+ */
+export function openInOf(stored) {
+    return DATABASE_VIEW_OPEN_IN.includes(stored)
+        ? stored
+        : 'side';
+}

package/dist/_pkgs/affine-block-database/service/properties-panel.d.ts

@@ -0,0 +1,23 @@
+import type { DatabaseBlockModel } from '../../affine-model/index.js';
+import { type PropertiesPanelRequest } from '../../affine-shared/services/index.js';
+import type { BlockStdScope } from '../../std/index.js';
+export type DatabasePropertiesPanelRequest = Extract<PropertiesPanelRequest, {
+    scope: 'source';
+}>;
+/**
+ * The properties panel's request for one view of a database (ADR 0035 §9b,
+ * issue B10): the document and the block that host the view, the view, and
+ * the source it reads. A view with no stored `sourceId` reads the block's
+ * implicit source, named here by the block's own id: the host that resolves
+ * sources reads it as "the view's default source", any other host as the
+ * block itself.
+ */
+export declare function databasePropertiesPanelRequest(model: DatabaseBlockModel, viewId: string): DatabasePropertiesPanelRequest;
+/**
+ * Open the host's properties panel on a view of `model`: the call the view
+ * options' "Properties" makes, and the one the view bar and the view settings
+ * of `@labre/affine-database-editor` make. `false` when the host has no panel
+ * (`PropertiesPanelExtension` absent or `null`): the caller then keeps the
+ * data-view's own properties popover.
+ */
+export declare function openDatabasePropertiesPanel(std: BlockStdScope, model: DatabaseBlockModel, viewId: string): boolean;

package/dist/_pkgs/affine-block-database/service/properties-panel.js

@@ -0,0 +1,33 @@
+import { PropertiesPanelProvider, } from '../../affine-shared/services/index.js';
+/**
+ * The properties panel's request for one view of a database (ADR 0035 §9b,
+ * issue B10): the document and the block that host the view, the view, and
+ * the source it reads. A view with no stored `sourceId` reads the block's
+ * implicit source, named here by the block's own id: the host that resolves
+ * sources reads it as "the view's default source", any other host as the
+ * block itself.
+ */
+export function databasePropertiesPanelRequest(model, viewId) {
+    const view = model.props.views.find(v => v.id === viewId);
+    return {
+        scope: 'source',
+        docId: model.store.id,
+        blockId: model.id,
+        sourceId: view?.sourceId ?? model.id,
+        viewId,
+    };
+}
+/**
+ * Open the host's properties panel on a view of `model`: the call the view
+ * options' "Properties" makes, and the one the view bar and the view settings
+ * of `@labre/affine-database-editor` make. `false` when the host has no panel
+ * (`PropertiesPanelExtension` absent or `null`): the caller then keeps the
+ * data-view's own properties popover.
+ */
+export function openDatabasePropertiesPanel(std, model, viewId) {
+    const panel = std.getOptional(PropertiesPanelProvider);
+    if (!panel)
+        return false;
+    panel.open(databasePropertiesPanelRequest(model, viewId));
+    return true;
+}

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

@@ -0,0 +1,10 @@
+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;
+/** 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[];

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

@@ -0,0 +1,35 @@
+/* ── 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.',
+];
+/* ── 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_NEW_RECORD_MORE,
+    DATABASE_SOURCE_MISSING,
+    DATABASE_SOURCE_MISSING_HINT,
+    DATABASE_VALUES_ERROR,
+    DATABASE_VALUES_LOADING,
+];

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

@@ -0,0 +1,10 @@
+import type { ExtensionType } from '../store/index.js';
+/**
+ * Registered by `DatabaseViewExtension` only (`./view.ts`): its presence says
+ * the `database` tooling is on, so a rendered database offers "+ view". The
+ * block reads it when it builds its data source and, absent, sets data-view's
+ * `ViewCreationOffKey` on it (ADR 0035 §5). Its own file so the block reads it
+ * without importing the view extensions, which import the block.
+ */
+export declare const DatabaseViewCreationIdentifier: import("../global/di/types.js").ServiceIdentifier<true> & (<U extends true = true>(variant: import("../global/di/types.js").ServiceVariant) => import("../global/di/types.js").ServiceIdentifier<U>);
+export declare const DatabaseViewCreationExtension: ExtensionType;

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

@@ -0,0 +1,14 @@
+import { createIdentifier } from '../global/di/index.js';
+/**
+ * Registered by `DatabaseViewExtension` only (`./view.ts`): its presence says
+ * the `database` tooling is on, so a rendered database offers "+ view". The
+ * block reads it when it builds its data source and, absent, sets data-view's
+ * `ViewCreationOffKey` on it (ADR 0035 §5). Its own file so the block reads it
+ * without importing the view extensions, which import the block.
+ */
+export const DatabaseViewCreationIdentifier = createIdentifier('AffineDatabaseViewCreation');
+export const DatabaseViewCreationExtension = {
+    setup: di => {
+        di.override(DatabaseViewCreationIdentifier, () => true);
+    },
+};

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

@@ -10,6 +10,37 @@ declare const optionsSchema: z.ZodObject<{
     configure: (args_0: DatabaseBlockModel, args_1: MenuOptions, ...args: unknown[]) => MenuOptions;
 }>;
 export type DatabaseViewExtensionOptions = z.infer<typeof optionsSchema>;
+/**
+ * Database rendering — ALWAYS registered, independent of the `database` and
+ * `data-view` flags (ADR 0009, ADR 0035 §5, issue B4). A document that holds a
+ * database must show it, let its cells be edited and its rows be opened
+ * whatever the flags say: until 0.48 the whole view sat behind `database`, and
+ * `{ database: false }` left every stored database rendered as nothing.
+ *
+ * What lives here is what an EXISTING database needs, the mirror of
+ * `CalloutRenderViewExtension`:
+ * - `effects()` whole: every element it defines draws a stored database (the
+ *   block, its title, the cells, the row detail and its peek);
+ * - the flavour and the block view, the lookup `lit-host` performs; the block
+ *   brings the presets, the cells and the row opening with it;
+ * - the link cell for the title band (ADR 0035 §11): a `link` value already
+ *   stored on a page is drawn with it.
+ */
+export declare class DatabaseRenderViewExtension extends ViewExtensionProvider {
+    name: string;
+    effect(): void;
+    setup(context: ViewExtensionContext): void;
+}
+/**
+ * Database creation tooling — flag-gated (`database`, ADR 0009, ADR 0035 §5):
+ * the slash-menu entries that insert a database, the "+ view" of a rendered
+ * one (`DatabaseViewCreationIdentifier`, `./view-creation.ts`), and the host's additions to
+ * the block's "⋯" menu (`configure`, kept on this class so a host's
+ * `viewManager.configure(DatabaseViewExtension, …)` still compiles and its
+ * entries follow the flag). With the flag off no database and no view can be
+ * made; the stored ones keep rendering through
+ * {@link DatabaseRenderViewExtension}.
+ */
 export declare class DatabaseViewExtension extends ViewExtensionProvider<DatabaseViewExtensionOptions> {
     name: string;
     schema: z.ZodObject<{
@@ -19,7 +50,6 @@ export declare class DatabaseViewExtension extends ViewExtensionProvider<Databas
     }, {
         configure: (args_0: DatabaseBlockModel, args_1: MenuOptions, ...args: unknown[]) => MenuOptions;
     }>;
-    effect(): void;
     setup(context: ViewExtensionContext, options?: DatabaseViewExtensionOptions): void;
 }
 export {};