@formicoidea/labre-core 0.50.0 → 0.51.0

package/dist/_pkgs/affine-inline-link/link-node/propose-views.d.ts

@@ -0,0 +1,22 @@
+import { type BlockStdScope } from '../../std/index.js';
+/**
+ * The URL a paste carries when its plain text is ONE http(s) URL and nothing
+ * else, or `null`. A sentence holding a URL, two URLs, a `mailto:` or any
+ * scheme `isSafeLinkUrl` refuses is not a lone URL: it pastes as text, as it
+ * always did.
+ */
+export declare function lonePastedUrl(text: string | null | undefined): string | null;
+/**
+ * After a lone URL was pasted in a page (labre REQ-IM-1), open the link's own
+ * toolbar on the link the paste wrote, so its view switcher offers "Card view"
+ * and "Embed view" next to the current "Inline view". Nothing is written: the
+ * paste already stored a plain link, which stays the default when the viewer
+ * picks nothing. The conversions are the toolbar's, with their own gates (a
+ * registered bookmark or embed view, an embed provider for the URL).
+ *
+ * Returns whether a toolbar was opened. Nothing opens when the paste did not
+ * leave a link at the caret (a URL the host recognised as one of its own
+ * documents became a reference), on a read-only document, or inside a table
+ * or a database cell, where the toolbar offers no conversion.
+ */
+export declare function proposeLinkViews(std: BlockStdScope, url: string): Promise<boolean>;

package/dist/_pkgs/affine-inline-link/link-node/propose-views.js

@@ -0,0 +1,59 @@
+import { isSafeLinkUrl, normalizeUrl } from '../../affine-shared/utils/index.js';
+import { TextSelection } from '../../std/index.js';
+import { AffineLink } from './affine-link.js';
+/**
+ * The URL a paste carries when its plain text is ONE http(s) URL and nothing
+ * else, or `null`. A sentence holding a URL, two URLs, a `mailto:` or any
+ * scheme `isSafeLinkUrl` refuses is not a lone URL: it pastes as text, as it
+ * always did.
+ */
+export function lonePastedUrl(text) {
+    const candidate = text?.trim();
+    if (!candidate || /\s/.test(candidate))
+        return null;
+    if (!isSafeLinkUrl(candidate))
+        return null;
+    if (!URL.canParse(candidate))
+        return null;
+    const { protocol } = new URL(candidate);
+    return protocol === 'http:' || protocol === 'https:' ? candidate : null;
+}
+/**
+ * After a lone URL was pasted in a page (labre REQ-IM-1), open the link's own
+ * toolbar on the link the paste wrote, so its view switcher offers "Card view"
+ * and "Embed view" next to the current "Inline view". Nothing is written: the
+ * paste already stored a plain link, which stays the default when the viewer
+ * picks nothing. The conversions are the toolbar's, with their own gates (a
+ * registered bookmark or embed view, an embed provider for the URL).
+ *
+ * Returns whether a toolbar was opened. Nothing opens when the paste did not
+ * leave a link at the caret (a URL the host recognised as one of its own
+ * documents became a reference), on a read-only document, or inside a table
+ * or a database cell, where the toolbar offers no conversion.
+ */
+export async function proposeLinkViews(std, url) {
+    if (std.store.readonly)
+        return false;
+    await std.host.updateComplete;
+    const caret = std.selection.find(TextSelection);
+    if (!caret)
+        return false;
+    const block = std.view.getBlock(caret.from.blockId);
+    if (!block)
+        return false;
+    await block.updateComplete;
+    if (block.closest('affine-database, affine-table'))
+        return false;
+    const href = normalizeUrl(url);
+    const links = Array.from(block.querySelectorAll('affine-link')).filter((node) => node instanceof AffineLink && node.link === href);
+    // The caret ends the pasted run; an equal link written earlier in the same
+    // paragraph must not be the one the toolbar points at.
+    const pasted = links.find(link => {
+        const range = link.selfInlineRange;
+        return !!range && range.index + range.length === caret.from.index;
+    }) ?? links.at(-1);
+    if (!pasted)
+        return false;
+    pasted.proposeViews();
+    return true;
+}

