@formicoidea/labre-core 0.32.0 → 0.34.1

package/dist/_pkgs/affine-model/elements/c4/board.d.ts

@@ -0,0 +1,88 @@
+import type { SerializedXYWH } from '../../../global/gfx/index.js';
+import type { FrameworkBackgroundProps } from '../framework-background/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+/**
+ * Which of C4's levels this board draws — the DECLARED fact, as opposed to the
+ * title, which is free text and says whatever its author wants it to.
+ *
+ * **Four values, for the four C's the notation is named after**: Context,
+ * Containers, Components, Code. The vocabulary is the model's, so it says all
+ * of it.
+ *
+ * ## Why `code` is here although nothing draws it
+ *
+ * Because the two questions are not the same one. What the EDITOR can draw is a
+ * fact about this tooling — there are no code-level artefacts in the pack today,
+ * and C4 itself says to skip that diagram unless it is generated from the source
+ * — while what a SHEET may declare is a fact about the author's intent. A board
+ * an architect keeps for the class diagram they paste in from elsewhere is a
+ * code-level board, and a vocabulary that refused to let them say so would be
+ * this editor's limitation dressed up as the notation's.
+ *
+ * So the declaration is the author's to make, and no rule judges it: nothing in
+ * the pack knows what a code diagram admits, and a rule with nothing to forbid
+ * is data that can never fire (`rules.ts` says this at length, about `component`
+ * and `code` together). The level is recorded, exported and readable; it is
+ * simply not yet checked.
+ *
+ * ## Widening this union is additive
+ *
+ * A value added here is a value older clients have never seen, and they read it
+ * back as the string it is — the same promise `C4NodeKind` and
+ * `C4BoundaryVariant` make. No document is rewritten, no migration is owed, and
+ * a rule that does not name a level evaluates nothing on a board carrying it.
+ *
+ * A board that states a level is a board a rule can judge — "a container has no
+ * place on a context diagram" — where a board that states nothing is a free
+ * sketch, which is what every C4 diagram ever drawn in this editor is.
+ */
+export type C4BoardLevel = 'context' | 'container' | 'component' | 'code';
+export type C4BoardProps = FrameworkBackgroundProps & {
+    /** The diagram title, written top-left — edited inline on dblclick. */
+    name?: string;
+    /** Which C4 level this sheet draws. Absent means a free sketch. */
+    level?: C4BoardLevel;
+};
+/**
+ * The C4 board: the sheet one diagram of the model is drawn on — a context
+ * diagram, a container diagram, a component diagram. A framework background like
+ * every other one in the library: the user drops nodes on top of it, and a
+ * connector never snaps to it.
+ *
+ * It carries a NAME, and optionally the LEVEL it draws. A C4 diagram has no
+ * frame of reference — a system drawn top left says nothing more than one drawn
+ * bottom right — so there are no axes, no zones and no partition to declare.
+ *
+ * What it LOOKS like is declared, not coded: see `C4_BOARD_BACKGROUND` in
+ * `@labre/affine-gfx-c4`.
+ */
+export declare class C4BoardElementModel extends FrameworkBackgroundElementModel<C4BoardProps> {
+    get type(): string;
+    accessor name: string;
+    accessor resizeEnabled: boolean;
+    accessor rotate: number;
+    accessor xywh: SerializedXYWH;
+    /**
+     * Which C4 level this sheet draws — the only OPTIONAL field of this element,
+     * and optional on purpose.
+     *
+     * `@field()`'s `init` writes nothing for an `undefined` default, so a board
+     * that never states its level stays byte-identical to one created before this
+     * value existed: no schema version bump, no migration, and every document
+     * already on disk opens and paints exactly as it did. The same call
+     * `C4BoundaryElementModel.variant` makes, for the same reason.
+     *
+     * ## Why there is no default to read, unlike the boundary's `variant`
+     *
+     * A boundary that says nothing still IS one of the two levels, and reading it
+     * as `'system'` is the only answer a reader could give. A board that says
+     * nothing is a different thing altogether: a free sketch, whose author has not
+     * told the tool which of the three sheets they are drawing. Guessing would
+     * hand every diagram already in existence a level nobody chose, and a rule
+     * reading it would start indicting drawings on the strength of that guess.
+     *
+     * So absent stays absent, and the rules that read it evaluate nothing at all
+     * on a board that declares none — no fact, no rule (PRD principle 8).
+     */
+    accessor level: C4BoardLevel | undefined;
+}

