@formicoidea/labre-core 0.32.0 → 0.33.0

package/dist/_pkgs/affine-model/elements/core-domain/core-domain.js

@@ -32,21 +32,27 @@ 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 { field } from '../../../std/gfx/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
 /**
  * The Core Domain Chart background (DDD Crew): the two axes (Complexity ×
  * Business differentiation) with their Low/High ticks and the translucent
  * Generic / Supporting / Core zone bands. The user places sub-domain dots,
  * movement arrows and the Notation legend on top of it.
  *
- * Mirrors the Wardley / EDGY / Cynefin backgrounds: extends
- * {@link GfxPrimitiveElementModel} so it inherits selection, move, copy/paste,
- * duplicate, align and undo/redo. Authored in a fixed reference space and scaled
- * uniformly to the element bounds by the renderer.
+ * An INSTANCE of the framework-background primitive
+ * ({@link FrameworkBackgroundElementModel}): the geometry and the passive-canvas
+ * behaviour come from the primitive — which declares the very same
+ * `connectable` getter and the very same four geometry overrides this class
+ * used to spell out — and what the chart LOOKS like comes from the
+ * `CORE_DOMAIN_BACKGROUND` declaration in `@labre/affine-gfx-ddd-core-domain`.
+ *
+ * The fields below are the persisted document and are NOT the primitive's
+ * business: the base swap adds no field, renames none and changes no default,
+ * so a chart authored before it is byte-identical to one authored after.
  */
 let CoreDomainChartElementModel = (() => {
-    let _classSuper = GfxPrimitiveElementModel;
+    let _classSuper = FrameworkBackgroundElementModel;
     let _resizeEnabled_decorators;
     let _resizeEnabled_initializers = [];
     let _resizeEnabled_extraInitializers = [];
@@ -56,6 +62,9 @@ let CoreDomainChartElementModel = (() => {
     let _showLabels_decorators;
     let _showLabels_initializers = [];
     let _showLabels_extraInitializers = [];
+    let _variant_decorators;
+    let _variant_initializers = [];
+    let _variant_extraInitializers = [];
     let _rotate_decorators;
     let _rotate_initializers = [];
     let _rotate_extraInitializers = [];
@@ -68,11 +77,13 @@ let CoreDomainChartElementModel = (() => {
             _resizeEnabled_decorators = [field(true)];
             _showZones_decorators = [field(true)];
             _showLabels_decorators = [field(true)];
+            _variant_decorators = [field('classic')];
             _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, _showZones_decorators, { kind: "accessor", name: "showZones", static: false, private: false, access: { has: obj => "showZones" in obj, get: obj => obj.showZones, set: (obj, value) => { obj.showZones = value; } }, metadata: _metadata }, _showZones_initializers, _showZones_extraInitializers);
             __esDecorate(this, null, _showLabels_decorators, { kind: "accessor", name: "showLabels", static: false, private: false, access: { has: obj => "showLabels" in obj, get: obj => obj.showLabels, set: (obj, value) => { obj.showLabels = value; } }, metadata: _metadata }, _showLabels_initializers, _showLabels_extraInitializers);
+            __esDecorate(this, null, _variant_decorators, { kind: "accessor", name: "variant", static: false, private: false, access: { has: obj => "variant" in obj, get: obj => obj.variant, set: (obj, value) => { obj.variant = value; } }, metadata: _metadata }, _variant_initializers, _variant_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 });
@@ -80,24 +91,6 @@ let CoreDomainChartElementModel = (() => {
         get type() {
             return 'coreDomain';
         }
-        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);
-        }
         #resizeEnabled_accessor_storage = __runInitializers(this, _resizeEnabled_initializers, true);
         get resizeEnabled() { return this.#resizeEnabled_accessor_storage; }
         set resizeEnabled(value) { this.#resizeEnabled_accessor_storage = value; }
@@ -107,7 +100,16 @@ let CoreDomainChartElementModel = (() => {
         #showLabels_accessor_storage = (__runInitializers(this, _showZones_extraInitializers), __runInitializers(this, _showLabels_initializers, true));
         get showLabels() { return this.#showLabels_accessor_storage; }
         set showLabels(value) { this.#showLabels_accessor_storage = value; }
-        #rotate_accessor_storage = (__runInitializers(this, _showLabels_extraInitializers), __runInitializers(this, _rotate_initializers, 0));
+        #variant_accessor_storage = (__runInitializers(this, _showLabels_extraInitializers), __runInitializers(this, _variant_initializers, 'classic'));
+        /**
+         * A HARD default, on the Wardley `variant` pattern: `classic` is written into
+         * the Y.Map at creation and is also what an older chart — which carries no
+         * such key at all — reads back as. Both roads lead to the chart the user has
+         * always seen, so the field ships with no migration and no backfill.
+         */
+        get variant() { return this.#variant_accessor_storage; }
+        set variant(value) { this.#variant_accessor_storage = value; }
+        #rotate_accessor_storage = (__runInitializers(this, _variant_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,900,820]'));

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

@@ -0,0 +1,36 @@
+import type { SerializedXYWH } from '../../../global/gfx/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+import type { FrameworkBackgroundProps } from '../framework-background/index.js';
+export type EventStormingBoardProps = FrameworkBackgroundProps;
+/**
+ * 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.
+ */
+export declare class EventStormingBoardElementModel extends FrameworkBackgroundElementModel<EventStormingBoardProps> {
+    get type(): string;
+    accessor resizeEnabled: boolean;
+    accessor rotate: number;
+    accessor xywh: SerializedXYWH;
+}

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/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;