@formicoidea/labre-core 0.32.0 → 0.34.1

package/dist/_pkgs/affine-inline-link/link-node/configs/toolbar.js

@@ -1,5 +1,5 @@
 import { toast } from '../../../affine-components/toast/index.js';
-import { ActionPlacement, EmbedIframeService, EmbedOptionProvider, } from '../../../affine-shared/services/index.js';
+import { ActionPlacement, EmbedIframeService, EmbedOptionProvider, TOOLBAR_CARD_VIEW, TOOLBAR_DELETE, TOOLBAR_EMBED_VIEW, TOOLBAR_INLINE_VIEW, toolbarActionLabel, } from '../../../affine-shared/services/index.js';
 import { CopyIcon, DeleteIcon, EditIcon, UnlinkIcon, } from '@blocksuite/icons/lit';
 import { BlockSelection } from '../../../std/index.js';
 import { signal } from '@preact/signals-core';
@@ -79,12 +79,12 @@ export const builtinInlineLinkToolbarConfig = {
             actions: [
                 {
                     id: 'inline',
-                    label: 'Inline view',
+                    labelWording: TOOLBAR_INLINE_VIEW,
                     disabled: true,
                 },
                 {
                     id: 'card',
-                    label: 'Card view',
+                    labelWording: TOOLBAR_CARD_VIEW,
                     run(ctx) {
                         const target = ctx.message$.peek()?.element;
                         if (!(target instanceof AffineLink))
@@ -133,7 +133,7 @@ export const builtinInlineLinkToolbarConfig = {
                 },
                 {
                     id: 'embed',
-                    label: 'Embed view',
+                    labelWording: TOOLBAR_EMBED_VIEW,
                     when(ctx) {
                         const target = ctx.message$.peek()?.element;
                         if (!(target instanceof AffineLink))
@@ -210,7 +210,7 @@ export const builtinInlineLinkToolbarConfig = {
                 if (!(target instanceof AffineLink))
                     return null;
                 const actions = this.actions.map(action => ({ ...action }));
-                const viewType$ = signal(actions[0].label);
+                const viewType$ = signal(toolbarActionLabel(ctx.std, actions[0]));
                 const onToggle = (e) => {
                     const opened = e.detail;
                     if (!opened)
@@ -280,7 +280,7 @@ export const builtinInlineLinkToolbarConfig = {
         {
             placement: ActionPlacement.More,
             id: 'c.delete',
-            label: 'Delete',
+            labelWording: TOOLBAR_DELETE,
             icon: DeleteIcon(),
             variant: 'destructive',
             run(ctx) {

package/dist/_pkgs/affine-inline-preset/command/format-block.js

@@ -1,5 +1,5 @@
 import { getSelectedBlocksCommand } from '../../affine-shared/commands/index.js';
-import { INLINE_ROOT_ATTR, } from '../../std/inline/index.js';
+import { INLINE_ROOT_ATTR } from '../../std/inline/index.js';
 import { FORMAT_BLOCK_SUPPORT_FLAVOURS } from './consts.js';
 // for block selection
 export const formatBlockCommand = (ctx, next) => {

package/dist/_pkgs/affine-inline-preset/command/format-native.js

@@ -1,5 +1,5 @@
-import { BLOCK_ID_ATTR, } from '../../std/index.js';
-import { INLINE_ROOT_ATTR, } from '../../std/inline/index.js';
+import { BLOCK_ID_ATTR } from '../../std/index.js';
+import { INLINE_ROOT_ATTR } from '../../std/inline/index.js';
 import { FORMAT_NATIVE_SUPPORT_FLAVOURS } from './consts.js';
 // for native range
 export const formatNativeCommand = (ctx, next) => {

package/dist/_pkgs/affine-inline-preset/command/format-text.js

@@ -1,6 +1,6 @@
 import { clearMarksOnDiscontinuousInput } from '../../affine-rich-text/index.js';
 import { getSelectedBlocksCommand } from '../../affine-shared/commands/index.js';
-import { INLINE_ROOT_ATTR, } from '../../std/inline/index.js';
+import { INLINE_ROOT_ATTR } from '../../std/inline/index.js';
 import { FORMAT_TEXT_SUPPORT_FLAVOURS } from './consts.js';
 // for text selection
 export const formatTextCommand = (ctx, next) => {

package/dist/_pkgs/affine-inline-preset/inline-spec.js

@@ -1,4 +1,4 @@
-import { InlineSpecExtension, } from '../std/inline/index.js';
+import { InlineSpecExtension } from '../std/inline/index.js';
 import { html } from 'lit';
 import { z } from 'zod';
 export const BoldInlineSpecExtension = InlineSpecExtension({

package/dist/_pkgs/affine-inline-reference/reference-node/configs/toolbar.d.ts

@@ -7,17 +7,17 @@ export declare const builtinInlineReferenceToolbarConfig: {
         id: string;
         actions: ({
             id: string;
-            label: string;
+            labelWording: import("../../../affine-shared/services/index.js").ChromeWording;
             disabled: true;
             run?: undefined;
         } | {
             id: string;
-            label: string;
+            labelWording: import("../../../affine-shared/services/index.js").ChromeWording;
             run(ctx: import("../../../affine-shared/services/index.js").ToolbarContext): void;
             disabled?: undefined;
         } | {
             id: string;
-            label: string;
+            labelWording: import("../../../affine-shared/services/index.js").ChromeWording;
             disabled(ctx: import("../../../affine-shared/services/index.js").ToolbarContext): boolean;
             run(ctx: import("../../../affine-shared/services/index.js").ToolbarContext): void;
         })[];
@@ -26,7 +26,7 @@ export declare const builtinInlineReferenceToolbarConfig: {
     }, {
         readonly placement: ActionPlacement.More;
         readonly id: "c.delete";
-        readonly label: "Delete";
+        readonly labelWording: import("../../../affine-shared/services/index.js").ChromeWording;
         readonly icon: import("lit-html").TemplateResult<1>;
         readonly variant: "destructive";
         readonly run: (ctx: import("../../../affine-shared/services/index.js").ToolbarContext) => void;

package/dist/_pkgs/affine-inline-reference/reference-node/configs/toolbar.js

@@ -1,5 +1,5 @@
 import { notifyLinkedDocSwitchedToEmbed } from '../../../affine-components/notification/index.js';
-import { ActionPlacement, DocDisplayMetaProvider, } from '../../../affine-shared/services/index.js';
+import { ActionPlacement, DocDisplayMetaProvider, TOOLBAR_CARD_VIEW, TOOLBAR_DELETE, TOOLBAR_EMBED_VIEW, TOOLBAR_INLINE_VIEW, toolbarActionLabel, } from '../../../affine-shared/services/index.js';
 import { cloneReferenceInfoWithoutAliases, isInsideBlockByFlavour, } from '../../../affine-shared/utils/index.js';
 import { DeleteIcon } from '@blocksuite/icons/lit';
 import { BlockSelection } from '../../../std/index.js';
@@ -38,12 +38,12 @@ export const builtinInlineReferenceToolbarConfig = {
             actions: [
                 {
                     id: 'inline',
-                    label: 'Inline view',
+                    labelWording: TOOLBAR_INLINE_VIEW,
                     disabled: true,
                 },
                 {
                     id: 'card',
-                    label: 'Card view',
+                    labelWording: TOOLBAR_CARD_VIEW,
                     run(ctx) {
                         const target = ctx.message$.peek()?.element;
                         if (!(target instanceof AffineReference))
@@ -78,7 +78,7 @@ export const builtinInlineReferenceToolbarConfig = {
                 },
                 {
                     id: 'embed',
-                    label: 'Embed view',
+                    labelWording: TOOLBAR_EMBED_VIEW,
                     disabled(ctx) {
                         const target = ctx.message$.peek()?.element;
                         if (!(target instanceof AffineReference))
@@ -140,7 +140,7 @@ export const builtinInlineReferenceToolbarConfig = {
                 if (!(target instanceof AffineReference))
                     return null;
                 const actions = this.actions.map(action => ({ ...action }));
-                const viewType$ = signal(actions[0].label);
+                const viewType$ = signal(toolbarActionLabel(ctx.std, actions[0]));
                 const onToggle = (e) => {
                     const opened = e.detail;
                     if (!opened)
@@ -174,7 +174,7 @@ export const builtinInlineReferenceToolbarConfig = {
         {
             placement: ActionPlacement.More,
             id: 'c.delete',
-            label: 'Delete',
+            labelWording: TOOLBAR_DELETE,
             icon: DeleteIcon(),
             variant: 'destructive',
             run(ctx) {

package/dist/_pkgs/affine-inline-reference/reference-node/reference-node.js

@@ -34,7 +34,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import { whenHover } from '../../affine-components/hover/index.js';
 import { Peekable } from '../../affine-components/peek/index.js';
-import { DEFAULT_DOC_NAME, REFERENCE_NODE, } from '../../affine-shared/consts/index.js';
+import { DEFAULT_DOC_NAME, REFERENCE_NODE } from '../../affine-shared/consts/index.js';
 import { DocDisplayMetaProvider, ToolbarRegistryIdentifier, } from '../../affine-shared/services/index.js';
 import { affineTextStyles } from '../../affine-shared/styles/index.js';
 import { cloneReferenceInfo, referenceToNode, } from '../../affine-shared/utils/index.js';

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

@@ -1,17 +1,50 @@
 import { ShapeElementModel } from '../shape/index.js';
 /**
- * The BPMN flow-object nodes shipped in v1. Each maps onto a native shape:
- *  - `startEvent` / `endEvent` → an ellipse (thin green / thick red ring)
- *  - `task`                    → a rounded rectangle with editable inner text
- *  - `gatewayExclusive`        → a diamond decorated with an X glyph
+ * The BPMN artefacts the pack draws — the **descriptive conformance subclass**
+ * of BPMN 2.0. Each maps onto a native shape, decorated by a glyph where the
+ * notation asks for one:
+ *
+ *  - events (ellipse)   — `startEvent` / `endEvent` plain, plus the message and
+ *    timer starts and the message and terminate ends;
+ *  - activities (rect)  — `task` plain, plus the user and service tasks, the
+ *    collapsed sub-process and the call activity;
+ *  - gateways (diamond) — `gatewayExclusive` (X) and `gatewayParallel` (+);
+ *  - data & artifacts   — `dataObject`, `dataStore` and `textAnnotation`, whose
+ *    silhouettes (folded page, cylinder, open bracket) are drawn by the glyph
+ *    over a native rect with its own stroke and fill turned off;
+ *  - `group`            — a dashed rounded rectangle drawn AROUND things.
+ *
+ * `group` is the odd one and deliberately so. Every other kind is a node the
+ * process is made of; a group is a lasso somebody drew round part of it. The
+ * spec (BPMN 2.0.2 §10.4) exempts it from every connection and containment
+ * constraint there is — it cannot be attached to a sequence or message flow, it
+ * is not bounded by the pool or lane it overlaps, and it may straddle several
+ * pools at once. Nothing here has to enforce that, because a group is unfilled:
+ * it is hit near its border and on its label, so it never steals a click from
+ * what it encloses, and what it encloses never becomes its content.
+ *
+ * ## Compatibility
+ *
+ * This union is only ever WIDENED, and it is widened with new VALUES of the
+ * existing `kind` string field — no new field, no schema change, no migration
+ * and no backfill. The precedent is `wardley`'s (`gfx/wardley/src/roles.ts`):
+ * a process drawn before today carries one of the four original values, loads
+ * unchanged and paints exactly as it always did.
+ *
+ * The expanded (drilled-in) sub-process is deliberately NOT here: `subProcess`
+ * is the COLLAPSED representation only — a task-sized rectangle with the `+`
+ * marker. An expanded sub-process is a container with its own flow inside it,
+ * which is a containment model this pack does not have yet.
  */
-export type BpmnNodeKind = 'startEvent' | 'endEvent' | 'task' | 'gatewayExclusive';
+export type BpmnNodeKind = 'startEvent' | 'startEventMessage' | 'startEventTimer' | 'endEvent' | 'endEventMessage' | 'endEventTerminate' | 'task' | 'taskUser' | 'taskService' | 'subProcess' | 'callActivity' | 'gatewayExclusive' | 'gatewayParallel' | 'dataObject' | 'dataStore' | 'textAnnotation' | 'group';
 /**
  * A BPMN flow-object node. Extends {@link ShapeElementModel} (a native shape)
  * so it inherits ALL shape behaviour — editable stroke width / colors, inner
  * text, native resize, the shape context toolbar — for free. `kind`
- * discriminates the four basics; only `gatewayExclusive` is decorated with a
- * glyph (the X) by the renderer (the others are plain native shapes).
+ * discriminates the artefacts and drives the RENDERING alone; what a node
+ * MEANS is the `role` stamped on it at creation (`gfx/bpmn/src/roles.ts`).
+ * The plain start event, end event and task are undecorated native shapes;
+ * every other kind is decorated with a glyph by the renderer.
  *
  * Mirrors {@link EdgyNodeElementModel}.
  */

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

@@ -38,8 +38,10 @@ import { ShapeElementModel } from '../shape/index.js';
  * A BPMN flow-object node. Extends {@link ShapeElementModel} (a native shape)
  * so it inherits ALL shape behaviour — editable stroke width / colors, inner
  * text, native resize, the shape context toolbar — for free. `kind`
- * discriminates the four basics; only `gatewayExclusive` is decorated with a
- * glyph (the X) by the renderer (the others are plain native shapes).
+ * discriminates the artefacts and drives the RENDERING alone; what a node
+ * MEANS is the `role` stamped on it at creation (`gfx/bpmn/src/roles.ts`).
+ * The plain start event, end event and task are undecorated native shapes;
+ * every other kind is decorated with a glyph by the renderer.
  *
  * Mirrors {@link EdgyNodeElementModel}.
  */

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

@@ -1,30 +1,148 @@
-import type { IVec, SerializedXYWH } from '../../../global/gfx/index.js';
-import { Bound } from '../../../global/gfx/index.js';
-import type { BaseElementProps } from '../../../std/gfx/index.js';
-import { GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
-export type BpmnPoolProps = BaseElementProps & {
+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".
+ *
+ * The shape of a {@link BackgroundInstanceZoneItem} in
+ * `@labre/affine-block-surface`, and deliberately the same three fields: the
+ * primitive paints an instance partition from that structure, the audit reports
+ * it from that structure, and a lane that had a shape of its own would be a
+ * fourth place the two have to agree.
+ *
+ * `size` is a relative WEIGHT, not a height in model units: lanes share the
+ * plot in proportion to their sizes, so a pool dragged taller redistributes the
+ * extra space instead of leaving a gap under the last band. `2` reads as "twice
+ * the other one", which is the only thing a lane's height ever means.
+ */
+export interface BpmnLane {
+    /** Stable id, generated at creation. Never the name: a lane can be renamed. */
+    id: string;
+    /** The lane name, written horizontally in its top-left corner. */
+    name?: string;
+    /** Relative weight — see above. Must be a finite number greater than zero. */
+    size: number;
+}
+export type BpmnPoolProps = FrameworkBackgroundProps & {
     /** The participant name shown in the left band — edited inline on dblclick. */
     name?: string;
-    /** When false the resize handles are hidden — toggled from the toolbar. */
-    resizeEnabled?: boolean;
+    /** The pool's own partition into lanes. Absent until the first one is added. */
+    lanes?: BpmnLane[];
 };
 /**
  * A BPMN "pool": a participant container drawn as a rounded-rect frame with a
- * vertical name band on the left. It is a background element (like the wardley
- * / cynefin backgrounds): the user drops flow-object nodes on top of it. Lanes
- * are deliberately out of scope for v1.
+ * vertical name band on the left. It is a framework background like every other
+ * one in the library — the user drops flow-object nodes on top of it, and a
+ * connector never snaps to it.
+ *
+ * The geometry of a passive canvas comes from
+ * {@link FrameworkBackgroundElementModel}: this class used to restate all five
+ * of those overrides verbatim, which is exactly the kind of copy that drifts.
+ * The persisted type is still `bpmnPool`, and the first four fields below are
+ * the four it has always written, in the same order, with the same defaults.
  *
- * Mirrors the other framework background elements.
+ * What it LOOKS like is declared, not coded: see `BPMN_POOL_BACKGROUND` in
+ * `@labre/affine-gfx-bpmn`.
  */
-export declare class BpmnPoolElementModel extends GfxPrimitiveElementModel<BpmnPoolProps> {
+export declare class BpmnPoolElementModel extends FrameworkBackgroundElementModel<BpmnPoolProps> {
     get type(): string;
-    get connectable(): boolean;
-    containsBound(bounds: Bound): boolean;
-    getLineIntersections(start: IVec, end: IVec): import("../../../global/gfx/index.js").PointLocation[] | null;
-    getNearestPoint(point: IVec): IVec;
-    includesPoint(x: number, y: number): boolean;
     accessor name: string;
     accessor resizeEnabled: boolean;
     accessor rotate: number;
     accessor xywh: SerializedXYWH;
+    /**
+     * The pool's own partition into lanes, in top-to-bottom order.
+     *
+     * The FIFTH field, and the only one that is optional. It mirrors
+     * `validationExceptions` on the base element model exactly, for the same three
+     * reasons:
+     *
+     * - **`undefined`, not `[]`.** `@field()`'s `init` writes nothing for an
+     *   `undefined` default, so a pool that has no lane stays byte-identical to
+     *   one created before this field existed: optional field, no schema version
+     *   bump, no migration, and every document already on disk opens and paints
+     *   exactly as it did (pinned by `pool-background.unit.spec.ts`, whose
+     *   fixture carries no `lanes` key). Removing the last lane goes back through
+     *   `clearField`, which deletes the KEY rather than leaving a phantom one.
+     * - **Flat JSON on purpose.** Element serialization is one level deep, and a
+     *   value a Yjs update can encode is the contract `_assignElementProp`
+     *   enforces. A nested `Y.Map` is what `tags` needs and this does not (see
+     *   `docs/adr/0007`): a lane list is one atomic choice about how a single
+     *   participant's own band is cut, authored by whoever is drawing the
+     *   process — not an accumulating multi-key set different people qualify
+     *   concurrently. The trade is stated so it is reviewed, not discovered:
+     *   two peers reordering the lanes at the same moment resolve
+     *   last-write-wins, one whole list winning over the other.
+     * - **Declared HERE and not on the base class.** A lane is a subdivision of a
+     *   pool and of nothing else, and the accessor is what carries the value
+     *   through a copy, a paste or a template insertion, so a duplicated pool
+     *   arrives with its lanes.
+     *
+     * What it MEANS is declared, not coded: `BPMN_POOL_BACKGROUND.instanceZones`
+     * in `@labre/affine-gfx-bpmn` names this prop, and the framework-background
+     * primitive paints the dividers and the names from it.
+     */
+    accessor lanes: BpmnLane[] | undefined;
+    /**
+     * A pool is picked by its BORDER — and by its TITLE BANDS, which is the one
+     * carve-out the recette kept (issue #194).
+     *
+     * That is the bpmn.io convention, and it is the convention because the bands
+     * are the only part of a pool that is the pool rather than the process drawn
+     * on it: the participant strip on the left carries the participant's name,
+     * the lane strip beside it carries the lane names, and nothing is ever
+     * dropped on either. The flow area is where the work goes, so a click there
+     * belongs to whatever is under the pointer.
+     *
+     * ## Where the geometry comes from
+     *
+     * The two strips run the FULL height of the pool: the participant band is the
+     * whole left margin, and the lane bands partition that same height between
+     * them with no gap — so their union is one vertical strip
+     * `POOL_LANE_BAND_WIDTH` wide, whatever the lanes' individual weights are.
+     * Which means this test needs no lane arithmetic at all, only the two widths
+     * (declared above, and read from here by the framework declaration) and the
+     * answer to "does this pool have a usable lane".
+     *
+     * The zoom-grown rename targets — the touch-sized boxes a double-click aims
+     * at — are the VIEW's business and stay in `pool-hit.ts`; what is painted is
+     * what is selectable, which is the promise this test has to keep.
+     */
+    includesPoint(x: number, y: number, options?: PointTestOptions): boolean;
+    /**
+     * Whether at least one lane is drawn — the only thing the hit test needs to
+     * know about the partition.
+     *
+     * Mirrors what `backgroundInstanceZones` keeps (a string id, a finite size
+     * greater than zero): a malformed row is dropped there and paints no band, so
+     * it must not make a band clickable here either.
+     */
+    private get hasUsableLane();
 }

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

@@ -32,18 +32,51 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { Bound, getPointsFromBoundWithRotation, linePolygonIntersects, pointInPolygon, polygonNearestPoint, } from '../../../global/gfx/index.js';
-import { field, GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
+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;
 /**
  * A BPMN "pool": a participant container drawn as a rounded-rect frame with a
- * vertical name band on the left. It is a background element (like the wardley
- * / cynefin backgrounds): the user drops flow-object nodes on top of it. Lanes
- * are deliberately out of scope for v1.
+ * vertical name band on the left. It is a framework background like every other
+ * one in the library — the user drops flow-object nodes on top of it, and a
+ * connector never snaps to it.
+ *
+ * The geometry of a passive canvas comes from
+ * {@link FrameworkBackgroundElementModel}: this class used to restate all five
+ * of those overrides verbatim, which is exactly the kind of copy that drifts.
+ * The persisted type is still `bpmnPool`, and the first four fields below are
+ * the four it has always written, in the same order, with the same defaults.
  *
- * Mirrors the other framework background elements.
+ * What it LOOKS like is declared, not coded: see `BPMN_POOL_BACKGROUND` in
+ * `@labre/affine-gfx-bpmn`.
  */
 let BpmnPoolElementModel = (() => {
-    let _classSuper = GfxPrimitiveElementModel;
+    let _classSuper = FrameworkBackgroundElementModel;
     let _name_decorators;
     let _name_initializers = [];
     let _name_extraInitializers = [];
@@ -56,6 +89,9 @@ let BpmnPoolElementModel = (() => {
     let _xywh_decorators;
     let _xywh_initializers = [];
     let _xywh_extraInitializers = [];
+    let _lanes_decorators;
+    let _lanes_initializers = [];
+    let _lanes_extraInitializers = [];
     return class BpmnPoolElementModel extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
@@ -63,33 +99,17 @@ let BpmnPoolElementModel = (() => {
             _resizeEnabled_decorators = [field(true)];
             _rotate_decorators = [field(0)];
             _xywh_decorators = [field()];
+            _lanes_decorators = [field()];
             __esDecorate(this, null, _name_decorators, { kind: "accessor", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
             __esDecorate(this, null, _resizeEnabled_decorators, { kind: "accessor", name: "resizeEnabled", static: false, private: false, access: { has: obj => "resizeEnabled" in obj, get: obj => obj.resizeEnabled, set: (obj, value) => { obj.resizeEnabled = value; } }, metadata: _metadata }, _resizeEnabled_initializers, _resizeEnabled_extraInitializers);
             __esDecorate(this, null, _rotate_decorators, { kind: "accessor", name: "rotate", static: false, private: false, access: { has: obj => "rotate" in obj, get: obj => obj.rotate, set: (obj, value) => { obj.rotate = value; } }, metadata: _metadata }, _rotate_initializers, _rotate_extraInitializers);
             __esDecorate(this, null, _xywh_decorators, { kind: "accessor", name: "xywh", static: false, private: false, access: { has: obj => "xywh" in obj, get: obj => obj.xywh, set: (obj, value) => { obj.xywh = value; } }, metadata: _metadata }, _xywh_initializers, _xywh_extraInitializers);
+            __esDecorate(this, null, _lanes_decorators, { kind: "accessor", name: "lanes", static: false, private: false, access: { has: obj => "lanes" in obj, get: obj => obj.lanes, set: (obj, value) => { obj.lanes = value; } }, metadata: _metadata }, _lanes_initializers, _lanes_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         get type() {
             return 'bpmnPool';
         }
-        get connectable() {
-            return false;
-        }
-        containsBound(bounds) {
-            const points = getPointsFromBoundWithRotation(this);
-            return points.some(point => bounds.containsPoint(point));
-        }
-        getLineIntersections(start, end) {
-            const points = getPointsFromBoundWithRotation(this);
-            return linePolygonIntersects(start, end, points);
-        }
-        getNearestPoint(point) {
-            return polygonNearestPoint(Bound.deserialize(this.xywh).points, point);
-        }
-        includesPoint(x, y) {
-            const points = getPointsFromBoundWithRotation(this);
-            return pointInPolygon([x, y], points);
-        }
         #name_accessor_storage = __runInitializers(this, _name_initializers, 'Pool');
         get name() { return this.#name_accessor_storage; }
         set name(value) { this.#name_accessor_storage = value; }
@@ -102,9 +122,111 @@ let BpmnPoolElementModel = (() => {
         #xywh_accessor_storage = (__runInitializers(this, _rotate_extraInitializers), __runInitializers(this, _xywh_initializers, '[0,0,560,200]'));
         get xywh() { return this.#xywh_accessor_storage; }
         set xywh(value) { this.#xywh_accessor_storage = value; }
+        #lanes_accessor_storage = (__runInitializers(this, _xywh_extraInitializers), __runInitializers(this, _lanes_initializers, undefined));
+        /**
+         * The pool's own partition into lanes, in top-to-bottom order.
+         *
+         * The FIFTH field, and the only one that is optional. It mirrors
+         * `validationExceptions` on the base element model exactly, for the same three
+         * reasons:
+         *
+         * - **`undefined`, not `[]`.** `@field()`'s `init` writes nothing for an
+         *   `undefined` default, so a pool that has no lane stays byte-identical to
+         *   one created before this field existed: optional field, no schema version
+         *   bump, no migration, and every document already on disk opens and paints
+         *   exactly as it did (pinned by `pool-background.unit.spec.ts`, whose
+         *   fixture carries no `lanes` key). Removing the last lane goes back through
+         *   `clearField`, which deletes the KEY rather than leaving a phantom one.
+         * - **Flat JSON on purpose.** Element serialization is one level deep, and a
+         *   value a Yjs update can encode is the contract `_assignElementProp`
+         *   enforces. A nested `Y.Map` is what `tags` needs and this does not (see
+         *   `docs/adr/0007`): a lane list is one atomic choice about how a single
+         *   participant's own band is cut, authored by whoever is drawing the
+         *   process — not an accumulating multi-key set different people qualify
+         *   concurrently. The trade is stated so it is reviewed, not discovered:
+         *   two peers reordering the lanes at the same moment resolve
+         *   last-write-wins, one whole list winning over the other.
+         * - **Declared HERE and not on the base class.** A lane is a subdivision of a
+         *   pool and of nothing else, and the accessor is what carries the value
+         *   through a copy, a paste or a template insertion, so a duplicated pool
+         *   arrives with its lanes.
+         *
+         * What it MEANS is declared, not coded: `BPMN_POOL_BACKGROUND.instanceZones`
+         * in `@labre/affine-gfx-bpmn` names this prop, and the framework-background
+         * primitive paints the dividers and the names from it.
+         */
+        get lanes() { return this.#lanes_accessor_storage; }
+        set lanes(value) { this.#lanes_accessor_storage = value; }
+        /**
+         * A pool is picked by its BORDER — and by its TITLE BANDS, which is the one
+         * carve-out the recette kept (issue #194).
+         *
+         * That is the bpmn.io convention, and it is the convention because the bands
+         * are the only part of a pool that is the pool rather than the process drawn
+         * on it: the participant strip on the left carries the participant's name,
+         * the lane strip beside it carries the lane names, and nothing is ever
+         * dropped on either. The flow area is where the work goes, so a click there
+         * belongs to whatever is under the pointer.
+         *
+         * ## Where the geometry comes from
+         *
+         * The two strips run the FULL height of the pool: the participant band is the
+         * whole left margin, and the lane bands partition that same height between
+         * them with no gap — so their union is one vertical strip
+         * `POOL_LANE_BAND_WIDTH` wide, whatever the lanes' individual weights are.
+         * Which means this test needs no lane arithmetic at all, only the two widths
+         * (declared above, and read from here by the framework declaration) and the
+         * answer to "does this pool have a usable lane".
+         *
+         * The zoom-grown rename targets — the touch-sized boxes a double-click aims
+         * at — are the VIEW's business and stay in `pool-hit.ts`; what is painted is
+         * what is selectable, which is the promise this test has to keep.
+         */
+        includesPoint(x, y, options) {
+            if (super.includesPoint(x, y, options))
+                return true;
+            const [ex, ey, w, h] = this.deserializedXYWH;
+            // Element-local coordinates, undoing the element rotation about its centre
+            // — the bands are axis-aligned inside the pool, not on the canvas.
+            let lx = x - ex;
+            let ly = y - ey;
+            const rotate = this.rotate ?? 0;
+            if (rotate) {
+                const [ux, uy] = rotatePoint([x, y], [ex + w / 2, ey + h / 2], -rotate);
+                lx = ux - ex;
+                ly = uy - ey;
+            }
+            if (ly < 0 || ly > h || lx < 0)
+                return false;
+            // Clamped to a pool narrower than its own margin — the degenerate case the
+            // renderer clamps too.
+            const band = Math.min(POOL_BAND_WIDTH, w);
+            const lanes = this.hasUsableLane
+                ? Math.min(POOL_LANE_BAND_WIDTH, w - band)
+                : 0;
+            return lx <= band + Math.max(lanes, 0);
+        }
+        /**
+         * Whether at least one lane is drawn — the only thing the hit test needs to
+         * know about the partition.
+         *
+         * Mirrors what `backgroundInstanceZones` keeps (a string id, a finite size
+         * greater than zero): a malformed row is dropped there and paints no band, so
+         * it must not make a band clickable here either.
+         */
+        get hasUsableLane() {
+            const lanes = this.lanes;
+            if (!Array.isArray(lanes))
+                return false;
+            return lanes.some(lane => typeof lane?.id === 'string' &&
+                lane.id !== '' &&
+                typeof lane.size === 'number' &&
+                Number.isFinite(lane.size) &&
+                lane.size > 0);
+        }
         constructor() {
             super(...arguments);
-            __runInitializers(this, _xywh_extraInitializers);
+            __runInitializers(this, _lanes_extraInitializers);
         }
     };
 })();