Models

Import these from @grafloria/engine.

On their own pages

• DetachedParentAnchor: The LAST-KNOWN ANCHOR of a node the diagram has REMOVED.
• DiagramEntity
• DiagramModel
• GroupModel
• LinkModel
• NodeModel
• PortModel
• SerializedDiagram
• SerializedPort
• StrokeModel: A freehand ink stroke: an ordered point list, a style, and an identity.

Functions

bumpMutationEpoch

Bump the epoch by hand, for a mutation that legitimately bypasses markDirty() (in-place points rewrites, say). Prefer markDirty().

ts
Copy
function bumpMutationEpoch(): number

distanceToSegment

Distance from p to the segment a→b. The primitive both hit-tests are built on.

ts
Copy
function distanceToSegment(p: Point, a: Point, b: Point): number

getMutationEpoch

Read the current mutation epoch. Cheap enough to call every frame.

ts
Copy
function getMutationEpoch(): number

hasPressure

True when the device gave us pressure worth keeping (i.e. it actually varies).

ts
Copy
function hasPressure(points: readonly StrokePoint[]): boolean

linkLabelPosition

The position along the path (0-1) a label resolves to.

slot WINS over position. Naming a slot is an explicit act; position is a required field that most slot users only fill in to satisfy the type, so letting it win would make slot silently do nothing.

ts
Copy
function linkLabelPosition(
  label: Pick<LinkLabel, 'position' | 'slot'>
): number

segmentDistance

Minimum distance between two SEGMENTS.

The eraser needs this and a point-test cannot replace it. A pointermove at 60Hz over a fast flick lands samples 80px apart; testing only the sample POINTS lets the eraser jump clean over a stroke it visibly swept through. So the eraser tests the segment it travelled, not the points it happened to land on.

ts
Copy
function segmentDistance(a1: Point, a2: Point, b1: Point, b2: Point): number

Constants

DEFAULT_GROUP_HEADER_HEIGHT

ts
Copy
const DEFAULT_GROUP_HEADER_HEIGHT: 24

DEFAULT_GROUP_PADDING

Defaults for groups AUTHORED in code (constructor path). A fitted frame needs breathing room and a title band or its label lands under the first member. Loaded documents are exempt: restore assigns the stored values (padding verbatim — possibly undefined, which getPadding() resolves to 0 — and headerHeight number-or-0), so legacy geometry is byte-stable.

ts
Copy
const DEFAULT_GROUP_PADDING: 16

DEFAULT_PORT_SNAP_RADIUS

How near a port must be to a point for {@link DiagramModel.findNearestPort} to consider it, in world units. Roughly a fingertip at 100% zoom.

ts
Copy
const DEFAULT_PORT_SNAP_RADIUS: 24

DEFAULT_SIMPLIFY_EPSILON

Douglas-Peucker tolerance, in WORLD units.

0.6 is tuned against real traces: below ~0.4 you keep the sensor jitter you were trying to remove; above ~1.2 a deliberate small loop (the dot of an "i", a tick) starts to visibly flatten. At 0.6 a 500-point scribble lands around 40-70 points and is indistinguishable from the raw trace at 100% zoom.

It is world-space, so ink drawn while zoomed OUT is simplified more aggressively in screen terms — which is right: you cannot see detail you did not draw.

ts
Copy
const DEFAULT_SIMPLIFY_EPSILON: 0.6

DEFAULT_STROKE_STYLE

ts
Copy
const DEFAULT_STROKE_STYLE: StrokeStyle

LINK_LABEL_SLOT_POSITIONS

Where each of the three edge label SLOTS sits along the path.

Pulled IN from the endpoints on purpose: at exactly 0 and 1 a slot label would land under the arrowhead and on top of the port. 0.12 / 0.88 clears both while still reading as "at the start / at the end of this edge".

ONE definition, shared by the model (LinkModel.addLabel), the renderer (LabelRenderer) and the edge optimizer — three places that must never disagree about where a label actually is.

ts
Copy
const LINK_LABEL_SLOT_POSITIONS: Record<'start' | 'center' | 'end', number>

Interfaces

ChangeEntry

ts
Copy
interface ChangeEntry

Properties

CollapsedState

The reversible snapshot captured when a group collapses. Stored (serialized) on the group so a collapsed diagram round-trips and can be expanded losslessly after a save/load — not just within one session.

ts
Copy
interface CollapsedState

Properties

DiagramLoadOptions

ts
Copy
interface DiagramLoadOptions

Properties

FitToContentsOptions

Options for {@link GroupModel.fitToContents}.

ts
Copy
interface FitToContentsOptions

Properties