package/dist/_pkgs/affine-model/blocks/image/image-crop.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The stored crop of an image block (ADR 0037): a view on the source, never
+ * new bytes. The rectangle is normalised to the source image (0..1 on each
+ * axis), so it needs no pixel size and survives any resize.
+ *
+ * Append-only: a mask token, once shipped, is never renamed or removed. A
+ * token this build does not know reads as `free`.
+ */
+export declare const IMAGE_CROP_MASKS: readonly ["free", "16:9", "4:3", "1:1"];
+export type ImageCropMask = (typeof IMAGE_CROP_MASKS)[number];
+export interface ImageCrop {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /** The preset that drew the rectangle; absent means free. */
+    mask?: ImageCropMask;
+}
+/**
+ * Below this a side is a sliver nobody can grab again; the crop tool never
+ * writes one, and a stored one is treated as damaged.
+ */
+export declare const IMAGE_CROP_MIN_SIDE = 0.02;
+/**
+ * The crop to paint, or `undefined` for the whole image.
+ *
+ * Every reader goes through here: the value may come from a peer, an import
+ * or a damaged document, and a crop that cannot be honoured shows the whole
+ * picture rather than an empty box or an error. A rectangle covering the
+ * whole image is "no crop" too, so nothing downstream has to tell them apart.
+ */
+export declare function readImageCrop(value: unknown): ImageCrop | undefined;
+export declare function isWholeImage(rect: Pick<ImageCrop, 'x' | 'y' | 'w' | 'h'>): boolean;
+/**
+ * The part of the source, in source pixels, a crop keeps — what a raster
+ * export hands to `drawImage(image, sx, sy, sw, sh, …)`.
+ *
+ * `null` when there is nothing to cut: no crop, or a source with no pixel
+ * size (an SVG without intrinsic dimensions loads as 0×0). The caller then
+ * draws the whole image into the box, as before ADR 0037; a source
+ * rectangle of 0×0 would draw nothing at all.
+ */
+export declare function imageCropSourceRect(crop: ImageCrop | undefined, naturalWidth: number, naturalHeight: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+} | null;

package/dist/_pkgs/affine-model/blocks/image/image-crop.js