package/dist/_pkgs/affine-model/elements/c4/board.js

@@ -0,0 +1,128 @@
+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 C4 board: the sheet one diagram of the model is drawn on — a context
+ * diagram, a container diagram, a component diagram. A framework background like
+ * every other one in the library: the user drops nodes on top of it, and a
+ * connector never snaps to it.
+ *
+ * It carries a NAME, and optionally the LEVEL it draws. A C4 diagram has no
+ * frame of reference — a system drawn top left says nothing more than one drawn
+ * bottom right — so there are no axes, no zones and no partition to declare.
+ *
+ * What it LOOKS like is declared, not coded: see `C4_BOARD_BACKGROUND` in
+ * `@labre/affine-gfx-c4`.
+ */
+let C4BoardElementModel = (() => {
+    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 = [];
+    let _level_decorators;
+    let _level_initializers = [];
+    let _level_extraInitializers = [];
+    return class C4BoardElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _name_decorators = [field('C4 diagram')];
+            _resizeEnabled_decorators = [field(true)];
+            _rotate_decorators = [field(0)];
+            _xywh_decorators = [field()];
+            _level_decorators = [field()];
+            __esDecorate(this, null, _name_decorators, { kind: "accessor", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
+            __esDecorate(this, null, _resizeEnabled_decorators, { kind: "accessor", name: "resizeEnabled", static: false, private: false, access: { has: obj => "resizeEnabled" in obj, get: obj => obj.resizeEnabled, set: (obj, value) => { obj.resizeEnabled = value; } }, metadata: _metadata }, _resizeEnabled_initializers, _resizeEnabled_extraInitializers);
+            __esDecorate(this, null, _rotate_decorators, { kind: "accessor", name: "rotate", static: false, private: false, access: { has: obj => "rotate" in obj, get: obj => obj.rotate, set: (obj, value) => { obj.rotate = value; } }, metadata: _metadata }, _rotate_initializers, _rotate_extraInitializers);
+            __esDecorate(this, null, _xywh_decorators, { kind: "accessor", name: "xywh", static: false, private: false, access: { has: obj => "xywh" in obj, get: obj => obj.xywh, set: (obj, value) => { obj.xywh = value; } }, metadata: _metadata }, _xywh_initializers, _xywh_extraInitializers);
+            __esDecorate(this, null, _level_decorators, { kind: "accessor", name: "level", static: false, private: false, access: { has: obj => "level" in obj, get: obj => obj.level, set: (obj, value) => { obj.level = value; } }, metadata: _metadata }, _level_initializers, _level_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'c4Board';
+        }
+        #name_accessor_storage = __runInitializers(this, _name_initializers, 'C4 diagram');
+        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,1400,900]'));
+        get xywh() { return this.#xywh_accessor_storage; }
+        set xywh(value) { this.#xywh_accessor_storage = value; }
+        #level_accessor_storage = (__runInitializers(this, _xywh_extraInitializers), __runInitializers(this, _level_initializers, undefined));
+        /**
+         * Which C4 level this sheet draws — the only OPTIONAL field of this element,
+         * and optional on purpose.
+         *
+         * `@field()`'s `init` writes nothing for an `undefined` default, so a board
+         * that never states its level stays byte-identical to one created before this
+         * value existed: no schema version bump, no migration, and every document
+         * already on disk opens and paints exactly as it did. The same call
+         * `C4BoundaryElementModel.variant` makes, for the same reason.
+         *
+         * ## Why there is no default to read, unlike the boundary's `variant`
+         *
+         * A boundary that says nothing still IS one of the two levels, and reading it
+         * as `'system'` is the only answer a reader could give. A board that says
+         * nothing is a different thing altogether: a free sketch, whose author has not
+         * told the tool which of the three sheets they are drawing. Guessing would
+         * hand every diagram already in existence a level nobody chose, and a rule
+         * reading it would start indicting drawings on the strength of that guess.
+         *
+         * So absent stays absent, and the rules that read it evaluate nothing at all
+         * on a board that declares none — no fact, no rule (PRD principle 8).
+         */
+        get level() { return this.#level_accessor_storage; }
+        set level(value) { this.#level_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _level_extraInitializers);
+        }
+    };
+})();
+export { C4BoardElementModel };

package/dist/_pkgs/affine-model/elements/c4/boundary.d.ts

@@ -0,0 +1,63 @@
+import type { SerializedXYWH } from '../../../global/gfx/index.js';
+import type { FrameworkBackgroundProps } from '../framework-background/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+/**
+ * Which level a boundary encloses. C4 draws the two identically — a dashed
+ * rectangle round a group of elements — and the difference is entirely in what
+ * the label says, which is why this is one element type with a variant rather
+ * than two.
+ */
+export type C4BoundaryVariant = 'system' | 'container';
+export type C4BoundaryProps = FrameworkBackgroundProps & {
+    /** The boundary name, written bottom-left — edited inline on dblclick. */
+    name?: string;
+    /** Which level this boundary encloses. Absent behaves as `'system'`. */
+    variant?: C4BoundaryVariant;
+};
+/**
+ * A C4 boundary: the dashed rectangle drawn AROUND a group of elements to say
+ * "all of this is one system" (or one container). A framework background, so
+ * nodes are dropped on it and connectors never snap to it — but a transparent
+ * one, unlike every other background in the library: a boundary is drawn over
+ * the board it sits on, and an opaque card would hide the diagram it encloses.
+ *
+ * What it LOOKS like is declared, not coded: see `C4_BOUNDARY_BACKGROUND` in
+ * `@labre/affine-gfx-c4`.
+ */
+export declare class C4BoundaryElementModel extends FrameworkBackgroundElementModel<C4BoundaryProps> {
+    get type(): string;
+    accessor name: string;
+    accessor resizeEnabled: boolean;
+    accessor rotate: number;
+    accessor xywh: SerializedXYWH;
+    /**
+     * The level enclosed — the only OPTIONAL field of this element, and optional
+     * on purpose.
+     *
+     * `@field()`'s `init` writes nothing for an `undefined` default, so a boundary
+     * that never states its level stays byte-identical to one created before this
+     * value existed: no schema version bump, no migration, and every document
+     * already on disk opens and paints exactly as it did. The same call
+     * `BpmnPoolElementModel.lanes` makes, for the same reason.
+     *
+     * Absent reads as `'system'` everywhere — the outermost boundary, which is the
+     * one a reader draws first and the one the default wording names.
+     */
+    accessor variant: C4BoundaryVariant | undefined;
+    /**
+     * The variant every reader of this element should use — `variant` with its
+     * documented default already applied.
+     *
+     * Derived, not stored: nothing here reaches the document, and an element that
+     * never stated a level is untouched by the existence of this getter.
+     *
+     * It is what lets the declaration gate a piece of itself on the level
+     * (`variantProp`), which a raw optional field cannot do: an unstated `variant`
+     * stringifies to `"undefined"`, matches no declared variant, and would paint
+     * NOTHING — the trap the boundary declaration used to avoid by declaring no
+     * `variantProp` at all. Reading the default here removes the trap instead of
+     * routing round it, so the frame can finally write the bracket line the
+     * stencil puts under a boundary's name.
+     */
+    get variantOrDefault(): C4BoundaryVariant;
+}

package/dist/_pkgs/affine-model/elements/c4/boundary.js

@@ -0,0 +1,134 @@
+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 C4 boundary: the dashed rectangle drawn AROUND a group of elements to say
+ * "all of this is one system" (or one container). A framework background, so
+ * nodes are dropped on it and connectors never snap to it — but a transparent
+ * one, unlike every other background in the library: a boundary is drawn over
+ * the board it sits on, and an opaque card would hide the diagram it encloses.
+ *
+ * What it LOOKS like is declared, not coded: see `C4_BOUNDARY_BACKGROUND` in
+ * `@labre/affine-gfx-c4`.
+ */
+let C4BoundaryElementModel = (() => {
+    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 = [];
+    let _variant_decorators;
+    let _variant_initializers = [];
+    let _variant_extraInitializers = [];
+    return class C4BoundaryElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _name_decorators = [field('Boundary')];
+            _resizeEnabled_decorators = [field(true)];
+            _rotate_decorators = [field(0)];
+            _xywh_decorators = [field()];
+            _variant_decorators = [field()];
+            __esDecorate(this, null, _name_decorators, { kind: "accessor", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
+            __esDecorate(this, null, _resizeEnabled_decorators, { kind: "accessor", name: "resizeEnabled", static: false, private: false, access: { has: obj => "resizeEnabled" in obj, get: obj => obj.resizeEnabled, set: (obj, value) => { obj.resizeEnabled = value; } }, metadata: _metadata }, _resizeEnabled_initializers, _resizeEnabled_extraInitializers);
+            __esDecorate(this, null, _rotate_decorators, { kind: "accessor", name: "rotate", static: false, private: false, access: { has: obj => "rotate" in obj, get: obj => obj.rotate, set: (obj, value) => { obj.rotate = value; } }, metadata: _metadata }, _rotate_initializers, _rotate_extraInitializers);
+            __esDecorate(this, null, _xywh_decorators, { kind: "accessor", name: "xywh", static: false, private: false, access: { has: obj => "xywh" in obj, get: obj => obj.xywh, set: (obj, value) => { obj.xywh = value; } }, metadata: _metadata }, _xywh_initializers, _xywh_extraInitializers);
+            __esDecorate(this, null, _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);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'c4Boundary';
+        }
+        #name_accessor_storage = __runInitializers(this, _name_initializers, 'Boundary');
+        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; }
+        #variant_accessor_storage = (__runInitializers(this, _xywh_extraInitializers), __runInitializers(this, _variant_initializers, undefined));
+        /**
+         * The level enclosed — the only OPTIONAL field of this element, and optional
+         * on purpose.
+         *
+         * `@field()`'s `init` writes nothing for an `undefined` default, so a boundary
+         * that never states its level stays byte-identical to one created before this
+         * value existed: no schema version bump, no migration, and every document
+         * already on disk opens and paints exactly as it did. The same call
+         * `BpmnPoolElementModel.lanes` makes, for the same reason.
+         *
+         * Absent reads as `'system'` everywhere — the outermost boundary, which is the
+         * one a reader draws first and the one the default wording names.
+         */
+        get variant() { return this.#variant_accessor_storage; }
+        set variant(value) { this.#variant_accessor_storage = value; }
+        /**
+         * The variant every reader of this element should use — `variant` with its
+         * documented default already applied.
+         *
+         * Derived, not stored: nothing here reaches the document, and an element that
+         * never stated a level is untouched by the existence of this getter.
+         *
+         * It is what lets the declaration gate a piece of itself on the level
+         * (`variantProp`), which a raw optional field cannot do: an unstated `variant`
+         * stringifies to `"undefined"`, matches no declared variant, and would paint
+         * NOTHING — the trap the boundary declaration used to avoid by declaring no
+         * `variantProp` at all. Reading the default here removes the trap instead of
+         * routing round it, so the frame can finally write the bracket line the
+         * stencil puts under a boundary's name.
+         */
+        get variantOrDefault() {
+            return this.variant ?? 'system';
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _variant_extraInitializers);
+        }
+    };
+})();
+export { C4BoundaryElementModel };

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

@@ -0,0 +1,3 @@
+export * from './board.js';
+export * from './boundary.js';
+export * from './node.js';

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

@@ -0,0 +1,3 @@
+export * from './board.js';
+export * from './boundary.js';
+export * from './node.js';

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

@@ -0,0 +1,97 @@
+import type { PointTestOptions } from '../../../std/gfx/index.js';
+import { ShapeElementModel } from '../shape/index.js';
+/**
+ * The C4 artefacts the pack draws — the four levels of the model, plus the
+ * container flavours the official stencil gives a silhouette of their own:
+ *
+ *  - people        — `person` and `person-ext`, a head over a rounded body;
+ *  - systems       — `system` and `system-ext`, a plain rounded rectangle;
+ *  - containers    — `container`, plus `database` (a cylinder), `mobile` (a
+ *    phone bezel down the leading edge) and `browser` (a chrome band across the
+ *    top). All four are CONTAINERS: what differs is the picture, never the
+ *    level;
+ *  - components    — `component`, the innermost level C4 draws.
+ *
+ * ## Why "external" is a KIND and not a flag
+ *
+ * `person-ext` and `system-ext` are separate values rather than an `external`
+ * boolean, mirroring {@link BpmnNodeKind}'s message and timer starts: the C4
+ * stencil greys an external element out entirely — fill, border and label — so
+ * externality is a different picture, not a modifier on one. One discriminant
+ * keeps the renderer's switch total and the size / palette tables keyed the same
+ * way; a second, orthogonal flag would multiply both by two and let a
+ * combination exist that the notation has no drawing for.
+ *
+ * ## Compatibility
+ *
+ * This union is only ever WIDENED, and it is widened with new VALUES of the
+ * existing `kind` string field — no new field, no schema change, no migration
+ * and no backfill. Same promise `wardley` and `bpmn` already make.
+ */
+export type C4NodeKind = 'person' | 'person-ext' | 'system' | 'system-ext' | 'container' | 'database' | 'mobile' | 'browser' | 'component';
+/**
+ * A C4 node. Extends {@link ShapeElementModel} (a native shape) so it inherits
+ * ALL shape behaviour — editable stroke width / colours, inner text, native
+ * resize, the shape context toolbar — for free. `kind` discriminates the
+ * artefacts and drives the RENDERING alone; what a node MEANS is the `role`
+ * stamped on it at creation (`gfx/c4/src/roles.ts`).
+ *
+ * Mirrors {@link BpmnNodeElementModel}.
+ */
+export declare class C4NodeElementModel extends ShapeElementModel {
+    get type(): string;
+    /**
+     * Connector anchors are restricted to the centre, as they are for a BPMN flow
+     * object: a C4 relationship attaches to the node centre and clips at the
+     * perimeter, so an arrow between two boxes points at the boxes rather than at
+     * whichever of their twelve anchors the hand was nearest.
+     */
+    get centerAnchorOnly(): boolean;
+    /**
+     * A C4 node is SOLID whatever its `filled` flag says.
+     *
+     * `rect.includesPoint` (and `ellipse`'s, and `diamond`'s) skips the interior
+     * test for an unfilled shape and falls back to the stroke plus the tight
+     * bounding box of the text run — the behaviour that makes a hollow group let
+     * clicks through to the work it encloses. Three of the nine C4 kinds are
+     * created unfilled and unstroked on purpose (`person`, `person-ext`,
+     * `database`, and the two decorated containers): their silhouette is a head
+     * over a body, a cylinder, a phone or a browser window, none of which a native
+     * rect can be, so the GLYPH paints the body and the native shape paints
+     * nothing at all.
+     *
+     * The consequence, reported by the PO on 27/08/2026, is that those nodes could
+     * not be double-clicked into their own text editor: the body a user can
+     * plainly see was not a hit target, and only the border and the handful of
+     * characters of the label were. Pointer events reach an element view through
+     * this method (`GfxViewEventHandler`), so selecting, hovering, dragging and
+     * `dblclick` were all affected — the last one visibly.
+     *
+     * Forcing `ignoreTransparent: false` says the one thing that is true of every
+     * C4 artefact and of no BPMN group: it is a BOX, and its whole area belongs to
+     * it. Nothing here is stored — the override changes hit testing, never the
+     * document — so it applies to nodes drawn before it existed as well as after.
+     *
+     * The same latent gap exists for BPMN's `dataObject` / `dataStore`; it is not
+     * fixed there because a BPMN artifact's own answer may well be different (its
+     * `hollow` kinds want the click-through), and guessing on another pack's
+     * behalf is how a fix becomes a regression.
+     */
+    includesPoint(x: number, y: number, options: PointTestOptions): boolean;
+    /**
+     * The one field a C4 node carries, and the whole of its schema.
+     *
+     * The two other tiers of the notation — the type line and the description —
+     * are deliberately NOT fields here. They are canvas TEXT elements, grouped
+     * with the shape, and they are edited in place exactly like any other words on
+     * the canvas (PO recette, 28/08/2026). A field would have been a second place
+     * to write the same sentence, reachable only through a form, and the form is
+     * the mechanism the recette rejected: an architect writes on the picture.
+     *
+     * What that buys the document format is that this model stays exactly what it
+     * was — `kind`, on a native shape — while the component grows two more tiers.
+     * See `gfx/c4/src/actions.ts` for how the group is assembled and
+     * `gfx/c4/src/export.ts` for how it is read back.
+     */
+    accessor kind: C4NodeKind;
+}

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

@@ -0,0 +1,130 @@
+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 { ShapeElementModel } from '../shape/index.js';
+/**
+ * A C4 node. Extends {@link ShapeElementModel} (a native shape) so it inherits
+ * ALL shape behaviour — editable stroke width / colours, inner text, native
+ * resize, the shape context toolbar — for free. `kind` discriminates the
+ * artefacts and drives the RENDERING alone; what a node MEANS is the `role`
+ * stamped on it at creation (`gfx/c4/src/roles.ts`).
+ *
+ * Mirrors {@link BpmnNodeElementModel}.
+ */
+let C4NodeElementModel = (() => {
+    let _classSuper = ShapeElementModel;
+    let _kind_decorators;
+    let _kind_initializers = [];
+    let _kind_extraInitializers = [];
+    return class C4NodeElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _kind_decorators = [field('system')];
+            __esDecorate(this, null, _kind_decorators, { kind: "accessor", name: "kind", static: false, private: false, access: { has: obj => "kind" in obj, get: obj => obj.kind, set: (obj, value) => { obj.kind = value; } }, metadata: _metadata }, _kind_initializers, _kind_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'c4Node';
+        }
+        /**
+         * Connector anchors are restricted to the centre, as they are for a BPMN flow
+         * object: a C4 relationship attaches to the node centre and clips at the
+         * perimeter, so an arrow between two boxes points at the boxes rather than at
+         * whichever of their twelve anchors the hand was nearest.
+         */
+        get centerAnchorOnly() {
+            return true;
+        }
+        /**
+         * A C4 node is SOLID whatever its `filled` flag says.
+         *
+         * `rect.includesPoint` (and `ellipse`'s, and `diamond`'s) skips the interior
+         * test for an unfilled shape and falls back to the stroke plus the tight
+         * bounding box of the text run — the behaviour that makes a hollow group let
+         * clicks through to the work it encloses. Three of the nine C4 kinds are
+         * created unfilled and unstroked on purpose (`person`, `person-ext`,
+         * `database`, and the two decorated containers): their silhouette is a head
+         * over a body, a cylinder, a phone or a browser window, none of which a native
+         * rect can be, so the GLYPH paints the body and the native shape paints
+         * nothing at all.
+         *
+         * The consequence, reported by the PO on 27/08/2026, is that those nodes could
+         * not be double-clicked into their own text editor: the body a user can
+         * plainly see was not a hit target, and only the border and the handful of
+         * characters of the label were. Pointer events reach an element view through
+         * this method (`GfxViewEventHandler`), so selecting, hovering, dragging and
+         * `dblclick` were all affected — the last one visibly.
+         *
+         * Forcing `ignoreTransparent: false` says the one thing that is true of every
+         * C4 artefact and of no BPMN group: it is a BOX, and its whole area belongs to
+         * it. Nothing here is stored — the override changes hit testing, never the
+         * document — so it applies to nodes drawn before it existed as well as after.
+         *
+         * The same latent gap exists for BPMN's `dataObject` / `dataStore`; it is not
+         * fixed there because a BPMN artifact's own answer may well be different (its
+         * `hollow` kinds want the click-through), and guessing on another pack's
+         * behalf is how a fix becomes a regression.
+         */
+        includesPoint(x, y, options) {
+            return super.includesPoint(x, y, {
+                ...options,
+                ignoreTransparent: false,
+            });
+        }
+        #kind_accessor_storage = __runInitializers(this, _kind_initializers, 'system');
+        /**
+         * The one field a C4 node carries, and the whole of its schema.
+         *
+         * The two other tiers of the notation — the type line and the description —
+         * are deliberately NOT fields here. They are canvas TEXT elements, grouped
+         * with the shape, and they are edited in place exactly like any other words on
+         * the canvas (PO recette, 28/08/2026). A field would have been a second place
+         * to write the same sentence, reachable only through a form, and the form is
+         * the mechanism the recette rejected: an architect writes on the picture.
+         *
+         * What that buys the document format is that this model stays exactly what it
+         * was — `kind`, on a native shape — while the component grows two more tiers.
+         * See `gfx/c4/src/actions.ts` for how the group is assembled and
+         * `gfx/c4/src/export.ts` for how it is read back.
+         */
+        get kind() { return this.#kind_accessor_storage; }
+        set kind(value) { this.#kind_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _kind_extraInitializers);
+        }
+    };
+})();
+export { C4NodeElementModel };