@formicoidea/labre-core 0.41.0 → 0.42.0

package/dist/_pkgs/affine-model/elements/uml/region.js

@@ -0,0 +1,150 @@
+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';
+import { umlInNameBand } from './band.js';
+/**
+ * Height of a region's NAME BAND — the strip its name is written in, in model
+ * units.
+ *
+ * Owned by the model for the reason {@link UML_PARTITION_BAND} is: the region's
+ * own hit test reads it, and `affine-model` cannot reach into the package where
+ * the declaration is resolved. The same 36 the partition uses, and deliberately
+ * so — the two are the same piece of furniture, a name written in a strip along
+ * the top of a transparent frame, and two numbers would drift.
+ */
+export const UML_REGION_BAND = 36;
+/**
+ * A COMPOSITE STATE — the region of UML 2.5.1 §14.2.4: the rounded rectangle
+ * drawn round the sub-states of a state that has its own state machine inside
+ * it.
+ *
+ * A framework background, transparent like {@link UmlPartitionElementModel}: it
+ * is drawn OVER states that are already there, and membership is geometry at
+ * read time (R11).
+ *
+ * ## Why a composite state IS the region, rather than a state with regions in it
+ *
+ * The metamodel has two objects — a State that `isComposite`, and the Regions it
+ * owns — and the notation draws ONE: a rounded rectangle with the state's name
+ * at the top and the sub-machine inside (§14.2.4, Figure 14.6). A drawing tool
+ * that made the author place a `state` node and then a `umlRegion` inside it
+ * would be asking them to draw two things to get one picture, and would leave
+ * every rule with two elements to decide which of them the composite state is.
+ *
+ * So this element IS the composite state: it carries the name, it draws the
+ * rounded rectangle, and its sub-states sit inside it by geometry.
+ *
+ * ## The ceiling, stated out loud
+ *
+ * ORTHOGONAL regions — a composite state cut into concurrent regions by dashed
+ * separators (§14.2.4, Figure 14.8) — are NOT drawn. One region per composite
+ * state is what this element is; a second one is a phase-3 refinement, and it
+ * will arrive the way the BPMN pool's lanes did (an instance partition on the
+ * declaration) rather than as a field added here in a hurry.
+ *
+ * What it LOOKS like is declared, not coded: see `UML_REGION_FRAME` in
+ * `@labre/affine-gfx-uml`.
+ */
+let UmlRegionElementModel = (() => {
+    let _classSuper = FrameworkBackgroundElementModel;
+    let _name_decorators;
+    let _name_initializers = [];
+    let _name_extraInitializers = [];
+    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 UmlRegionElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _name_decorators = [field('State')];
+            _resizeEnabled_decorators = [field(true)];
+            _rotate_decorators = [field(0)];
+            _xywh_decorators = [field()];
+            __esDecorate(this, null, _name_decorators, { kind: "accessor", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
+            __esDecorate(this, null, _resizeEnabled_decorators, { kind: "accessor", name: "resizeEnabled", static: false, private: false, access: { has: obj => "resizeEnabled" in obj, get: obj => obj.resizeEnabled, set: (obj, value) => { obj.resizeEnabled = value; } }, metadata: _metadata }, _resizeEnabled_initializers, _resizeEnabled_extraInitializers);
+            __esDecorate(this, null, _rotate_decorators, { kind: "accessor", name: "rotate", static: false, private: false, access: { has: obj => "rotate" in obj, get: obj => obj.rotate, set: (obj, value) => { obj.rotate = value; } }, metadata: _metadata }, _rotate_initializers, _rotate_extraInitializers);
+            __esDecorate(this, null, _xywh_decorators, { kind: "accessor", name: "xywh", static: false, private: false, access: { has: obj => "xywh" in obj, get: obj => obj.xywh, set: (obj, value) => { obj.xywh = value; } }, metadata: _metadata }, _xywh_initializers, _xywh_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'umlRegion';
+        }
+        #name_accessor_storage = __runInitializers(this, _name_initializers, 'State');
+        /**
+         * `State`, not `Region`: this element IS the composite state on the page, and
+         * a fresh one that called itself a Region would be naming the metamodel
+         * object rather than the thing the author drew (see the header).
+         */
+        get name() { return this.#name_accessor_storage; }
+        set name(value) { this.#name_accessor_storage = value; }
+        #resizeEnabled_accessor_storage = (__runInitializers(this, _name_extraInitializers), __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,520,320]'));
+        /** Room for a small sub-machine — an initial, two states and a final. */
+        get xywh() { return this.#xywh_accessor_storage; }
+        set xywh(value) { this.#xywh_accessor_storage = value; }
+        /**
+         * Picked by its BORDER and by its NAME BAND — the carve-out the diagram frame
+         * and the partition both make, and for the same reason: the band is the only
+         * part of the composite state that is the STATE rather than the sub-machine
+         * drawn inside it.
+         *
+         * Always the TOP edge: unlike a partition, a composite state has no
+         * orientation to turn — §14.2.4 writes its name across the top and nowhere
+         * else.
+         */
+        includesPoint(x, y, options) {
+            if (super.includesPoint(x, y, options))
+                return true;
+            return umlInNameBand(this, 'top', UML_REGION_BAND, x, y);
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _xywh_extraInitializers);
+        }
+    };
+})();
+export { UmlRegionElementModel };

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

@@ -0,0 +1,37 @@
+import type { SerializedXYWH } from '../../../global/gfx/index.js';
+import type { FrameworkBackgroundProps } from '../framework-background/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+export type UmlSubjectProps = FrameworkBackgroundProps & {
+    /** The subject name, written top-left — edited inline on dblclick. */
+    name?: string;
+};
+/**
+ * A UML use case SUBJECT: the system boundary of UML 2.5.1 §18.1.4 — the plain
+ * rectangle drawn around the use cases a system offers, with its name written
+ * top-left and the actors left outside it.
+ *
+ * A framework background, so use cases are dropped on it and connectors never
+ * snap to it — but a TRANSPARENT one, like {@link C4BoundaryElementModel} and
+ * for the same reason: a subject is drawn over the diagram frame it sits on,
+ * and an opaque card would hide the use cases it encloses. Containment is
+ * visual only; membership, as for every board in the library, is computed from
+ * geometry at read time (R11).
+ *
+ * ## Why no variant, and no compartments
+ *
+ * The notation gives it none. §18.1.4 draws one rectangle with one name — there
+ * is no dashed flavour, no keyword line and no second tier — so, unlike a C4
+ * boundary (which draws system and container identically and tells them apart
+ * by the label), there is nothing here for a discriminant to discriminate. A
+ * field with one possible value is a field that can only ever go stale.
+ *
+ * What it LOOKS like is declared, not coded: see `UML_SUBJECT_BACKGROUND` in
+ * `@labre/affine-gfx-uml`.
+ */
+export declare class UmlSubjectElementModel extends FrameworkBackgroundElementModel<UmlSubjectProps> {
+    get type(): string;
+    accessor name: string;
+    accessor resizeEnabled: boolean;
+    accessor rotate: number;
+    accessor xywh: SerializedXYWH;
+}

package/dist/_pkgs/affine-model/elements/uml/subject.js

@@ -0,0 +1,108 @@
+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';
+/**
+ * A UML use case SUBJECT: the system boundary of UML 2.5.1 §18.1.4 — the plain
+ * rectangle drawn around the use cases a system offers, with its name written
+ * top-left and the actors left outside it.
+ *
+ * A framework background, so use cases are dropped on it and connectors never
+ * snap to it — but a TRANSPARENT one, like {@link C4BoundaryElementModel} and
+ * for the same reason: a subject is drawn over the diagram frame it sits on,
+ * and an opaque card would hide the use cases it encloses. Containment is
+ * visual only; membership, as for every board in the library, is computed from
+ * geometry at read time (R11).
+ *
+ * ## Why no variant, and no compartments
+ *
+ * The notation gives it none. §18.1.4 draws one rectangle with one name — there
+ * is no dashed flavour, no keyword line and no second tier — so, unlike a C4
+ * boundary (which draws system and container identically and tells them apart
+ * by the label), there is nothing here for a discriminant to discriminate. A
+ * field with one possible value is a field that can only ever go stale.
+ *
+ * What it LOOKS like is declared, not coded: see `UML_SUBJECT_BACKGROUND` in
+ * `@labre/affine-gfx-uml`.
+ */
+let UmlSubjectElementModel = (() => {
+    let _classSuper = FrameworkBackgroundElementModel;
+    let _name_decorators;
+    let _name_initializers = [];
+    let _name_extraInitializers = [];
+    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 UmlSubjectElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _name_decorators = [field('Subject')];
+            _resizeEnabled_decorators = [field(true)];
+            _rotate_decorators = [field(0)];
+            _xywh_decorators = [field()];
+            __esDecorate(this, null, _name_decorators, { kind: "accessor", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
+            __esDecorate(this, null, _resizeEnabled_decorators, { kind: "accessor", name: "resizeEnabled", static: false, private: false, access: { has: obj => "resizeEnabled" in obj, get: obj => obj.resizeEnabled, set: (obj, value) => { obj.resizeEnabled = value; } }, metadata: _metadata }, _resizeEnabled_initializers, _resizeEnabled_extraInitializers);
+            __esDecorate(this, null, _rotate_decorators, { kind: "accessor", name: "rotate", static: false, private: false, access: { has: obj => "rotate" in obj, get: obj => obj.rotate, set: (obj, value) => { obj.rotate = value; } }, metadata: _metadata }, _rotate_initializers, _rotate_extraInitializers);
+            __esDecorate(this, null, _xywh_decorators, { kind: "accessor", name: "xywh", static: false, private: false, access: { has: obj => "xywh" in obj, get: obj => obj.xywh, set: (obj, value) => { obj.xywh = value; } }, metadata: _metadata }, _xywh_initializers, _xywh_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'umlSubject';
+        }
+        #name_accessor_storage = __runInitializers(this, _name_initializers, 'Subject');
+        get name() { return this.#name_accessor_storage; }
+        set name(value) { this.#name_accessor_storage = value; }
+        #resizeEnabled_accessor_storage = (__runInitializers(this, _name_extraInitializers), __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,520,360]'));
+        get xywh() { return this.#xywh_accessor_storage; }
+        set xywh(value) { this.#xywh_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _xywh_extraInitializers);
+        }
+    };
+})();
+export { UmlSubjectElementModel };

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

@@ -138,7 +138,7 @@ let WardleyBackgroundElementModel = (() => {
             _showCornerLabels_decorators = [field(true)];
             _showVisibilityLabels_decorators = [field(true)];
             _rotate_decorators = [field(0)];
-            _xywh_decorators = [field()];
+            _xywh_decorators = [field('[0,0,0,0]')];
             __esDecorate(this, null, _banded_decorators, { kind: "accessor", name: "banded", static: false, private: false, access: { has: obj => "banded" in obj, get: obj => obj.banded, set: (obj, value) => { obj.banded = value; } }, metadata: _metadata }, _banded_initializers, _banded_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, _showGradient_decorators, { kind: "accessor", name: "showGradient", static: false, private: false, access: { has: obj => "showGradient" in obj, get: obj => obj.showGradient, set: (obj, value) => { obj.showGradient = value; } }, metadata: _metadata }, _showGradient_initializers, _showGradient_extraInitializers);

package/dist/_pkgs/affine-shared/services/embed-iframe/embed-iframe-config.d.ts

@@ -23,6 +23,7 @@ export type IframeOptions = {
     allow?: string;
     allowFullscreen?: boolean;
     containerBorderRadius?: number;
+    sandbox?: string;
 };
 /**
  * Define the config of an embed iframe block

package/dist/_pkgs/affine-shared/services/font-loader/config.d.ts

@@ -16,5 +16,12 @@ export declare const fontConfigSchema: z.ZodObject<{
     weight: string;
 }>;
 export type FontConfig = z.infer<typeof fontConfigSchema>;
+/**
+ * The AFFiNE-hosted mirror. It carries strictly fewer files than the community
+ * list: `cdn.affine.pro` answers 404 for every `Inter-Bold`, `Poppins-Bold`
+ * and `BebasNeue-Bold` spelling, so those three families offer no 700 weight
+ * here. The Kalam / Satoshi / Lora `SemiBold` entries below already point at
+ * the 700 file — those families ship a single heavy face, not two.
+ */
 export declare const AffineCanvasTextFonts: FontConfig[];
 export declare const CommunityCanvasTextFonts: FontConfig[];

package/dist/_pkgs/affine-shared/services/font-loader/config.js

@@ -6,6 +6,13 @@ export const fontConfigSchema = z.object({
     url: z.string(),
     style: z.string(),
 });
+/**
+ * The AFFiNE-hosted mirror. It carries strictly fewer files than the community
+ * list: `cdn.affine.pro` answers 404 for every `Inter-Bold`, `Poppins-Bold`
+ * and `BebasNeue-Bold` spelling, so those three families offer no 700 weight
+ * here. The Kalam / Satoshi / Lora `SemiBold` entries below already point at
+ * the 700 file — those families ship a single heavy face, not two.
+ */
 export const AffineCanvasTextFonts = [
     // Inter, https://fonts.cdnfonts.com/css/inter?styles=29139,29134,29135,29136,29140,29141
     {
@@ -221,13 +228,27 @@ export const CommunityCanvasTextFonts = [
         weight: FontWeight.Regular,
         style: FontStyle.Italic,
     },
+    {
+        font: FontFamily.Inter,
+        url: 'https://fonts.cdnfonts.com/s/19795/Inter-Bold.woff',
+        weight: FontWeight.Bold,
+        style: FontStyle.Normal,
+    },
     {
         font: FontFamily.Inter,
         url: 'https://fonts.cdnfonts.com/s/19795/Inter-SemiBoldItalic.woff',
         weight: FontWeight.SemiBold,
         style: FontStyle.Italic,
     },
+    {
+        font: FontFamily.Inter,
+        url: 'https://fonts.cdnfonts.com/s/19795/Inter-BoldItalic.woff',
+        weight: FontWeight.Bold,
+        style: FontStyle.Italic,
+    },
     // Kalam, https://fonts.cdnfonts.com/css/kalam?styles=15166,170689,170687
+    // Kalam ships no 600 face: its `SemiBold` entry below already IS the 700
+    // file, so the family offers one heavy weight, not two.
     {
         font: FontFamily.Kalam,
         url: 'https://fonts.cdnfonts.com/s/13130/Kalam-Light.woff',
@@ -308,6 +329,12 @@ export const CommunityCanvasTextFonts = [
         weight: FontWeight.SemiBold,
         style: FontStyle.Normal,
     },
+    {
+        font: FontFamily.Poppins,
+        url: 'https://fonts.cdnfonts.com/s/16009/Poppins-Bold.woff',
+        weight: FontWeight.Bold,
+        style: FontStyle.Normal,
+    },
     {
         font: FontFamily.Poppins,
         url: 'https://fonts.cdnfonts.com/s/16009/Poppins-LightItalic.woff',
@@ -326,7 +353,15 @@ export const CommunityCanvasTextFonts = [
         weight: FontWeight.SemiBold,
         style: FontStyle.Italic,
     },
+    {
+        font: FontFamily.Poppins,
+        url: 'https://fonts.cdnfonts.com/s/16009/Poppins-BoldItalic.woff',
+        weight: FontWeight.Bold,
+        style: FontStyle.Italic,
+    },
     // Lora, https://fonts.cdnfonts.com/css/lora-4?styles=50357,50356,50354,50355
+    // Lora ships no 600 face either: as with Kalam and Satoshi, the entries
+    // below map the 700 file onto `SemiBold` and the family has a single heavy.
     {
         font: FontFamily.Lora,
         url: 'https://fonts.cdnfonts.com/s/29883/Lora-Regular.woff',
@@ -364,6 +399,14 @@ export const CommunityCanvasTextFonts = [
         weight: FontWeight.Regular,
         style: FontStyle.Normal,
     },
+    {
+        font: FontFamily.BebasNeue,
+        // The bold face is the one Bebas Neue file whose name is spelled with a
+        // space, like the light one above and unlike the regular one.
+        url: 'https://fonts.cdnfonts.com/s/14902/BebasNeue%20Bold.woff',
+        weight: FontWeight.Bold,
+        style: FontStyle.Normal,
+    },
     // OrelegaOne, https://fonts.cdnfonts.com/css/orelega-one?styles=148618
     {
         font: FontFamily.OrelegaOne,

package/dist/_pkgs/affine-shared/services/pivot-materiality-publisher.js

@@ -42,8 +42,7 @@
  * materiality by scanning `collectPivotOccurrences`. Derived materialities are
  * a cache of the boards, never a second original.
  */
-import { LifeCycleWatcher } from '../../std/index.js';
-import { FRAMEWORK_IDS } from '../../std/index.js';
+import { frameworkOfRole, LifeCycleWatcher } from '../../std/index.js';
 import { GfxControllerIdentifier, isPivotBound, readElementTags, } from '../../std/gfx/index.js';
 import { effect } from '@preact/signals-core';
 import { PivotPropertiesProvider, publishOccurrenceMaterialities, } from './pivot-properties-service.js';
@@ -51,13 +50,6 @@ import { PivotPropertiesProvider, publishOccurrenceMaterialities, } from './pivo
 const MATERIAL_PROPS = new Set(['tags', 'role', 'pivotDocId']);
 const touchesMateriality = (payload) => Object.keys(payload.props).some(key => MATERIAL_PROPS.has(key)) ||
     Object.keys(payload.oldValues).some(key => MATERIAL_PROPS.has(key));
-/** `'wardley:component'` → `'wardley'`, when that names a real framework. */
-function frameworkOfRole(role) {
-    const namespace = role?.split(':')[0];
-    return FRAMEWORK_IDS.includes(namespace ?? '')
-        ? namespace
-        : undefined;
-}
 /**
  * `(pivotDocId, elementId)` — the host's primary key for a derived materiality.
  *

package/dist/_pkgs/affine-shared/services/telemetry-service/document-damage-watcher.d.ts

@@ -0,0 +1,53 @@
+import { LifeCycleWatcher } from '../../../std/index.js';
+import type { SurfaceElementDamage, SurfaceElementDamageReport } from '../../../std/gfx/index.js';
+/**
+ * The whole surface API this watcher touches, named structurally on purpose:
+ * it is also the entire harness a unit spec has to stand up, and it keeps the
+ * watcher from caring which block flavour grew a `damagedElements` map next.
+ */
+export type DamageReportingSurface = {
+    readonly damagedElements: ReadonlyMap<string, SurfaceElementDamage>;
+    readonly elementDamaged: {
+        subscribe(next: (report: SurfaceElementDamageReport) => void): {
+            unsubscribe(): void;
+        };
+    };
+};
+export declare function isDamageReportingSurface(model: unknown): model is DamageReportingSurface;
+/**
+ * Reports `DocumentDamaged` — how many documents open carrying elements the
+ * editor cannot draw (#318, follow-up of #321).
+ *
+ * **Why a state read and not only a subscription.** The surface builds its
+ * element models when the block model is created, well before any view or
+ * `LifeCycleWatcher` is mounted, so every element the document OPENED with is
+ * already damaged by the time this watcher exists. It therefore reads
+ * `surface.damagedElements` once at mount for the opening batch, and only then
+ * subscribes for what a remote sync delivers afterwards.
+ *
+ * **One event per batch, elements deduplicated for the watcher's lifetime.**
+ * A sync can deliver several damaged elements in one go; sending one event per
+ * element would make "how many damaged documents" unreadable, and re-sending an
+ * id already counted would make it wrong. Later arrivals are therefore
+ * aggregated in a microtask and filtered against what was already reported.
+ *
+ * `page` is left unset here for the reason `BlockLifecycleTelemetryWatcher`
+ * leaves it unset: this is store plumbing, it has no editor mode to state, and
+ * a damaged document is damaged in either one.
+ *
+ * Inert when no `TelemetryService` is injected.
+ */
+export declare class DocumentDamageTelemetryWatcher extends LifeCycleWatcher {
+    static readonly key = "document-damage-telemetry";
+    /** Ids already counted, so a document never counts an element twice. */
+    private readonly _counted;
+    private readonly _pending;
+    private _flushScheduled;
+    private _stopped;
+    private _subscriptions;
+    private _telemetry?;
+    mounted(): void;
+    unmounted(): void;
+    private _schedule;
+    private _flush;
+}

package/dist/_pkgs/affine-shared/services/telemetry-service/document-damage-watcher.js

@@ -0,0 +1,95 @@
+import { LifeCycleWatcher } from '../../../std/index.js';
+import { TelemetryProvider, } from './telemetry-service.js';
+export function isDamageReportingSurface(model) {
+    const candidate = model;
+    return (!!candidate &&
+        candidate.damagedElements instanceof Map &&
+        typeof candidate.elementDamaged?.subscribe === 'function');
+}
+/**
+ * Reports `DocumentDamaged` — how many documents open carrying elements the
+ * editor cannot draw (#318, follow-up of #321).
+ *
+ * **Why a state read and not only a subscription.** The surface builds its
+ * element models when the block model is created, well before any view or
+ * `LifeCycleWatcher` is mounted, so every element the document OPENED with is
+ * already damaged by the time this watcher exists. It therefore reads
+ * `surface.damagedElements` once at mount for the opening batch, and only then
+ * subscribes for what a remote sync delivers afterwards.
+ *
+ * **One event per batch, elements deduplicated for the watcher's lifetime.**
+ * A sync can deliver several damaged elements in one go; sending one event per
+ * element would make "how many damaged documents" unreadable, and re-sending an
+ * id already counted would make it wrong. Later arrivals are therefore
+ * aggregated in a microtask and filtered against what was already reported.
+ *
+ * `page` is left unset here for the reason `BlockLifecycleTelemetryWatcher`
+ * leaves it unset: this is store plumbing, it has no editor mode to state, and
+ * a damaged document is damaged in either one.
+ *
+ * Inert when no `TelemetryService` is injected.
+ */
+export class DocumentDamageTelemetryWatcher extends LifeCycleWatcher {
+    constructor() {
+        super(...arguments);
+        /** Ids already counted, so a document never counts an element twice. */
+        this._counted = new Set();
+        this._pending = new Set();
+        this._flushScheduled = false;
+        this._stopped = false;
+        this._subscriptions = [];
+    }
+    static { this.key = 'document-damage-telemetry'; }
+    mounted() {
+        const telemetry = this.std.getOptional(TelemetryProvider);
+        if (!telemetry)
+            return;
+        this._telemetry = telemetry;
+        // Structural, not `instanceof SurfaceBlockModel`: the watcher needs two
+        // members, not a class, and the guard is what states that.
+        const surfaces = this.std.store.getModelsByFlavour('affine:surface').filter(isDamageReportingSurface);
+        for (const surface of surfaces) {
+            for (const id of surface.damagedElements.keys())
+                this._pending.add(id);
+            this._subscriptions.push(surface.elementDamaged.subscribe(({ id }) => {
+                this._pending.add(id);
+                this._schedule();
+            }));
+        }
+        // The opening batch, synchronously: it is complete already, and nothing
+        // gained by making the host wait a tick for the number it opened with.
+        this._flush();
+    }
+    unmounted() {
+        this._stopped = true;
+        for (const subscription of this._subscriptions)
+            subscription.unsubscribe();
+        this._subscriptions = [];
+        this._pending.clear();
+        this._counted.clear();
+        this._telemetry = undefined;
+        super.unmounted();
+    }
+    _schedule() {
+        if (this._flushScheduled)
+            return;
+        this._flushScheduled = true;
+        queueMicrotask(() => {
+            this._flushScheduled = false;
+            if (!this._stopped)
+                this._flush();
+        });
+    }
+    _flush() {
+        const fresh = [...this._pending].filter(id => !this._counted.has(id));
+        this._pending.clear();
+        if (fresh.length === 0)
+            return;
+        for (const id of fresh)
+            this._counted.add(id);
+        this._telemetry?.track('DocumentDamaged', {
+            reason: 'missing-xywh',
+            elementCount: fresh.length,
+        });
+    }
+}

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

@@ -1,6 +1,7 @@
 export * from './block-lifecycle-watcher.js';
 export * from './citation.js';
 export * from './database.js';
+export * from './document-damage-watcher.js';
 export * from './lifecycle.js';
 export * from './link.js';
 export * from './noop.js';

package/dist/_pkgs/affine-shared/services/telemetry-service/index.js

@@ -1,6 +1,7 @@
 export * from './block-lifecycle-watcher.js';
 export * from './citation.js';
 export * from './database.js';
+export * from './document-damage-watcher.js';
 export * from './lifecycle.js';
 export * from './link.js';
 export * from './noop.js';

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

@@ -34,7 +34,7 @@ export type BlockLifecycleEvents = {
  * manipulated ('background:classic', 'node:market', 'connector:link'…).
  */
 export interface FrameworkElementEvent extends TelemetryEvent {
-    framework: 'wardley' | 'edgy' | 'cynefin' | 'bpmn' | 'c4' | 'event-storming' | 'core-domain' | 'context-map';
+    framework: 'wardley' | 'edgy' | 'cynefin' | 'bpmn' | 'c4' | 'event-storming' | 'core-domain' | 'context-map' | 'uml';
     element: string;
 }
 /**
@@ -295,3 +295,28 @@ export type AuditEvents = {
     MapAuditCompleted: MapAuditCompletedEvent;
     MapAuditInterrupted: MapAuditInterruptedEvent;
 };
+/**
+ * A document was opened carrying elements the editor cannot draw — today, a
+ * surface element whose `xywh` never arrived (#318), which reads a zero-size
+ * bound and paints nothing.
+ *
+ * **Not a lifecycle event and not a user gesture: a health event.** The block
+ * taxonomy describes what someone did; this one describes what a document IS
+ * when it lands, which no existing event can say. It was already reported as a
+ * `console.warn` by the surface model — invisible to analytics, and therefore
+ * unable to answer the one question that matters after the app-side
+ * persistence fix: *how many documents open damaged*. The metric the dashboard
+ * reads is the count of DISTINCT documents, not of events.
+ *
+ * Counts only. Never an element id, never a type name, never board content.
+ */
+export interface DocumentDamagedEvent extends TelemetryEvent {
+    page?: 'doc editor' | 'whiteboard editor';
+    /** What is wrong with the elements this event counts. */
+    reason: 'missing-xywh';
+    /** How many damaged elements this batch found. */
+    elementCount: number;
+}
+export type DocumentHealthEvents = {
+    DocumentDamaged: DocumentDamagedEvent;
+};