@@ -0,0 +1,78 @@
+/**
+ * The stored crop of an image block (ADR 0037): a view on the source, never
+ * new bytes. The rectangle is normalised to the source image (0..1 on each
+ * axis), so it needs no pixel size and survives any resize.
+ *
+ * Append-only: a mask token, once shipped, is never renamed or removed. A
+ * token this build does not know reads as `free`.
+ */
+export const IMAGE_CROP_MASKS = ['free', '16:9', '4:3', '1:1'];
+/**
+ * Below this a side is a sliver nobody can grab again; the crop tool never
+ * writes one, and a stored one is treated as damaged.
+ */
+export const IMAGE_CROP_MIN_SIDE = 0.02;
+const EPSILON = 1e-6;
+const isFraction = (value) => typeof value === 'number' && Number.isFinite(value);
+/**
+ * The crop to paint, or `undefined` for the whole image.
+ *
+ * Every reader goes through here: the value may come from a peer, an import
+ * or a damaged document, and a crop that cannot be honoured shows the whole
+ * picture rather than an empty box or an error. A rectangle covering the
+ * whole image is "no crop" too, so nothing downstream has to tell them apart.
+ */
+export function readImageCrop(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const { x, y, w, h, mask } = value;
+    if (!isFraction(x) || !isFraction(y) || !isFraction(w) || !isFraction(h)) {
+        return undefined;
+    }
+    if (x < -EPSILON || y < -EPSILON)
+        return undefined;
+    if (w < IMAGE_CROP_MIN_SIDE - EPSILON || h < IMAGE_CROP_MIN_SIDE - EPSILON) {
+        return undefined;
+    }
+    if (x + w > 1 + EPSILON || y + h > 1 + EPSILON)
+        return undefined;
+    if (isWholeImage({ x, y, w, h }))
+        return undefined;
+    const crop = {
+        x: Math.max(0, x),
+        y: Math.max(0, y),
+        w: Math.min(w, 1 - Math.max(0, x)),
+        h: Math.min(h, 1 - Math.max(0, y)),
+    };
+    if (typeof mask === 'string' &&
+        mask !== 'free' &&
+        IMAGE_CROP_MASKS.includes(mask)) {
+        crop.mask = mask;
+    }
+    return crop;
+}
+export function isWholeImage(rect) {
+    return (Math.abs(rect.x) < EPSILON &&
+        Math.abs(rect.y) < EPSILON &&
+        Math.abs(rect.w - 1) < EPSILON &&
+        Math.abs(rect.h - 1) < EPSILON);
+}
+/**
+ * The part of the source, in source pixels, a crop keeps — what a raster
+ * export hands to `drawImage(image, sx, sy, sw, sh, …)`.
+ *
+ * `null` when there is nothing to cut: no crop, or a source with no pixel
+ * size (an SVG without intrinsic dimensions loads as 0×0). The caller then
+ * draws the whole image into the box, as before ADR 0037; a source
+ * rectangle of 0×0 would draw nothing at all.
+ */
+export function imageCropSourceRect(crop, naturalWidth, naturalHeight) {
+    if (!crop || naturalWidth <= 0 || naturalHeight <= 0)
+        return null;
+    return {
+        x: crop.x * naturalWidth,
+        y: crop.y * naturalHeight,
+        w: crop.w * naturalWidth,
+        h: crop.h * naturalHeight,
+    };
+}

package/dist/_pkgs/affine-model/blocks/image/image-model.d.ts

@@ -1,5 +1,6 @@
 import type { GfxCommonBlockProps, GfxElementGeometry } from '../../../std/gfx/index.js';
 import type { BlockMeta } from '../../utils/types.js';