GroupRect

A resolved rectangle (all four sides present).

ts
Copy
interface GroupRect

Properties

LaneConfig

Swimlanes & pools as a GENERIC banded group (not BPMN-named). A pool group tiles its child lane groups into bands along one axis; each lane is an ordinary group (so drop-to-assign, membership, constraints all reuse the existing machinery). This is intrinsic band config that round-trips.

ts
Copy
interface LaneConfig

Properties

MembershipLeaf

ts
Copy
interface MembershipLeaf

Properties

NearestPortHit

What {@link DiagramModel.findNearestPort} found.

ts
Copy
interface NearestPortHit

Properties

NearestPortOptions

Options for {@link DiagramModel.findNearestPort}.

ts
Copy
interface NearestPortOptions

Properties

SerializedGroup

ts
Copy
interface SerializedGroup extends SerializedEntity

Properties

SerializedLink

ts
Copy
interface SerializedLink extends SerializedEntity

Properties

SerializedNode

ts
Copy
interface SerializedNode extends SerializedEntity

Properties

SerializedStroke

ts
Copy
interface SerializedStroke extends SerializedEntity

Properties

StrokePoint

One sample from the pointer.

pressure is 0..1 and OPTIONAL — a mouse does not have any. It is stored only when the device actually reported a varying one (see {@link hasPressure}), because a field that is always 0.5 is noise on the wire and a lie in the model.

It is not decoration: the renderer builds a variable-width outline from it. A pressure that does not change the picture would be exactly the "machinery wired to nothing" this project has shipped in all nine previous waves.

ts
Copy
interface StrokePoint

Properties

StrokeStyle

How the ink looks. Flat and JSON-safe — this crosses the wire as an op payload.

ts
Copy
interface StrokeStyle

Properties

SubgraphGroupConfig

A group's own compound-layout configuration — the subset of the GroupInfo layout contract that is intrinsic to the group and round-trips.

ts
Copy
interface SubgraphGroupConfig

Properties

Types

GroupFitMode

How {@link GroupModel.fitToContents} reconciles the freshly computed content rectangle with the group's current rectangle.

• exact — snap to the content rectangle (default).
• grow-only — never shrink below the current rectangle (union).
• shrink-only— never grow beyond the current rectangle (intersection-ish).

ts
Copy
type GroupFitMode = 'exact' | 'grow-only' | 'shrink-only';

GroupPadding

Per-side padding (a scalar expands to all four sides).

ts
Copy
type GroupPadding =
  | number
  | { top?: number; right?: number; bottom?: number; left?: number };

LinkConnectorName

ts
Copy
type LinkConnectorName =
  | 'straight'      // straight segments, hard corners
  | 'rounded'       // straight segments, cornerRadius arcs (the orthogonal look)
  | 'smooth'        // catmull-rom-style smoothing through the points
  | 'bezier'        // cubic bezier between endpoints
  | (string & {});

LinkRouterName

. pathType conflated two independent choices: WHERE the line goes (routing geometry) and HOW the polyline is drawn (connector rendering). They are now two orthogonal, per-link, serializable settings, with pathType kept as the back-compat shorthand that derives both when the explicit fields are absent.

Router names resolve against the engine's RoutingEngine registry, so a custom registered router is addressable per link by its registration name.

ts
Copy
type LinkRouterName =
  | 'straight'      // endpoint-to-endpoint, ignores obstacles
  | 'orthogonal'    // HVH/VHV elbows honouring port sides
  | 'manhattan'     // grid search with obstacle avoidance + direction-change cost
  | 'avoid'         // A* obstacle-avoiding router
  | 'elk'           // delegate geometry to ELK's edge router
  | (string & {});

MembershipRule

A SERIALIZABLE declarative membership predicate over a node's data (never eval'd code). Leaves match one field with an operator; branches compose with all/any/not. Kept intentionally small and closed so it round- trips and can be reasoned about / edited as data.

ts
Copy
type MembershipRule =
  | MembershipLeaf
  | { all: MembershipRule[] }
  | { any: MembershipRule[] }
  | { not: MembershipRule };

MemberValidation

Predicate used to gate group membership. Return false to reject a candidate entity from joining the group.

ts
Copy
type MemberValidation = (candidateId: string, group: GroupModel) => boolean;

Parameters

• candidateId: id of the node/group being added
• group: the group the candidate would join

PositioningMode

Positioning mode

• absolute: Position relative to diagram origin (default, backward compatible)
• relative: Position relative to parent
• layout: Position managed by parent's layout algorithm (future)

ts
Copy
type PositioningMode = 'absolute' | 'relative' | 'layout';