@formicoidea/labre-core 0.32.0 → 0.34.1

package/dist/_pkgs/affine-model/elements/event-storming/event-storming.js

@@ -0,0 +1,103 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { field } from '../../../std/gfx/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+/**
+ * The Event Storming board: the paper roll a Big Picture is stormed on.
+ *
+ * One axis and nothing else — TIME, running left to right along the bottom.
+ * That is the whole frame of reference Event Storming has: an event drawn to
+ * the left of another happened before it, and how HIGH a sticky sits means
+ * nothing at all (the vertical is where a workshop parks its unknowns, not a
+ * scale). Declaring the one axis and no zones is therefore the honest
+ * declaration, and it is what lets `es.against-timeline` say "this flow runs
+ * backwards" without inventing a second dimension nobody drew against.
+ *
+ * **Swimlanes are cut from v1** (plan § Coupes v1). A lane is a horizontal
+ * BAND with a name, which on this element would be a variant declaration
+ * (`variantProp: 'lanes'`) and a rule family that measures membership per lane.
+ * Neither exists yet, and shipping half of it — bands that paint but that no
+ * rule can read — would put a semantic on the vertical the framework does not
+ * have. The v2 note lives here so the day lanes land, the reason they were not
+ * here is on the record.
+ *
+ * Adds no field of its own beyond the primitive's `resizeEnabled`, so a board
+ * is byte-identical to what {@link FrameworkBackgroundElementModel} already
+ * persists. It is created 3200 × 1400 — a Big Picture is WIDE, because the
+ * timeline is the point — and freely resizable in both directions: the roll
+ * grows sideways all morning as events are remembered, and locking its
+ * proportion would fight the hand.
+ */
+let EventStormingBoardElementModel = (() => {
+    let _classSuper = FrameworkBackgroundElementModel;
+    let _resizeEnabled_decorators;
+    let _resizeEnabled_initializers = [];
+    let _resizeEnabled_extraInitializers = [];
+    let _rotate_decorators;
+    let _rotate_initializers = [];
+    let _rotate_extraInitializers = [];
+    let _xywh_decorators;
+    let _xywh_initializers = [];
+    let _xywh_extraInitializers = [];
+    return class EventStormingBoardElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _resizeEnabled_decorators = [field(true)];
+            _rotate_decorators = [field(0)];
+            _xywh_decorators = [field()];
+            __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);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'eventStorming';
+        }
+        #resizeEnabled_accessor_storage = __runInitializers(this, _resizeEnabled_initializers, true);
+        get resizeEnabled() { return this.#resizeEnabled_accessor_storage; }
+        set resizeEnabled(value) { this.#resizeEnabled_accessor_storage = value; }
+        #rotate_accessor_storage = (__runInitializers(this, _resizeEnabled_extraInitializers), __runInitializers(this, _rotate_initializers, 0));
+        get rotate() { return this.#rotate_accessor_storage; }
+        set rotate(value) { this.#rotate_accessor_storage = value; }
+        #xywh_accessor_storage = (__runInitializers(this, _rotate_extraInitializers), __runInitializers(this, _xywh_initializers, '[0,0,3200,1400]'));
+        get xywh() { return this.#xywh_accessor_storage; }
+        set xywh(value) { this.#xywh_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _xywh_extraInitializers);
+        }
+    };
+})();
+export { EventStormingBoardElementModel };

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

@@ -0,0 +1 @@
+export * from './event-storming.js';

package/dist/_pkgs/affine-model/elements/event-storming/index.js

@@ -0,0 +1 @@
+export * from './event-storming.js';

package/dist/_pkgs/affine-model/elements/framework-background/background.d.ts

@@ -1,6 +1,6 @@
 import type { IVec } from '../../../global/gfx/index.js';
 import { Bound } from '../../../global/gfx/index.js';
-import type { BaseElementProps } from '../../../std/gfx/index.js';
+import type { BaseElementProps, PointTestOptions } from '../../../std/gfx/index.js';
 import { GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
 /**
  * The props every framework background carries, whatever it draws.
@@ -38,5 +38,10 @@ export declare abstract class FrameworkBackgroundElementModel<Props extends Base
     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;
+    /**
+     * Picked by its BORDER band, not by its whole area — see
+     * {@link backgroundIncludesPoint} for the why and for what a caller asking
+     * about the visible extent (`ignoreTransparent: false`) still gets.
+     */
+    includesPoint(x: number, y: number, options?: PointTestOptions): boolean;
 }

package/dist/_pkgs/affine-model/elements/framework-background/background.js

@@ -1,5 +1,6 @@
-import { Bound, getPointsFromBoundWithRotation, linePolygonIntersects, pointInPolygon, polygonNearestPoint, } from '../../../global/gfx/index.js';
+import { Bound, getPointsFromBoundWithRotation, linePolygonIntersects, polygonNearestPoint, } from '../../../global/gfx/index.js';
 import { GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
+import { backgroundIncludesPoint } from './hit-test.js';
 /**
  * The MODEL half of the framework-background primitive (PF2.1).
  *
@@ -35,8 +36,12 @@ export class FrameworkBackgroundElementModel extends GfxPrimitiveElementModel {
     getNearestPoint(point) {
         return polygonNearestPoint(Bound.deserialize(this.xywh).points, point);
     }
-    includesPoint(x, y) {
-        const points = getPointsFromBoundWithRotation(this);
-        return pointInPolygon([x, y], points);
+    /**
+     * Picked by its BORDER band, not by its whole area — see
+     * {@link backgroundIncludesPoint} for the why and for what a caller asking
+     * about the visible extent (`ignoreTransparent: false`) still gets.
+     */
+    includesPoint(x, y, options) {
+        return backgroundIncludesPoint(this, x, y, options);
     }
 }

package/dist/_pkgs/affine-model/elements/framework-background/hit-test.d.ts

@@ -0,0 +1,48 @@
+import type { IBound } from '../../../global/gfx/index.js';
+import type { PointTestOptions } from '../../../std/gfx/index.js';
+/**
+ * The width of the band a background is picked by, in SCREEN pixels.
+ *
+ * Ten is what every caller on the picking path already asks for
+ * (`getElementByPoint`, the default tool, the gfx view event handler all pass
+ * `hitThreshold: 10`); naming it here gives the one caller that passes nothing
+ * — the frame manager, which calls `includesPoint(x, y, {})` — the same band
+ * instead of a shape's 1-pixel default.
+ */
+export declare const BACKGROUND_BORDER_HIT_THRESHOLD = 10;
+/**
+ * Whether a point picks a framework background — THE hit test every background
+ * in the library shares.
+ *
+ * ## A background is picked by its border, not by its area
+ *
+ * A background is a passive canvas: the user drops nodes onto it and works on
+ * THEM. A hit test over the whole rectangle makes the backdrop compete with its
+ * own content for every click — it wins outright when it sits above in the
+ * paint order (`getElementByPoint` keeps the topmost hit), and it fills every
+ * gap when it sits below (the interior of an unfilled shape, the space beside a
+ * small node). Both were reported from the same recette (issue #194).
+ *
+ * So the band IS the affordance: within `hitThreshold` screen pixels of the
+ * (rotated) outline, and nowhere else. The threshold is divided by the zoom for
+ * the reason every shape divides it — a border band has to stay the same width
+ * under the pointer whatever the viewport is doing.
+ *
+ * ## The interior still answers "is the pointer on this element"
+ *
+ * `ignoreTransparent: false` is the existing way a caller says it is asking
+ * about the element's visible EXTENT rather than about what a click would pick
+ * — an unfilled shape answers the same two ways for the same reason
+ * (`rect.includesPoint`). Exactly two callers pass it: the default tool, which
+ * uses it to decide whether a press on an ALREADY-SELECTED element starts a
+ * move, and the connector manager, which never sees a background at all
+ * (`connectable` is false). So a selected background keeps being dragged from
+ * anywhere inside it, and only picking changed.
+ *
+ * ## What did NOT change
+ *
+ * `containsBound` / `intersectsBound` (the lasso), `getNearestPoint` and
+ * `getLineIntersections` are untouched: a rubber band that had to graze the
+ * outline would be a second regression dressed as a fix.
+ */
+export declare function backgroundIncludesPoint(bounds: IBound, x: number, y: number, options?: PointTestOptions): boolean;

package/dist/_pkgs/affine-model/elements/framework-background/hit-test.js

@@ -0,0 +1,55 @@
+import { getPointsFromBoundWithRotation, pointInPolygon, pointOnPolygonStoke, } from '../../../global/gfx/index.js';
+/**
+ * The width of the band a background is picked by, in SCREEN pixels.
+ *
+ * Ten is what every caller on the picking path already asks for
+ * (`getElementByPoint`, the default tool, the gfx view event handler all pass
+ * `hitThreshold: 10`); naming it here gives the one caller that passes nothing
+ * — the frame manager, which calls `includesPoint(x, y, {})` — the same band
+ * instead of a shape's 1-pixel default.
+ */
+export const BACKGROUND_BORDER_HIT_THRESHOLD = 10;
+/**
+ * Whether a point picks a framework background — THE hit test every background
+ * in the library shares.
+ *
+ * ## A background is picked by its border, not by its area
+ *
+ * A background is a passive canvas: the user drops nodes onto it and works on
+ * THEM. A hit test over the whole rectangle makes the backdrop compete with its
+ * own content for every click — it wins outright when it sits above in the
+ * paint order (`getElementByPoint` keeps the topmost hit), and it fills every
+ * gap when it sits below (the interior of an unfilled shape, the space beside a
+ * small node). Both were reported from the same recette (issue #194).
+ *
+ * So the band IS the affordance: within `hitThreshold` screen pixels of the
+ * (rotated) outline, and nowhere else. The threshold is divided by the zoom for
+ * the reason every shape divides it — a border band has to stay the same width
+ * under the pointer whatever the viewport is doing.
+ *
+ * ## The interior still answers "is the pointer on this element"
+ *
+ * `ignoreTransparent: false` is the existing way a caller says it is asking
+ * about the element's visible EXTENT rather than about what a click would pick
+ * — an unfilled shape answers the same two ways for the same reason
+ * (`rect.includesPoint`). Exactly two callers pass it: the default tool, which
+ * uses it to decide whether a press on an ALREADY-SELECTED element starts a
+ * move, and the connector manager, which never sees a background at all
+ * (`connectable` is false). So a selected background keeps being dragged from
+ * anywhere inside it, and only picking changed.
+ *
+ * ## What did NOT change
+ *
+ * `containsBound` / `intersectsBound` (the lasso), `getNearestPoint` and
+ * `getLineIntersections` are untouched: a rubber band that had to graze the
+ * outline would be a second regression dressed as a fix.
+ */
+export function backgroundIncludesPoint(bounds, x, y, options) {
+    const point = [x, y];
+    const points = getPointsFromBoundWithRotation(bounds);
+    const threshold = (options?.hitThreshold ?? BACKGROUND_BORDER_HIT_THRESHOLD) /
+        (options?.zoom ?? 1);
+    if (pointOnPolygonStoke(point, points, threshold))
+        return true;
+    return options?.ignoreTransparent === false && pointInPolygon(point, points);
+}

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

@@ -1 +1,2 @@
 export * from './background.js';
+export * from './hit-test.js';

package/dist/_pkgs/affine-model/elements/framework-background/index.js

@@ -1 +1,2 @@
 export * from './background.js';
+export * from './hit-test.js';

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

@@ -1,8 +1,11 @@
 import type { EdgelessTextBlockModel } from '../blocks/edgeless-text/edgeless-text-model.js';
 import type { BpmnNodeElementModel, BpmnPoolElementModel } from './bpmn/index.js';
 import type { BrushElementModel } from './brush/index.js';
+import type { C4BoardElementModel, C4BoundaryElementModel, C4NodeElementModel } from './c4/index.js';
 import type { ConnectorElementModel } from './connector/index.js';
+import type { ContextMapBoardElementModel } from './context-map/index.js';
 import type { CoreDomainChartElementModel } from './core-domain/index.js';
+import type { EventStormingBoardElementModel } from './event-storming/index.js';
 import type { EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel } from './edgy/index.js';
 import type { CynefinElementModel } from './cynefin/index.js';
 import type { EstuarineElementModel } from './estuarine/index.js';
@@ -14,11 +17,14 @@ import type { TextElementModel } from './text/index.js';
 import type { WardleyBackgroundElementModel, WardleyNodeElementModel } from './wardley/index.js';
 export * from './bpmn/index.js';
 export * from './brush/index.js';
+export * from './c4/index.js';
 export * from './connector/index.js';
+export * from './context-map/index.js';
 export * from './core-domain/index.js';
 export * from './cynefin/index.js';
 export * from './edgy/index.js';
 export * from './estuarine/index.js';
+export * from './event-storming/index.js';
 export * from './framework-background/index.js';
 export * from './group/index.js';
 export * from './highlighter/index.js';
@@ -30,6 +36,9 @@ export type SurfaceElementModelMap = {
     bpmnNode: BpmnNodeElementModel;
     bpmnPool: BpmnPoolElementModel;
     brush: BrushElementModel;
+    c4Board: C4BoardElementModel;
+    c4Boundary: C4BoundaryElementModel;
+    c4Node: C4NodeElementModel;
     highlighter: HighlighterElementModel;
     connector: ConnectorElementModel;
     group: GroupElementModel;
@@ -44,6 +53,8 @@ export type SurfaceElementModelMap = {
     cynefin: CynefinElementModel;
     estuarine: EstuarineElementModel;
     coreDomain: CoreDomainChartElementModel;
+    contextMap: ContextMapBoardElementModel;
+    eventStorming: EventStormingBoardElementModel;
 };
 export type SurfaceTextModelMap = {
     text: TextElementModel;

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

@@ -1,10 +1,13 @@
 export * from './bpmn/index.js';
 export * from './brush/index.js';
+export * from './c4/index.js';
 export * from './connector/index.js';
+export * from './context-map/index.js';
 export * from './core-domain/index.js';
 export * from './cynefin/index.js';
 export * from './edgy/index.js';
 export * from './estuarine/index.js';
+export * from './event-storming/index.js';
 export * from './framework-background/index.js';
 export * from './group/index.js';
 export * from './highlighter/index.js';

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

@@ -213,14 +213,8 @@ function pointOnBezierGeometry(element, px, py, hitThreshold) {
             const mt2 = mt * mt;
             const t2 = t * t;
             // Cubic Bezier: B(t) = (1-t)^3*P0 + 3(1-t)^2*t*P1 + 3(1-t)*t^2*P2 + t^3*P3
-            const bx = mt2 * mt * cx +
-                3 * mt2 * t * cp1x +
-                3 * mt * t2 * cp2x +
-                t2 * t * nx;
-            const by = mt2 * mt * cy +
-                3 * mt2 * t * cp1y +
-                3 * mt * t2 * cp2y +
-                t2 * t * ny;
+            const bx = mt2 * mt * cx + 3 * mt2 * t * cp1x + 3 * mt * t2 * cp2x + t2 * t * nx;
+            const by = mt2 * mt * cy + 3 * mt2 * t * cp1y + 3 * mt * t2 * cp2y + t2 * t * ny;
             const dbx = px - bx;
             const dby = py - by;
             if (dbx * dbx + dby * dby <= hitDistSq)

package/dist/_pkgs/affine-shared/adapters/html/block-adapter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 export const BlockHtmlAdapterMatcherIdentifier = createIdentifier('BlockHtmlAdapterMatcher');
 export function BlockHtmlAdapterExtension(matcher) {
     const identifier = BlockHtmlAdapterMatcherIdentifier(matcher.flavour);

package/dist/_pkgs/affine-shared/adapters/markdown/block-adapter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 export const BlockMarkdownAdapterMatcherIdentifier = createIdentifier('BlockMarkdownAdapterMatcher');
 export function BlockMarkdownAdapterExtension(matcher) {
     const identifier = BlockMarkdownAdapterMatcherIdentifier(matcher.flavour);

package/dist/_pkgs/affine-shared/adapters/markdown/delta-converter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 import rehypeParse from 'rehype-parse';
 import { unified } from 'unified';
 import { rehypeInlineToBlock, rehypeWrapInlineElements, } from '../html/rehype-plugins/index.js';

package/dist/_pkgs/affine-shared/adapters/notion-html/block-adapter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 export const BlockNotionHtmlAdapterMatcherIdentifier = createIdentifier('BlockNotionHtmlAdapterMatcher');
 export function BlockNotionHtmlAdapterExtension(matcher) {
     const identifier = BlockNotionHtmlAdapterMatcherIdentifier(matcher.flavour);

package/dist/_pkgs/affine-shared/adapters/notion-html/delta-converter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 import isEqual from 'lodash-es/isEqual.js';
 import { DeltaASTConverter, } from '../types/delta-converter.js';
 export const NotionHtmlASTToDeltaMatcherIdentifier = createIdentifier('NotionHtmlASTToDeltaMatcher');

package/dist/_pkgs/affine-shared/adapters/plain-text/block-adapter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 export const BlockPlainTextAdapterMatcherIdentifier = createIdentifier('BlockPlainTextAdapterMatcher');
 export function BlockPlainTextAdapterExtension(matcher) {
     const identifier = BlockPlainTextAdapterMatcherIdentifier(matcher.flavour);

package/dist/_pkgs/affine-shared/adapters/plain-text/delta-converter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 import { DeltaASTConverter, } from '../types/delta-converter.js';
 export const InlineDeltaToPlainTextAdapterMatcherIdentifier = createIdentifier('InlineDeltaToPlainTextAdapterMatcher');
 export function InlineDeltaToPlainTextAdapterExtension(matcher) {

package/dist/_pkgs/affine-shared/adapters/utils/color.js

@@ -56,7 +56,9 @@ const parseHex = (value) => {
     const hex = value.slice(1);
     if (!/^[0-9a-f]+$/i.test(hex))
         return null;
-    const expand = (part) => part.length === 1 ? Number.parseInt(part + part, 16) : Number.parseInt(part, 16);
+    const expand = (part) => part.length === 1
+        ? Number.parseInt(part + part, 16)
+        : Number.parseInt(part, 16);
     const size = hex.length === 3 || hex.length === 4 ? 1 : 2;
     if (hex.length !== size * 3 && hex.length !== size * 4)
         return null;
@@ -234,7 +236,8 @@ export const resolveNearestSupportedColor = (color) => {
     const target = rgbToOklab(parsed);
     const achromatic = target.chroma < ACHROMATIC_CHROMA_THRESHOLD;
     if (achromatic &&
-        (target.l < DEFAULT_TEXT_LIGHTNESS_MIN || target.l > DEFAULT_TEXT_LIGHTNESS_MAX)) {
+        (target.l < DEFAULT_TEXT_LIGHTNESS_MIN ||
+            target.l > DEFAULT_TEXT_LIGHTNESS_MAX)) {
         return null;
     }
     let nearest;

package/dist/_pkgs/affine-shared/commands/model-crud/draft-selected-models.js

@@ -1,4 +1,4 @@
-import { toDraftModel, } from '../../../store/index.js';
+import { toDraftModel } from '../../../store/index.js';
 export const draftSelectedModelsCommand = (ctx, next) => {
     const models = ctx.selectedModels;
     if (!models) {

package/dist/_pkgs/affine-shared/commands/selection/focus-block-end.js

@@ -1,4 +1,4 @@
-import { TextSelection, } from '../../../std/index.js';
+import { TextSelection } from '../../../std/index.js';
 /**
  * Focus the end of the block
  * @param focusBlock - The block to focus

package/dist/_pkgs/affine-shared/commands/selection/focus-block-start.js

@@ -1,4 +1,4 @@
-import { TextSelection, } from '../../../std/index.js';
+import { TextSelection } from '../../../std/index.js';
 export const focusBlockStart = (ctx, next) => {
     const { focusBlock, std } = ctx;
     if (!focusBlock || !focusBlock.model.text)

package/dist/_pkgs/affine-shared/consts/index.d.ts

@@ -4,6 +4,16 @@ export declare const EDGELESS_BLOCK_CHILD_PADDING = 24;
 export declare const EDGELESS_BLOCK_CHILD_BORDER_WIDTH = 2;
 export declare const PAGE_HEADER_HEIGHT = 53;
 export declare const EMBED_CARD_MIN_WIDTH = 450;
+/**
+ * The smallest a thing you TAP may be, in CSS pixels.
+ *
+ * 44 is the figure both platform guidelines settle on (WCAG 2.2's target-size
+ * criterion asks for 24, which is a floor for a mouse, not a finger). Labre's
+ * boards are worked on a tablet in a workshop as often as on a laptop, so any
+ * list a user picks from — the artefact catalogue's rows are the first — sizes
+ * its rows from here rather than from whatever looked right in a screenshot.
+ */
+export declare const TOUCH_TARGET_MIN_PX = 44;
 export declare const EMBED_CARD_WIDTH: Record<EmbedCardStyle, number>;
 export declare const EMBED_CARD_HEIGHT: Record<EmbedCardStyle, number>;
 export declare const EMBED_BLOCK_FLAVOUR_LIST: readonly ["affine:embed-github", "affine:embed-youtube", "affine:embed-figma", "affine:embed-linked-doc", "affine:embed-synced-doc", "affine:embed-html", "affine:embed-loom"];

package/dist/_pkgs/affine-shared/consts/index.js

@@ -6,6 +6,16 @@ export const EDGELESS_BLOCK_CHILD_BORDER_WIDTH = 2;
 // In AFFiNE, to avoid the option element to be covered by the header, we need to reserve the space for the header
 export const PAGE_HEADER_HEIGHT = 53;
 export const EMBED_CARD_MIN_WIDTH = 450;
+/**
+ * The smallest a thing you TAP may be, in CSS pixels.
+ *
+ * 44 is the figure both platform guidelines settle on (WCAG 2.2's target-size
+ * criterion asks for 24, which is a floor for a mouse, not a finger). Labre's
+ * boards are worked on a tablet in a workshop as often as on a laptop, so any
+ * list a user picks from — the artefact catalogue's rows are the first — sizes
+ * its rows from here rather than from whatever looked right in a screenshot.
+ */
+export const TOUCH_TARGET_MIN_PX = 44;
 export const EMBED_CARD_WIDTH = {
     horizontal: 752,
     horizontalThin: 752,

package/dist/_pkgs/affine-shared/services/artefact-catalogue-service.d.ts

@@ -0,0 +1,55 @@
+import type { CommandOwner } from '../../std/index.js';
+import type { ExtensionType } from '../../store/index.js';
+/**
+ * Consumer 2 of `docs/adr/0008`: the "more artefacts" sidepanel, which shows an
+ * owner's WHOLE `'catalogue'` surface by sub-category once its senior sub-menu
+ * has stopped being able to.
+ *
+ * The seam had to exist before either end of it, because the senior menu is
+ * what opens it — `selectSeniorMenuCommands` reports an overflow, the menu
+ * grows a trailing button, and that button needs somewhere to send the click.
+ * The library now ships the panel that answers by default
+ * (`edgeless-artefact-catalogue-widget`, registered next to the toolbar
+ * widget), and the menu still renders the button only when this provider
+ * answers — so an assembly that overrode the provider away shows no control
+ * that opens nothing.
+ *
+ * The contract is two verbs on purpose. Everything the panel needs to draw
+ * itself is already enumerable from the command registry
+ * (`getCommandsForSurface(std, owner, 'catalogue')`), so the seam carries the
+ * OWNER and nothing else — no list of entries, no open state, no rendering.
+ * That is what lets the two implementations be genuinely different things: the
+ * library's own left sidepanel, and a host's existing right-hand sidebar.
+ */
+export interface ArtefactCatalogueService {
+    /** Show the catalogue, scoped to one framework's artefacts. */
+    open(owner: CommandOwner): void;
+    /** Put it away. Never touches the active senior tool. */
+    close(): void;
+}
+export declare const ArtefactCatalogueProvider: import("../../global/di/types.js").ServiceIdentifier<ArtefactCatalogueService> & (<U extends ArtefactCatalogueService = ArtefactCatalogueService>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
+/**
+ * Host override seam: replace the library's sidepanel with the host's own —
+ * or switch the catalogue off entirely.
+ *
+ * **Replace** — a host that already owns a sidebar (a right-hand inspector, a
+ * docked panel, a mobile sheet) registers this extension, its implementation
+ * answers {@link ArtefactCatalogueProvider}, and the library's widget is then
+ * never asked to open: the sub-menu's "More artefacts…" entry resolves ONE
+ * service, and `di.override` decides which. The host's own UI draws itself
+ * from the registry (`getCommandsForSurface(std, owner, 'catalogue')`,
+ * `getCommandIcon`) and creates through the one bottleneck
+ * (`runCommand(std, command, { surface: 'catalogue', … })`), so telemetry and
+ * the usage measure keep flowing wherever the pixels live.
+ *
+ * **Disable** — pass `null`. The provider then answers nothing, and every
+ * consumer reads that the honest way: the sub-menu's "More artefacts…" button
+ * is not rendered (a control that opens nothing is a lie), and the library's
+ * panel never opens. This is a cold-assembly switch, like the framework flags:
+ * decided when the editor is put together, not toggled mid-session.
+ *
+ * Mirrors `CommandUsageExtension` / `KeymapOverrideExtension`: `di.override`,
+ * so a host registering after the library's own extensions always wins,
+ * whatever the registration order turns out to be.
+ */
+export declare function ArtefactCatalogueExtension(service: ArtefactCatalogueService | null): ExtensionType;

package/dist/_pkgs/affine-shared/services/artefact-catalogue-service.js

@@ -0,0 +1,35 @@
+import { createIdentifier } from '../../global/di/index.js';
+export const ArtefactCatalogueProvider = createIdentifier('AffineArtefactCatalogue');
+/**
+ * Host override seam: replace the library's sidepanel with the host's own —
+ * or switch the catalogue off entirely.
+ *
+ * **Replace** — a host that already owns a sidebar (a right-hand inspector, a
+ * docked panel, a mobile sheet) registers this extension, its implementation
+ * answers {@link ArtefactCatalogueProvider}, and the library's widget is then
+ * never asked to open: the sub-menu's "More artefacts…" entry resolves ONE
+ * service, and `di.override` decides which. The host's own UI draws itself
+ * from the registry (`getCommandsForSurface(std, owner, 'catalogue')`,
+ * `getCommandIcon`) and creates through the one bottleneck
+ * (`runCommand(std, command, { surface: 'catalogue', … })`), so telemetry and
+ * the usage measure keep flowing wherever the pixels live.
+ *
+ * **Disable** — pass `null`. The provider then answers nothing, and every
+ * consumer reads that the honest way: the sub-menu's "More artefacts…" button
+ * is not rendered (a control that opens nothing is a lie), and the library's
+ * panel never opens. This is a cold-assembly switch, like the framework flags:
+ * decided when the editor is put together, not toggled mid-session.
+ *
+ * Mirrors `CommandUsageExtension` / `KeymapOverrideExtension`: `di.override`,
+ * so a host registering after the library's own extensions always wins,
+ * whatever the registration order turns out to be.
+ */
+export function ArtefactCatalogueExtension(service) {
+    return {
+        setup: di => {
+            // `null` rides through the factory on purpose: `getOptional` then
+            // reports the catalogue as absent, which is the whole disable story.
+            di.override(ArtefactCatalogueProvider, () => service);
+        },
+    };
+}

package/dist/_pkgs/affine-shared/services/audit-service.d.ts

@@ -65,6 +65,17 @@ export interface AuditAxisFact {
  */
 export interface AuditZoneFact {
     id: string;
+    /**
+     * The user's own wording, when the zone is one THIS frame declares rather
+     * than one the framework does — a BPMN pool's lanes. Namespaced ids keep the
+     * two apart (`lane:sales` against `product`), and the name is what makes an
+     * instance zone worth reporting at all: `lane:2` says nothing to an assistant,
+     * "Facturation" says what the band is for.
+     *
+     * Absent on every framework zone, whose meaning is the framework's and whose
+     * wording is the host's to translate.
+     */
+    name?: string;
     rect: {
         x: number;
         y: number;

package/dist/_pkgs/affine-shared/services/command-usage-service.d.ts

@@ -0,0 +1,31 @@
+import { type CommandUsageStore } from '../../std/index.js';
+import type { ExtensionType } from '../../store/index.js';
+/**
+ * Where `createLocalCommandUsageStore` persists. Namespaced like the rest of
+ * Labre's browser-local state, and versionless on purpose: the shape is two
+ * numbers per command, and a reader that does not recognise an entry drops it.
+ */
+export declare const COMMAND_USAGE_KEY = "labre:command-usage";
+/**
+ * The default {@link CommandUsageStore}: recency and frequency in this
+ * browser's `localStorage`, per command id.
+ *
+ * It measures only. Nothing ranks anything here — PF6's "seven most-recent +
+ * six most-used" sub-menu reads these numbers, and a host that
+ * wants the measure to follow the user across devices replaces the whole store
+ * through {@link CommandUsageExtension}.
+ */
+export declare function createLocalCommandUsageStore(): CommandUsageStore;
+/**
+ * Host override seam: replace the browser-local measure with the host's own.
+ *
+ * This is where a host persists command usage in ITS database — so the ranking
+ * follows the user from laptop to browser to tablet instead of restarting at
+ * zero, which is exactly what a "most-used" sub-menu is judged on. The library
+ * ships the local store as the default (`CommandUsageViewExtension`) and never
+ * requires a host to care.
+ *
+ * Mirrors `EditorSettingExtension` / `KeymapOverrideExtension`: `di.override`,
+ * so a host registering after the library's own extensions always wins.
+ */
+export declare function CommandUsageExtension(store: CommandUsageStore): ExtensionType;