@formicoidea/labre-core 0.41.0 → 0.42.0

package/dist/_pkgs/affine-gfx-connector/toolbar/config.js

@@ -1,8 +1,8 @@
 import { EdgelessCRUDIdentifier } from '../../affine-block-surface/index.js';
-import { packColor, } from '../../affine-components/color-picker/index.js';
+import { frameworkPaletteGroups, packColor, } from '../../affine-components/color-picker/index.js';
 import { createTextActions, normalizeTextBound } from '../../affine-gfx-text/index.js';
 import { ConnectorElementModel, ConnectorMode, DEFAULT_FRONT_ENDPOINT_STYLE, DEFAULT_REAR_ENDPOINT_STYLE, DefaultTheme, LineWidth, PointStyle, resolveColor, StrokeStyle, } from '../../affine-model/index.js';
-import { ToolbarModuleExtension, translateKey, } from '../../affine-shared/services/index.js';
+import { CONNECTOR_SOURCE_LABEL, CONNECTOR_TARGET_LABEL, ToolbarModuleExtension, translateKey, } from '../../affine-shared/services/index.js';
 import { getMostCommonResolvedValue, getMostCommonValue, } from '../../affine-shared/utils/index.js';
 import { getRootBlock, LINE_STYLE_LIST, renderMenu, } from '../../affine-widget-edgeless-toolbar/index.js';
 import { Bound } from '../../global/gfx/index.js';
@@ -14,8 +14,20 @@ import { isConnectorWithLabel } from '../connector-manager.js';
 import { INVERT_EDGE_DIRECTION, invertEdgeDirection, } from '../direction/invert-direction.js';
 import { asTypedEdge, edgeIsBound, roleVocabularies, } from '../direction/typed-edge.js';
 import { mountConnectorLabelEditor } from '../text/index.js';
+import { EndPointDiamondHollowIcon, EndPointTriangleHollowIcon, StartPointDiamondHollowIcon, StartPointTriangleHollowIcon, } from './hollow-endpoint-icons.js';
 import { CONNECTOR_ADD_TEXT, CONNECTOR_LABEL_END_POINT_STYLE, CONNECTOR_LABEL_SHAPE, CONNECTOR_LABEL_START_POINT_STYLE, CONNECTOR_LABEL_STROKE_STYLE, CONNECTOR_LABEL_STYLE, CONNECTOR_MODE_WORDING, CONNECTOR_TOOLTIP_CONNECTOR_SHAPE, CONNECTOR_TOOLTIP_FLIP_DIRECTION, } from '../translations.js';