+import type { ImageCrop } from './image-crop.js';
 import { ImageBlockTransformer } from './image-transformer.js';
 export type ImageBlockProps = {
     caption?: string;
@@ -9,6 +10,11 @@ export type ImageBlockProps = {
     rotate: number;
     size?: number;
     comments?: Record<string, boolean>;
+    /**
+     * The part of the source this block shows (ADR 0037). Absent means the
+     * whole image; read it through `readImageCrop`, never directly.
+     */
+    crop?: ImageCrop;
 } & Omit<GfxCommonBlockProps, 'scale'> & BlockMeta;
 export declare const ImageBlockSchema: {
     version: number;

package/dist/_pkgs/affine-model/blocks/image/image-model.js

@@ -14,6 +14,8 @@ const defaultImageProps = {
     rotate: 0,
     size: -1,
     comments: undefined,
+    // `undefined`, so it is never written on load (ADR 0037).
+    crop: undefined,
     'meta:createdAt': undefined,
     'meta:createdBy': undefined,
     'meta:updatedAt': undefined,

package/dist/_pkgs/affine-model/blocks/image/index.d.ts

@@ -1,2 +1,3 @@
+export * from './image-crop.js';
 export * from './image-model.js';
 export * from './image-transformer.js';

package/dist/_pkgs/affine-model/blocks/image/index.js

@@ -1,2 +1,3 @@
+export * from './image-crop.js';
 export * from './image-model.js';
 export * from './image-transformer.js';

package/dist/_pkgs/affine-model/consts/shape.d.ts

@@ -21,3 +21,5 @@ export declare enum ShapeStyle {
     General = "General",
     Scribbled = "Scribbled"
 }
+export declare const SHAPE_TEXT_PADDING = 20;
+export declare const SHAPE_TEXT_VERTICAL_PADDING = 10;

package/dist/_pkgs/affine-model/consts/shape.js

@@ -39,3 +39,8 @@ export var ShapeStyle;
     ShapeStyle["General"] = "General";
     ShapeStyle["Scribbled"] = "Scribbled";
 })(ShapeStyle || (ShapeStyle = {}));
+// Moved here from `elements/shape/shape.ts`, unchanged, so the model's
+// headless entry exports them without the element class (ADR 0012, P3 as
+// amended 2026-10-14).
+export const SHAPE_TEXT_PADDING = 20;
+export const SHAPE_TEXT_VERTICAL_PADDING = 10;

package/dist/_pkgs/affine-model/elements/bpmn/consts.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Constants moved out of the element-class files of this folder, unchanged, so
+ * the model's headless entry (`@labre/affine-model/headless`) exports them
+ * without `@labre/std/gfx` behind them (ADR 0012, P3 as amended 2026-10-14).
+ * The folder index re-exports this file.
+ */
+/**
+ * Width of the participant band — the left margin strip the pool name is
+ * written up, in model units.
+ *
+ * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-bpmn`
+ * rather than the other way round. The pool's own hit test needs it (a pool is
+ * clickable by its title bands as well as its border, the bpmn.io convention),
+ * and `affine-model` cannot reach into `affine-block-surface` where the
+ * declaration is resolved. One number, owned by the layer that both the
+ * declaration and the hit test can read.
+ */
+export declare const POOL_BAND_WIDTH = 28;
+/**
+ * Width of a lane's own title band — the strip immediately inside the
+ * participant band, with the lane name turned on its side.
+ *
+ * Four units narrower than {@link POOL_BAND_WIDTH}, and for the same reason the
+ * lane font is two points smaller: the two strips sit side by side, so the
+ * subordinate one has to say so. Identical widths read as a single 56-unit
+ * gutter rather than as a participant containing lanes, which is exactly the
+ * relationship the picture has to carry.
+ *
+ * NO fill, divider only — what bpmn.io, Camunda and Visio all draw.
+ */
+export declare const POOL_LANE_BAND_WIDTH = 24;

package/dist/_pkgs/affine-model/elements/bpmn/consts.js

@@ -0,0 +1,31 @@
+/**
+ * Constants moved out of the element-class files of this folder, unchanged, so
+ * the model's headless entry (`@labre/affine-model/headless`) exports them
+ * without `@labre/std/gfx` behind them (ADR 0012, P3 as amended 2026-10-14).
+ * The folder index re-exports this file.
+ */
+/**
+ * Width of the participant band — the left margin strip the pool name is
+ * written up, in model units.
+ *
+ * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-bpmn`
+ * rather than the other way round. The pool's own hit test needs it (a pool is
+ * clickable by its title bands as well as its border, the bpmn.io convention),
+ * and `affine-model` cannot reach into `affine-block-surface` where the
+ * declaration is resolved. One number, owned by the layer that both the
+ * declaration and the hit test can read.
+ */
+export const POOL_BAND_WIDTH = 28;
+/**
+ * Width of a lane's own title band — the strip immediately inside the
+ * participant band, with the lane name turned on its side.
+ *
+ * Four units narrower than {@link POOL_BAND_WIDTH}, and for the same reason the
+ * lane font is two points smaller: the two strips sit side by side, so the
+ * subordinate one has to say so. Identical widths read as a single 56-unit
+ * gutter rather than as a participant containing lanes, which is exactly the
+ * relationship the picture has to carry.
+ *
+ * NO fill, divider only — what bpmn.io, Camunda and Visio all draw.
+ */
+export const POOL_LANE_BAND_WIDTH = 24;

package/dist/_pkgs/affine-model/elements/bpmn/index.d.ts

@@ -1,2 +1,3 @@
 export * from './node.js';
 export * from './pool.js';
+export * from './consts.js';

package/dist/_pkgs/affine-model/elements/bpmn/index.js

@@ -1,2 +1,3 @@
 export * from './node.js';
 export * from './pool.js';
+export * from './consts.js';

package/dist/_pkgs/affine-model/elements/bpmn/pool.d.ts

@@ -2,31 +2,6 @@ import type { SerializedXYWH } from '../../../global/gfx/index.js';
 import type { PointTestOptions } from '../../../std/gfx/index.js';
 import type { FrameworkBackgroundProps } from '../framework-background/index.js';
 import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
-/**
- * Width of the participant band — the left margin strip the pool name is
- * written up, in model units.
- *
- * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-bpmn`
- * rather than the other way round. The pool's own hit test needs it (a pool is
- * clickable by its title bands as well as its border, the bpmn.io convention),
- * and `affine-model` cannot reach into `affine-block-surface` where the
- * declaration is resolved. One number, owned by the layer that both the
- * declaration and the hit test can read.
- */
-export declare const POOL_BAND_WIDTH = 28;
-/**
- * Width of a lane's own title band — the strip immediately inside the
- * participant band, with the lane name turned on its side.
- *
- * Four units narrower than {@link POOL_BAND_WIDTH}, and for the same reason the
- * lane font is two points smaller: the two strips sit side by side, so the
- * subordinate one has to say so. Identical widths read as a single 56-unit
- * gutter rather than as a participant containing lanes, which is exactly the
- * relationship the picture has to carry.
- *
- * NO fill, divider only — what bpmn.io, Camunda and Visio all draw.
- */
-export declare const POOL_LANE_BAND_WIDTH = 24;
 /**
  * One LANE (couloir) of a pool: a horizontal band the participant's own work is
  * divided into — "Sales", "Back office", "Automated".

package/dist/_pkgs/affine-model/elements/bpmn/pool.js

@@ -35,31 +35,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 import { rotatePoint } from '../../../global/gfx/index.js';
 import { field } from '../../../std/gfx/index.js';
 import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
-/**
- * Width of the participant band — the left margin strip the pool name is
- * written up, in model units.
- *
- * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-bpmn`
- * rather than the other way round. The pool's own hit test needs it (a pool is
- * clickable by its title bands as well as its border, the bpmn.io convention),
- * and `affine-model` cannot reach into `affine-block-surface` where the
- * declaration is resolved. One number, owned by the layer that both the
- * declaration and the hit test can read.
- */
-export const POOL_BAND_WIDTH = 28;
-/**
- * Width of a lane's own title band — the strip immediately inside the
- * participant band, with the lane name turned on its side.
- *
- * Four units narrower than {@link POOL_BAND_WIDTH}, and for the same reason the
- * lane font is two points smaller: the two strips sit side by side, so the
- * subordinate one has to say so. Identical widths read as a single 56-unit
- * gutter rather than as a participant containing lanes, which is exactly the
- * relationship the picture has to carry.
- *
- * NO fill, divider only — what bpmn.io, Camunda and Visio all draw.
- */
-export const POOL_LANE_BAND_WIDTH = 24;
+import { POOL_BAND_WIDTH, POOL_LANE_BAND_WIDTH } from './consts.js';
 /**
  * A BPMN "pool": a participant container drawn as a rounded-rect frame with a
  * vertical name band on the left. It is a framework background like every other

package/dist/_pkgs/affine-model/elements/shape/shape.d.ts

@@ -47,8 +47,6 @@ export type ShapeProps = BaseElementProps & {
     textFitMode?: TextFitMode;
     maxWidth?: false | number;
 } & Partial<TextStyleProps>;
-export declare const SHAPE_TEXT_PADDING = 20;
-export declare const SHAPE_TEXT_VERTICAL_PADDING = 10;
 export declare class ShapeElementModel extends GfxPrimitiveElementModel<ShapeProps> {
     /**
      * The bound of the text content.

package/dist/_pkgs/affine-model/elements/shape/shape.js

@@ -36,10 +36,9 @@ import { Bound, getBoundWithRotation } from '../../../global/gfx/index.js';
 import { field, GfxLocalElementModel, GfxPrimitiveElementModel, local, prop, } from '../../../std/gfx/index.js';
 import * as Y from 'yjs';
 import { DEFAULT_ROUGHNESS, FontFamily, FontStyle, FontWeight, ShapeStyle, ShapeTextFontSize, ShapeType, StrokeStyle, TextAlign, TextFitMode, TextResizing, TextVerticalAlign, } from '../../consts/index.js';
+import { SHAPE_TEXT_PADDING, SHAPE_TEXT_VERTICAL_PADDING, } from '../../consts/shape.js';
 import { DefaultTheme } from '../../themes/index.js';
 import { shapeMethods } from './api/index.js';
-export const SHAPE_TEXT_PADDING = 20;
-export const SHAPE_TEXT_VERTICAL_PADDING = 10;
 let ShapeElementModel = (() => {
     let _classSuper = GfxPrimitiveElementModel;
     let _color_decorators;

package/dist/_pkgs/affine-model/elements/uml/consts.d.ts

@@ -0,0 +1,133 @@
+/**
+ * The UML element constants an interchange reader needs WITHOUT the element
+ * classes: moved out of `diagram.ts`, `fragment.ts`, `partition.ts` and `region.ts`
+ * unchanged, so the
+ * model's headless entry (`@labre/affine-model/headless`) can export them with
+ * no `@labre/std/gfx` behind it (ADR 0012, P3 as amended 2026-10-14). The
+ * package index re-exports this file, so nothing an importer reads moved.
+ */
+/**
+ * Height of the diagram frame's heading band — the strip across the top of the
+ * frame the `<kind> <name>` tag is written in, in model units.
+ *
+ * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-uml`
+ * rather than the other way round, for the reason `C4_BOARD_TITLE_BAND_HEIGHT`
+ * is: the frame's own hit test needs it (a diagram is clickable by its heading
+ * band as well as by its border), and `affine-model` cannot reach into
+ * `affine-block-surface` where the declaration is resolved. One number, owned
+ * by the layer that both the declaration and the hit test can read.
+ *
+ * It is the frame's TOP MARGIN — the inset the drawing gives up so the heading
+ * has somewhere to be written — so the strip that is painted, the strip that is
+ * picked and the strip that opens the rename are one number rather than three.
+ *
+ * 44 is the height of the cut-corner tag UML 2.5.1 Annex A draws the heading
+ * in: a 20-unit label with the rest as breathing room above and below.
+ * Changing it moves the heading, so it is a visual decision and not a hit-test
+ * one.
+ */
+export declare const UML_FRAME_BAND_HEIGHT = 44;
+/**
+ * Which kind of UML diagram this frame draws — the DECLARED fact, as opposed to
+ * the name, which is free text and says whatever its author wants it to.
+ *
+ * ## Where the values come from
+ *
+ * UML 2.5.1 Annex A gives the normative frame kind names, each with the
+ * abbreviation that may be written in its place:
+ *
+ *  - `activity` / `act`;
+ *  - `class` — the one kind Annex A gives NO abbreviation for, so the word
+ *    itself is the tag;
+ *  - `component` / `cmp`;
+ *  - `deployment` / `dep`;
+ *  - `interaction` / `sd`;
+ *  - `package` / `pkg`;
+ *  - `state machine` / `stm`;
+ *  - `use case` / `uc`.
+ *
+ * `obj` is NOT in that list. Annex A has no frame kind for the object diagram —
+ * the standard treats it as a class diagram showing instances — but every tool
+ * that draws one tags it `obj`, and an architect reading the sheet expects to
+ * see it. So `obj` is kept as a TOOL CONVENTION, recorded as such here so that
+ * nobody later "fixes" it against the spec without knowing it was a choice.
+ *
+ * ## Widening this union is additive
+ *
+ * Phase 1 shipped the first four kinds below; phase 2 APPENDED `cmp` and `dep`,
+ * the two structural frames of §11.6.4 and §19.2.4, then `act` and `stm`, the
+ * two behaviour frames of §15.2.4 and §14.2.4; phase 3 appends `sd`. Each
+ * arrives as a new VALUE of the existing `kind`
+ * string field — no new field, no schema change, no migration and no backfill.
+ * The same promise `C4NodeKind` and `BpmnNodeKind` already make.
+ *
+ * Appended, never reordered: the union is read as a set of strings by every
+ * consumer, and a document only ever stores one of them, so the ORDER below is a
+ * reading aid. Keeping it chronological is what lets a reviewer see at a glance
+ * which build a value arrived in.
+ *
+ * A value a client has never seen reads back as the string it is, and
+ * {@link UmlDiagramElementModel.heading} writes it verbatim, so a document
+ * created by a newer build still shows its own heading on an older one.
+ */
+export type UmlDiagramKind = 'class' | 'pkg' | 'obj' | 'uc' | 'cmp' | 'dep' | 'act' | 'stm' | 'sd';
+/**
+ * The word written in the heading tag, per kind.
+ *
+ * A table rather than the raw value so that a kind whose stored discriminant
+ * and whose printed tag ever diverge has one place to say so. Today they are
+ * the same four strings, and that is worth stating rather than assuming.
+ *
+ * `Partial` on purpose: a frame read off a document carries whatever string was
+ * written there, including a kind from a later phase this build has never heard
+ * of. Typing the lookup as total would make {@link
+ * UmlDiagramElementModel.heading}'s `?? this.kind` fallback look like dead
+ * defensive code, when it is the whole of the append-only promise.
+ */
+export declare const UML_DIAGRAM_KIND_TAG: Partial<Record<UmlDiagramKind, string>>;
+/**
+ * Height of a combined fragment's OPERATOR BAND — the strip across its top the
+ * pentagon tag is drawn in, in model units.
+ *
+ * Owned by the model for the reason {@link UML_FRAME_BAND_HEIGHT} is: the
+ * fragment's own hit test reads it (a fragment is clickable by its tag strip as
+ * well as by its border), and `affine-model` cannot reach into
+ * `affine-block-surface` where the declaration is resolved.
+ *
+ * The diagram frame's own 44, and deliberately: §17.6.4 draws the operator in
+ * the very same cut-corner pentagon Annex A draws a frame heading in — it IS a
+ * frame, nested in another one — and two numbers for one piece of furniture
+ * would drift.
+ */
+export declare const UML_FRAGMENT_BAND = 44;
+/**
+ * Height of a partition's NAME BAND — the strip its name is written in, in
+ * model units.
+ *
+ * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-uml`, for
+ * the reason {@link UML_FRAME_BAND_HEIGHT} is: the partition's own hit test
+ * reads it (a swimlane is clickable by its header as well as by its border),
+ * and `affine-model` cannot reach into `affine-block-surface` where the
+ * declaration is resolved. One number, owned by the layer that both the
+ * declaration and the hit test can read.
+ *
+ * It is the band's THICKNESS whichever edge the band is on — the top for a
+ * vertical lane, the left for a horizontal one — because §15.6.4 draws one
+ * header strip and turns it with the lane rather than resizing it.
+ *
+ * 36 against the diagram frame's 44: a partition header is a name and not a
+ * `<kind> <name>` heading, and it is written inside a lane that already sits on
+ * a sheet, so it reads as a subdivision rather than as a second sheet.
+ */
+export declare const UML_PARTITION_BAND = 36;
+/**
+ * Height of a region's NAME BAND — the strip its name is written in, in model
+ * units.
+ *
+ * Owned by the model for the reason {@link UML_PARTITION_BAND} is: the region's
+ * own hit test reads it, and `affine-model` cannot reach into the package where
+ * the declaration is resolved. The same 36 the partition uses, and deliberately
+ * so — the two are the same piece of furniture, a name written in a strip along
+ * the top of a transparent frame, and two numbers would drift.
+ */
+export declare const UML_REGION_BAND = 36;