-const FRONT_ENDPOINT_STYLE_LIST = [
+/**
+ * Every `PointStyle` must appear in BOTH lists.
+ *
+ * `renderMenu` paints the menu's trigger with
+ * `renderCurrentMenuItemWith(items, currentValue, 'icon')`, which returns
+ * `undefined` for a value the list does not carry — an unlisted style gives a
+ * blank button, so a connector created by a framework (or imported) with that
+ * head shows an empty endpoint control. There is no test that can catch a
+ * forgotten entry at the type level; `endpoint-style.unit.spec.ts` asserts the
+ * coverage instead.
+ */
+export const FRONT_ENDPOINT_STYLE_LIST = [
     {
         value: PointStyle.None,
         icon: StartPointIcon(),
@@ -28,6 +40,10 @@ const FRONT_ENDPOINT_STYLE_LIST = [
         value: PointStyle.Triangle,
         icon: StartPointTriangleIcon(),
     },
+    {
+        value: PointStyle.TriangleHollow,
+        icon: StartPointTriangleHollowIcon(),
+    },
     {
         value: PointStyle.Circle,
         icon: StartPointCircleIcon(),
@@ -36,12 +52,20 @@ const FRONT_ENDPOINT_STYLE_LIST = [
         value: PointStyle.Diamond,
         icon: StartPointDiamondIcon(),
     },
+    {
+        value: PointStyle.DiamondHollow,
+        icon: StartPointDiamondHollowIcon(),
+    },
 ];
-const REAR_ENDPOINT_STYLE_LIST = [
+export const REAR_ENDPOINT_STYLE_LIST = [
     {
         value: PointStyle.Diamond,
         icon: EndPointDiamondIcon(),
     },
+    {
+        value: PointStyle.DiamondHollow,
+        icon: EndPointDiamondHollowIcon(),
+    },
     {
         value: PointStyle.Circle,
         icon: EndPointCircleIcon(),
@@ -50,6 +74,10 @@ const REAR_ENDPOINT_STYLE_LIST = [
         value: PointStyle.Triangle,
         icon: EndPointTriangleIcon(),
     },
+    {
+        value: PointStyle.TriangleHollow,
+        icon: EndPointTriangleHollowIcon(),
+    },
     {
         value: PointStyle.Arrow,
         icon: EndPointArrowIcon(),
@@ -127,6 +155,9 @@ export const connectorToolbarConfig = {
                     }
                     updateModelsWith(ctx, models, 'strokeStyle', value);
                 };
+                // A link belongs to what it links: the carousel opens on the framework
+                // of its endpoints, else of the board it crosses (`docs/adr/0027`).
+                const carousel = frameworkPaletteGroups(ctx.std, models, DefaultTheme.Palettes);
                 return html `
           <edgeless-color-picker-button
             class="stroke-color"
@@ -137,6 +168,8 @@ export const connectorToolbarConfig = {
             .hollowCircle=${true}
             .originalColor=${firstModel.stroke}
             .enableCustomColor=${enableCustomColor}
+            .paletteGroups=${carousel.groups}
+            .activeGroupKey=${carousel.activeKey}
             .std=${ctx.std}
           >
             <edgeless-line-styles-panel
@@ -360,6 +393,41 @@ export const connectorToolbarConfig = {
                 mountConnectorLabelEditor(model, rootBlock);
             },
         },
+        /**
+         * The two END labels (`docs/adr/0018` phase 2).
+         *
+         * After the caption and its style controls, because that is the order the
+         * notation itself has: an association is named in the middle and adorned at
+         * its ends. Each entry appears only while its own end is bare — an end
+         * label that exists is edited by double-clicking it, exactly as the caption
+         * is, and `g.text` has always hidden itself on the same rule.
+         *
+         * Wordings, not literals: the row is a host's UI, and a hard-coded "Source
+         * label" is the one word a translated editor cannot translate (#183).
+         */
+        ...['source', 'target'].map(end => ({
+            id: end === 'source' ? 'h.source-label' : 'h.target-label',
+            tooltipWording: end === 'source' ? CONNECTOR_SOURCE_LABEL : CONNECTOR_TARGET_LABEL,
+            labelWording: end === 'source' ? CONNECTOR_SOURCE_LABEL : CONNECTOR_TARGET_LABEL,
+            icon: AddTextIcon(),
+            when(ctx) {
+                const models = ctx.getSurfaceModelsByType(ConnectorElementModel);
+                if (models.length !== 1)
+                    return false;
+                return end === 'source'
+                    ? !models[0].sourceLabel
+                    : !models[0].targetLabel;
+            },
+            run(ctx) {
+                const model = ctx.getCurrentModelByType(ConnectorElementModel);
+                if (!model)
+                    return;
+                const rootBlock = getRootBlock(ctx);
+                if (!rootBlock)
+                    return;
+                mountConnectorLabelEditor(model, rootBlock, undefined, { which: end });
+            },
+        })),
         // id: `g.text`
         ...createTextActions(ConnectorElementModel, 'connector', (ctx, model, props) => {
             if (!isConnectorWithLabel(model))

package/dist/_pkgs/affine-gfx-connector/toolbar/hollow-endpoint-icons.d.ts

@@ -0,0 +1,8 @@
+/** Front (start) hollow diamond — the head sits at the left end of the stub. */
+export declare const StartPointDiamondHollowIcon: () => import("lit-html").TemplateResult<1>;
+/** Rear (end) hollow diamond — the head sits at the right end of the stub. */
+export declare const EndPointDiamondHollowIcon: () => import("lit-html").TemplateResult<1>;
+/** Front (start) hollow closed triangle. */
+export declare const StartPointTriangleHollowIcon: () => import("lit-html").TemplateResult<1>;
+/** Rear (end) hollow closed triangle. */
+export declare const EndPointTriangleHollowIcon: () => import("lit-html").TemplateResult<1>;

package/dist/_pkgs/affine-gfx-connector/toolbar/hollow-endpoint-icons.js

@@ -0,0 +1,118 @@
+import { html } from 'lit';
+/**
+ * The four toolbar icons for the hollow UML endpoint heads.
+ *
+ * Hand-authored because `@blocksuite/icons` has no hollow variant of its
+ * `StartPoint*` / `EndPoint*` set. They mirror that set deliberately: the same
+ * `0 0 24 24` viewBox and the same `1em` box, so a hollow entry lines up
+ * pixel-for-pixel with the filled neighbour it sits next to in the endpoint
+ * menus. The difference is only the paint — the shipped icons merge stub and
+ * head into one `fill='currentColor'` path, these draw the stub as a stroked
+ * line and leave the head `fill="none"` so the reader sees the hollow head the
+ * canvas will actually draw.
+ *
+ * Each is a function returning a `TemplateResult`, matching how the
+ * `@blocksuite/icons` lit icons are called at the use site
+ * (`StartPointDiamondIcon()`).
+ */
+const ICON_STYLE = 'user-select:none;flex-shrink:0;';
+/** Front (start) hollow diamond — the head sits at the left end of the stub. */
+export const StartPointDiamondHollowIcon = () => html `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    viewBox="0 0 24 24"
+    width="1em"
+    height="1em"
+    fill="none"
+    style=${ICON_STYLE}
+  >
+    <path
+      d="M21 12H11"
+      stroke="currentColor"
+      stroke-width="1.5"
+      stroke-linecap="round"
+    />
+    <path
+      d="M11 12L7 8L3 12L7 16Z"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="1.5"
+      stroke-linejoin="round"
+    />
+  </svg>
+`;
+/** Rear (end) hollow diamond — the head sits at the right end of the stub. */
+export const EndPointDiamondHollowIcon = () => html `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    viewBox="0 0 24 24"
+    width="1em"
+    height="1em"
+    fill="none"
+    style=${ICON_STYLE}
+  >
+    <path
+      d="M3 12H13"
+      stroke="currentColor"
+      stroke-width="1.5"
+      stroke-linecap="round"
+    />
+    <path
+      d="M13 12L17 8L21 12L17 16Z"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="1.5"
+      stroke-linejoin="round"
+    />
+  </svg>
+`;
+/** Front (start) hollow closed triangle. */
+export const StartPointTriangleHollowIcon = () => html `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    viewBox="0 0 24 24"
+    width="1em"
+    height="1em"
+    fill="none"
+    style=${ICON_STYLE}
+  >
+    <path
+      d="M21 12H10.5"
+      stroke="currentColor"
+      stroke-width="1.5"
+      stroke-linecap="round"
+    />
+    <path
+      d="M10.5 7.5L3 12L10.5 16.5Z"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="1.5"
+      stroke-linejoin="round"
+    />
+  </svg>
+`;
+/** Rear (end) hollow closed triangle. */
+export const EndPointTriangleHollowIcon = () => html `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    viewBox="0 0 24 24"
+    width="1em"
+    height="1em"
+    fill="none"
+    style=${ICON_STYLE}
+  >
+    <path
+      d="M3 12H13.5"
+      stroke="currentColor"
+      stroke-width="1.5"
+      stroke-linecap="round"
+    />
+    <path
+      d="M13.5 7.5L21 12L13.5 16.5Z"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="1.5"
+      stroke-linejoin="round"
+    />
+  </svg>
+`;

package/dist/_pkgs/affine-gfx-connector/view/view.d.ts

@@ -1,5 +1,41 @@
-import { type ConnectorElementModel } from '../../affine-model/index.js';
+import { CONNECTOR_END_LABEL_GRAB, type ConnectorElementModel } from '../../affine-model/index.js';
+import { type IVec, type XYWH } from '../../global/gfx/index.js';
 import { type DragEndContext, type DragMoveContext, type DragStartContext, GfxElementModelView } from '../../std/gfx/index.js';
+import { type ConnectorLabelWhich } from '../text/edgeless-connector-label-editor.js';
+/**
+ * How close to an endpoint a double-click has to land to mean "the label of
+ * THAT end" (`docs/adr/0018` phase 2).
+ *
+ * Re-exported rather than declared: the number is the model's now, because the
+ * connector's own HIT TEST has to claim the same discs — a gesture the
+ * dispatcher never delivers is a gesture no picker gets to interpret
+ * (`connectorEndNear`, and the PO's recette of 14/09/2026). Kept exported here
+ * because this is where every caller has always reached for it.
+ */
+export { CONNECTOR_END_LABEL_GRAB };
+/** What {@link pickConnectorLabelWhich} needs, and nothing more. */
+export type ConnectorLabelHitTarget = {
+    absolutePath: readonly IVec[];
+    sourceLabelXYWH?: XYWH;
+    targetLabelXYWH?: XYWH;
+};
+/**
+ * Which of a connector's three labels a point is asking for.
+ *
+ * The order is what makes the gesture predictable:
+ *
+ * 1. an END LABEL BOX under the pointer — an existing label is edited where it
+ *    is drawn, never re-created somewhere else;
+ * 2. otherwise, within {@link CONNECTOR_END_LABEL_GRAB} of an ENDPOINT — the
+ *    nearer end, which is where a label the connector does not have yet gets
+ *    created;
+ * 3. otherwise the CENTRE, which is what a double-click on a connector has
+ *    always meant and stays the answer everywhere else on the line.
+ *
+ * Pure, and exported, because the ordering is the whole behaviour and a spec
+ * that had to drive a real pointer to check it would test the dispatcher.
+ */
+export declare function pickConnectorLabelWhich(connector: ConnectorLabelHitTarget, point: IVec, grab?: number): ConnectorLabelWhich;
 export declare class ConnectorElementView extends GfxElementModelView<ConnectorElementModel> {
     static type: string;
     onDragStart: (context: DragStartContext) => void;

package/dist/_pkgs/affine-gfx-connector/view/view.js

@@ -1,7 +1,55 @@
-import { LocalShapeElementModel, } from '../../affine-model/index.js';
-import { Bound, serializeXYWH, Vec } from '../../global/gfx/index.js';
+import { CONNECTOR_END_LABEL_GRAB, LocalShapeElementModel, } from '../../affine-model/index.js';
+import { Bound, serializeXYWH, Vec, } from '../../global/gfx/index.js';
 import { generateKeyBetween, GfxElementModelView, GfxViewInteractionExtension, } from '../../std/gfx/index.js';
-import { mountConnectorLabelEditor } from '../text/edgeless-connector-label-editor.js';
+import { mountConnectorLabelEditor, } from '../text/edgeless-connector-label-editor.js';
+/**
+ * How close to an endpoint a double-click has to land to mean "the label of
+ * THAT end" (`docs/adr/0018` phase 2).
+ *
+ * Re-exported rather than declared: the number is the model's now, because the
+ * connector's own HIT TEST has to claim the same discs — a gesture the
+ * dispatcher never delivers is a gesture no picker gets to interpret
+ * (`connectorEndNear`, and the PO's recette of 14/09/2026). Kept exported here
+ * because this is where every caller has always reached for it.
+ */
+export { CONNECTOR_END_LABEL_GRAB };
+/**
+ * Which of a connector's three labels a point is asking for.
+ *
+ * The order is what makes the gesture predictable:
+ *
+ * 1. an END LABEL BOX under the pointer — an existing label is edited where it
+ *    is drawn, never re-created somewhere else;
+ * 2. otherwise, within {@link CONNECTOR_END_LABEL_GRAB} of an ENDPOINT — the
+ *    nearer end, which is where a label the connector does not have yet gets
+ *    created;
+ * 3. otherwise the CENTRE, which is what a double-click on a connector has
+ *    always meant and stays the answer everywhere else on the line.
+ *
+ * Pure, and exported, because the ordering is the whole behaviour and a spec
+ * that had to drive a real pointer to check it would test the dispatcher.
+ */
+export function pickConnectorLabelWhich(connector, point, grab = CONNECTOR_END_LABEL_GRAB) {
+    const boxes = [
+        ['source', connector.sourceLabelXYWH],
+        ['target', connector.targetLabelXYWH],
+    ];
+    for (const [end, box] of boxes) {
+        if (box && Bound.fromXYWH(box).isPointInBound(point))
+            return end;
+    }
+    const path = connector.absolutePath;
+    if (path.length) {
+        const first = path[0];
+        const last = path[path.length - 1];
+        const toSource = Vec.dist(point, [first[0], first[1]]);
+        const toTarget = Vec.dist(point, [last[0], last[1]]);
+        if (Math.min(toSource, toTarget) <= grab) {
+            return toSource <= toTarget ? 'source' : 'target';
+        }
+    }
+    return 'center';
+}
 export class ConnectorElementView extends GfxElementModelView {
     constructor() {
         super(...arguments);
@@ -21,6 +69,30 @@ export class ConnectorElementView extends GfxElementModelView {
     static { this.type = 'connector'; }
     onCreated() {
         super.onCreated();
+        // What the GRID must offer before any hit test is asked. The grid indexes a
+        // connector by its `responseBound` — the box of its PATH — and the end-label
+        // grab discs stick out of it by up to `CONNECTOR_END_LABEL_GRAB`, so without
+        // this nothing is ever a candidate out there and
+        // `ConnectorElementModel.endGrabIncludesPoint` never gets asked. It widens
+        // the CANDIDATE set only: what is picked, hovered and selected is still
+        // decided by the model's own `includesPoint`.
+        //
+        // Set from the view rather than defaulted on the model because it is a
+        // LOCAL fact about this peer's pointer, which is exactly what
+        // `responseExtension` is for — nothing about it is written to the document.
+        //
+        // NOT gated on the model's `role`, although `endGrabIncludesPoint` is
+        // (a generalist connector keeps its hairline). Two reasons, and both are
+        // about `onCreated` running exactly once: a connector acquires its role
+        // AFTER creation often enough — an import writes the element then types it,
+        // a morph retypes it, a paste re-creates it — and a halo decided at that one
+        // moment would be missing for every one of those. And it costs nothing to
+        // keep: the extension widens the CANDIDATE set only, and the authority on
+        // what a point actually hits is the model, which now declines.
+        this.model.responseExtension = [
+            CONNECTOR_END_LABEL_GRAB,
+            CONNECTOR_END_LABEL_GRAB,
+        ];
         this._initLabelMoving();
     }
     _initLabelMoving() {
@@ -28,12 +100,14 @@ export class ConnectorElementView extends GfxElementModelView {
         if (this.model.isLocked()) {
             return;
         }
-        const enterLabelEditor = (evt) => {
+        const enterLabelEditor = (evt, which = 'center') => {
             const edgeless = this.std.view.getBlock(this.std.store.root.id);
             if (edgeless && !this.model.isLocked()) {
-                mountConnectorLabelEditor(this.model, edgeless, this.gfx.viewport.toModelCoord(evt.x, evt.y));
+                mountConnectorLabelEditor(this.model, edgeless, this.gfx.viewport.toModelCoord(evt.x, evt.y), { which });
             }
         };
+        /** Which label the pointer is asking for, in model coordinates. */
+        const labelEndAt = (evt) => pickConnectorLabelWhich(this.model, this.gfx.viewport.toModelCoord(evt.x, evt.y));
         const getCurrentPosition = (evt) => {
             const [x, y] = this.gfx.viewport.toModelCoord(evt.x, evt.y);
             return {
@@ -64,7 +138,10 @@ export class ConnectorElementView extends GfxElementModelView {
                 clientY: 0,
             };
             view.on('dblclick', evt => {
-                enterLabelEditor(evt);
+                // This view IS the centre label's box, so the answer is not up for
+                // discussion — a short connector whose caption sits within grabbing
+                // distance of an arrowhead still edits its caption when you click it.
+                enterLabelEditor(evt, 'center');
             });
             view.on('dragstart', evt => {
                 startPoint = getCurrentPosition(evt);
@@ -130,9 +207,21 @@ export class ConnectorElementView extends GfxElementModelView {
         }));
         updateLabelElement();
         this.on('dblclick', evt => {
-            if (!curLabelElement) {
-                enterLabelEditor(evt);
+            // The centre label, when it exists, is a local element with its own view
+            // and its own `dblclick` above: anything that lands inside its box is
+            // already spoken for, and answering here too would mount two editors.
+            if (curLabelElement &&
+                Bound.deserialize(curLabelElement.xywh).isPointInBound(this.gfx.viewport.toModelCoord(evt.x, evt.y))) {
+                return;
             }
+            const which = labelEndAt(evt);
+            // Outside that box, `center` means what it meant before this tranche:
+            // open the caption editor when there is no caption yet, and otherwise do
+            // nothing (the caption is edited by clicking the caption). The two ends
+            // are new, and they answer whether the connector has a caption or not.
+            if (which === 'center' && curLabelElement)
+                return;
+            enterLabelEditor(evt, which);
         });
     }
 }

package/dist/_pkgs/affine-gfx-group/command/group-api.js

@@ -77,7 +77,7 @@ export const createGroupCommand = (ctx, next) => {
             return pre;
         }, {}),
         // Translated HERE and once: the title is document content the moment it
-        // lands (ADR 0016), so the host's catalogue is asked at placement and
+        // lands (ADR 0023), so the host's catalogue is asked at placement and
         // never again — a renamed group keeps its name.
         title: translateKey(std, ...GROUP_SEED_NAME, { n: groups.length + 1 }),
     });

package/dist/_pkgs/affine-gfx-group/store.js

@@ -1,6 +1,5 @@
 import { StoreExtensionProvider, } from '../affine-ext-loader/index.js';
 import { groupToMarkdownAdapterMatcher, groupToPlainTextAdapterMatcher, } from './adapter/index.js';
-import { groupRelationWatcherExtension } from './group-watcher.js';
 export class GroupStoreExtension extends StoreExtensionProvider {
     constructor() {
         super(...arguments);
@@ -10,6 +9,5 @@ export class GroupStoreExtension extends StoreExtensionProvider {
         super.setup(context);
         context.register(groupToPlainTextAdapterMatcher);
         context.register(groupToMarkdownAdapterMatcher);
-        context.register(groupRelationWatcherExtension);
     }
 }

package/dist/_pkgs/affine-gfx-group/translations.d.ts

@@ -1,16 +1,15 @@
-import { type ChromeWording } from '../affine-shared/services/index.js';
+import { type ChromeWording, GROUP_SEED_NAME } from '../affine-shared/services/index.js';
 /**
- * The group's own seed: the default title a newly created group is stamped
- * with (`Group 2`), written into the document at creation
- * (`createGroupCommand`). Resolved at PLACEMENT and never again — a group
- * renamed by its author keeps its name, and a group created before this key
- * existed keeps the plain text it was given.
+ * The group's own seed — the default title a newly created group is stamped
+ * with (`Group 2`), written into the document by `createGroupCommand`.
  *
- * `{{n}}` is the group's 1-based ordinal among the groups already on the doc;
- * see the translation-service README on why a count carries a param rather
- * than its own key.
+ * It now LIVES in `@labre/affine-shared`, because the surface block's legend
+ * groups the box it draws and cannot import this package (`gfx-group` depends
+ * on the surface block, not the other way round). Re-exported here unchanged,
+ * and still listed by {@link GROUP_WORDINGS} below, so the key manifest sees
+ * exactly the one `seed` entry it always has.
  */
-export declare const GROUP_SEED_NAME: ChromeWording;
+export { GROUP_SEED_NAME };
 /**
  * This package's contribution to the translation-key manifest — a single seed,
  * listed in `PACKAGE_SEED_WORDINGS` under source `seed`

package/dist/_pkgs/affine-gfx-group/translations.js

@@ -1,19 +1,15 @@
-import { TOOLBAR_INSERT_INTO_PAGE, TOOLBAR_RENAME, TOOLBAR_UNGROUP, } from '../affine-shared/services/index.js';
+import { GROUP_SEED_NAME, TOOLBAR_INSERT_INTO_PAGE, TOOLBAR_RENAME, TOOLBAR_UNGROUP, } from '../affine-shared/services/index.js';
 /**
- * The group's own seed: the default title a newly created group is stamped
- * with (`Group 2`), written into the document at creation
- * (`createGroupCommand`). Resolved at PLACEMENT and never again — a group
- * renamed by its author keeps its name, and a group created before this key
- * existed keeps the plain text it was given.
+ * The group's own seed — the default title a newly created group is stamped
+ * with (`Group 2`), written into the document by `createGroupCommand`.
  *
- * `{{n}}` is the group's 1-based ordinal among the groups already on the doc;
- * see the translation-service README on why a count carries a param rather
- * than its own key.
+ * It now LIVES in `@labre/affine-shared`, because the surface block's legend
+ * groups the box it draws and cannot import this package (`gfx-group` depends
+ * on the surface block, not the other way round). Re-exported here unchanged,
+ * and still listed by {@link GROUP_WORDINGS} below, so the key manifest sees
+ * exactly the one `seed` entry it always has.
  */
-export const GROUP_SEED_NAME = [
-    'com.labre.group.seed.name',
-    'Group {{n}}',
-];
+export { GROUP_SEED_NAME };
 /**
  * This package's contribution to the translation-key manifest — a single seed,
  * listed in `PACKAGE_SEED_WORDINGS` under source `seed`

package/dist/_pkgs/affine-gfx-mindmap/templates/index.js

@@ -29,7 +29,7 @@ function tpl(name, preview, build, nameKey) {
         nameKey,
         content: makeTemplateSnapshot(build(EN_SEEDS), name),
         // The seeds a template writes into the document go through the
-        // translation seam at placement (ADR 0016); `content` stays the English
+        // translation seam at placement (ADR 0023); `content` stays the English
         // build.
         localize: std => makeTemplateSnapshot(build(seedsFor(std)), name),
     };

package/dist/_pkgs/affine-gfx-mindmap/toolbar/basket-elements.js

@@ -37,7 +37,7 @@ export const getMindmapRender = (mindmapStyle) => async (bound, edgeless) => {
     const rootX = x;
     const rootY = centerVertical - rootH / 2;
     // Translated HERE and once: the captions are document content the moment
-    // they land (ADR 0016), so the host's catalogue is asked at placement and
+    // they land (ADR 0023), so the host's catalogue is asked at placement and
     // never again.
     const root = {
         children: [],

package/dist/_pkgs/affine-gfx-mindmap/toolbar/utils/import-mindmap.js

@@ -29,7 +29,7 @@ function readAsText(file) {
 async function parseMmFile(file, std) {
     const content = await readAsText(file);
     // Translated HERE and once: a node with no text is document content the
-    // moment the import lands (ADR 0016).
+    // moment the import lands (ADR 0023).
     const untitled = translateKey(std, ...MINDMAP_SEED_IMPORTED_NODE);
     try {
         const parsed = c.convertXML(content);
@@ -67,7 +67,7 @@ async function parseMmFile(file, std) {
 async function parseOPMLFile(file, std) {
     const content = await readAsText(file);
     // Translated HERE and once: a node with no text is document content the
-    // moment the import lands (ADR 0016).
+    // moment the import lands (ADR 0023).
     const untitled = translateKey(std, ...MINDMAP_SEED_IMPORTED_NODE);
     try {
         const parsed = c.convertXML(content);

package/dist/_pkgs/affine-gfx-mindmap/translations.d.ts

@@ -3,7 +3,7 @@ import { type ChromeWording } from '../affine-shared/services/index.js';
  * The mindmap's own seeds: the captions a freshly placed mindmap is written
  * with, wherever the gesture draws one directly (the toolbar's built-in
  * templates, the drag-from-basket tool, a `.mm`/`.opml` import that meets an
- * empty node). Resolved at PLACEMENT and never again (ADR 0016) — a node
+ * empty node). Resolved at PLACEMENT and never again (ADR 0023) — a node
  * renamed by its author keeps its name, and a mindmap created before these
  * keys existed keeps the plain text it was given.
  *

package/dist/_pkgs/affine-gfx-mindmap/translations.js

@@ -3,7 +3,7 @@ import { MINDMAP_NAME, } from '../affine-shared/services/index.js';
  * The mindmap's own seeds: the captions a freshly placed mindmap is written
  * with, wherever the gesture draws one directly (the toolbar's built-in
  * templates, the drag-from-basket tool, a `.mm`/`.opml` import that meets an
- * empty node). Resolved at PLACEMENT and never again (ADR 0016) — a node
+ * empty node). Resolved at PLACEMENT and never again (ADR 0023) — a node
  * renamed by its author keeps its name, and a mindmap created before these
  * keys existed keeps the plain text it was given.
  *

package/dist/_pkgs/affine-gfx-shape/element-renderer/highlighter.js

@@ -1,4 +1,4 @@
-import { ElementRendererExtension, } from '../../affine-block-surface/index.js';
+import { ElementRendererExtension, taggedPath2D, } from '../../affine-block-surface/index.js';
 import { DefaultTheme, } from '../../affine-model/index.js';
 export const highlighter = (model, ctx, matrix, renderer) => {
     const { rotate, deserializedXYWH: [, , w, h], } = model;
@@ -7,6 +7,6 @@ export const highlighter = (model, ctx, matrix, renderer) => {
     ctx.setTransform(matrix.translateSelf(cx, cy).rotateSelf(rotate).translateSelf(-cx, -cy));
     const color = renderer.getColorValue(model.color, DefaultTheme.hightlighterColor, true);
     ctx.fillStyle = color;
-    ctx.fill(new Path2D(model.commands));
+    ctx.fill(taggedPath2D(model.commands));
 };
 export const HighlighterElementRendererExtension = ElementRendererExtension('highlighter', highlighter);

package/dist/_pkgs/affine-gfx-shape/overlay/polygon-drawing-overlay.d.ts

@@ -37,5 +37,11 @@ export declare class PolygonDrawingOverlay extends ToolOverlay {
      * account (renders as transparent).
      */
     private _effectiveStrokeColor;
+    /**
+     * The marker shown at the pointer while the tool is armed and empty: the same
+     * dot the first placed vertex gets, plus a light ring, so the promise the
+     * cursor makes is the shape the click keeps.
+     */
+    private _renderFirstVertexHint;
     render(ctx: CanvasRenderingContext2D, _rc: RoughCanvas): void;
 }