@fulate/ui 1.0.0

package/dist/line/base.d.ts

@@ -0,0 +1,142 @@
+import { ChangeImpact, Element, ElementTransform, ElementProperties, type AnchorId, type AuthoredPathAnchor, type AuthoredSubpath, type BaseElementOption, type ConnectionPortRef, type GeometrySnapshot, type Layer, type OwnerPropertyChange, type PropertyChanges, type Root, type SegmentId, type ElementTransformBaseline, type ReferenceTransformBaseline, type ReparentTransformIntent, type TransformIntent } from "@fulate/core";
+import { type Rect, type PointView } from "@fulate/share";
+import { type BindableEndpoint, type EndpointConnectionRole, type EndpointRelation, type EndpointRelationBinding } from "../connection/types";
+import { SelectionBehaviorMode, SelectionDiveMode, SelectionSnapMode, type EditorCapabilityToken } from "../editor/capability";
+/** 省略一端表示保持，own `undefined` 表示清除该端。 */
+export interface LineEndpointRelationPatch {
+    readonly head?: EndpointRelation | undefined;
+    readonly tail?: EndpointRelation | undefined;
+}
+export type LineDecoration = "none" | "arrow" | "dot";
+export interface LineOption extends Omit<BaseElementOption<BaseLine>, "ports"> {
+    /** 普通创建传 points；JSON/History/clipboard restore 直接传 canonical subpath。 */
+    path?: readonly PointView[] | AuthoredSubpath;
+    relations?: LineEndpointRelationPatch;
+    /** 显式线色；省略时使用 Root Skin 的 `lineStroke`。 */
+    strokeColor?: string;
+    strokeWidth?: number;
+    headDecoration?: LineDecoration;
+    tailDecoration?: LineDecoration;
+}
+type LinePatch = Omit<LineOption, "key" | "layer" | "children">;
+interface LineTransformOwnedState {
+    readonly path: AuthoredSubpath;
+    readonly effective?: {
+        readonly path: AuthoredSubpath;
+        readonly reference: ReferenceTransformBaseline;
+        readonly relationPatch?: LineEndpointRelationPatch;
+    };
+}
+interface LineStateOption extends Omit<LineOption, "path" | "relations"> {
+    path?: AuthoredSubpath;
+    headRelation?: EndpointRelation;
+    tailRelation?: EndpointRelation;
+}
+declare class LineProperties extends ElementProperties {
+    path: AuthoredSubpath;
+    headRelation?: EndpointRelation;
+    tailRelation?: EndpointRelation;
+    strokeColor?: string;
+    strokeWidth: number;
+    headDecoration: LineDecoration;
+    tailDecoration: LineDecoration;
+    constructor(options?: LineStateOption);
+    toJSON(): Record<string, unknown>;
+    getImpact(changes: PropertyChanges): ChangeImpact;
+}
+export declare class LineTransform<E extends BaseLine = BaseLine> extends ElementTransform<E> {
+    private layoutPathSource;
+    private layoutPathBounds;
+    protected resolveFitSize(): void;
+    protected buildLayoutReferenceBounds(): Readonly<Rect> | null;
+    protected getWorldMatrixReferenceBounds(): Readonly<Rect> | null;
+    protected worldMatrixAffectsLocalGeometry(): boolean;
+    private resolveEndpointPoint;
+    private resolveEffectiveSubpath;
+    protected buildGeometrySnapshot(revision: number, layoutReferenceBounds?: Readonly<Rect>): GeometrySnapshot;
+    protected buildLocalHitBounds(snapshot: GeometrySnapshot): Readonly<Rect> | null;
+    protected buildVisualBounds(snapshot: GeometrySnapshot): Readonly<Rect> | null;
+    protected buildVisualOutline(snapshot: GeometrySnapshot): PointView[];
+    private getVisualPadding;
+    protected getOwnContentBoundsView(): Readonly<Rect>;
+    protected buildWorldVisualBounds(): import("@fulate/share").Bound;
+    hasInView(): boolean;
+    hasPointHint(point: PointView): boolean;
+}
+export interface LineEndpointUpdate {
+    /** 仅首尾 anchor 使用；省略保持，own `undefined` 清除 relation。 */
+    readonly target?: ConnectionPortRef | undefined;
+}
+/**
+ * Base class for line elements. The one open authored subpath owns coordinates
+ * and stable local IDs; endpoint relations contain no geometry coordinates.
+ */
+export declare abstract class BaseLine extends Element<LineProperties, LineOption, LinePatch> {
+    get path(): AuthoredSubpath<AuthoredPathAnchor>;
+    get headRelation(): EndpointRelation;
+    get tailRelation(): EndpointRelation;
+    get strokeColor(): string;
+    get strokeWidth(): number;
+    get headDecoration(): LineDecoration;
+    get tailDecoration(): LineDecoration;
+    protected getResolvedStrokeColor(): string;
+    private endpointRelationIndex;
+    private worldGeometrySource;
+    private worldPointView;
+    private worldLineMatrixA;
+    private worldLineMatrixB;
+    private worldLineMatrixC;
+    private worldLineMatrixD;
+    private worldLineMatrixE;
+    private worldLineMatrixF;
+    constructor(options?: LineOption);
+    /** 把当前 source-authored relations 同步到 Root 唯一 reverse index。 */
+    private syncEndpointRelations;
+    protected getDefaultConnectionPortSchema(): any[];
+    getBindableEndpoints(): readonly BindableEndpoint[];
+    getEndpointRole(anchorId: AnchorId): EndpointConnectionRole | null;
+    getEndpointRelationBindings(): readonly EndpointRelationBinding[];
+    getEditorCapability<T>(token: EditorCapabilityToken<T>): T | undefined;
+    getSelectionBehavior(): {
+        readonly mode: SelectionBehaviorMode.Standard;
+        readonly dive: SelectionDiveMode.None;
+        readonly snap: SelectionSnapMode.Enabled;
+    };
+    getTransformPolicy(): {
+        readonly move: true;
+        readonly resize: "both";
+        readonly rotate: true;
+        readonly rotationPivot: "adjustable";
+    };
+    protected resolvePointPathPatch(path: AuthoredSubpath): LinePatch;
+    captureTransformBaseline(): ElementTransformBaseline<LineTransformOwnedState>;
+    resolveTransformChange(baseline: Readonly<ElementTransformBaseline<LineTransformOwnedState>>, intent: Readonly<TransformIntent | ReparentTransformIntent>): OwnerPropertyChange;
+    protected resolveOptions(options: LinePatch): LinePatch;
+    get headAnchor(): AuthoredPathAnchor;
+    get tailAnchor(): AuthoredPathAnchor;
+    get headPoint(): PointView | undefined;
+    get tailPoint(): PointView | undefined;
+    getAnchorIndex(anchorId: AnchorId): number;
+    getSegmentIndex(segmentId: SegmentId): number;
+    getEndpointRelation(anchorId: AnchorId): EndpointRelation;
+    resolveConnectEndpointChange(anchorId: AnchorId, target: ConnectionPortRef): OwnerPropertyChange | null;
+    resolveDisconnectEndpointChange(anchorIds: readonly AnchorId[], localPositions?: ReadonlyMap<AnchorId, PointView>): OwnerPropertyChange | null;
+    worldToLocal(x: number, y: number): PointView | null;
+    /** 返回可独立修改的 world point 结果。 */
+    getWorldLinePoints(): PointView[];
+    /** @internal Borrowed committed polyline coordinates for paint and hit tests. */
+    getWorldLinePointsView(): readonly PointView[];
+    /** @internal Borrowed effective local vertices from the canonical snapshot. */
+    getEffectiveLineVerticesView(): readonly import("@fulate/core").ResolvedVertex[];
+    getWorldSnapPointsView(): readonly PointView[];
+    addPoint(x: number, y: number, target?: ConnectionPortRef): AnchorId;
+    setLocalPoint(anchorId: AnchorId, point: PointView, endpointUpdate?: LineEndpointUpdate): void;
+    movePoint(anchorId: AnchorId, worldX: number, worldY: number): void;
+    insertPoint(segmentId: SegmentId, worldX: number, worldY: number): AnchorId;
+    removePoint(anchorId: AnchorId): void;
+    getLocalPoints(): PointView[];
+    protected onPropertiesChanged(current: LineProperties, changes: PropertyChanges): void;
+    protected onActivate(root: Root | null, layer: Layer | null): void;
+    protected onDeactivate(root: Root | null, layer: Layer | null): void;
+}
+export {};

package/dist/line/helpers/decoration.d.ts

@@ -0,0 +1,4 @@
+import type { LineDecoration } from "../base";
+import type { PointView } from "@fulate/share";
+export declare function getDecorationLineInset(decoration: LineDecoration): number;
+export declare function drawDecoration(ctx: CanvasRenderingContext2D, decoration: LineDecoration, from: PointView, to: PointView, color: string): void;

package/dist/line/index.d.ts

@@ -0,0 +1,3 @@
+export { BaseLine, LineTransform } from "./base";
+export type { LineEndpointRelationPatch, LineEndpointUpdate, LineOption, LineDecoration } from "./base";
+export { Line } from "./straight";

package/dist/line/straight-primitives.d.ts

@@ -0,0 +1,8 @@
+import { Bound, type BoundingBox, type PointView } from "@fulate/share";
+import type { LineDecoration } from "./base";
+export declare function tracePolyline(ctx: CanvasRenderingContext2D, points: readonly PointView[], headInset?: number, tailInset?: number): void;
+export declare function paintPolyline(ctx: CanvasRenderingContext2D, points: readonly PointView[], strokeColor: string, strokeWidth: number, headDecoration?: LineDecoration, tailDecoration?: LineDecoration): void;
+export declare function hasPolylinePointHint(points: readonly PointView[], point: PointView, viewportScale: number): boolean;
+export declare function getLineVisualPadding(strokeWidth: number): number;
+/** world-space line paint uses fixed-width stroke/decorations after pose projection. */
+export declare function expandLineWorldVisualBounds(bounds: Readonly<BoundingBox>, padding: number): Bound;

package/dist/line/straight.d.ts

@@ -0,0 +1,19 @@
+import { BaseLine, type LineOption } from "./base";
+import type { PointView } from "@fulate/share";
+import { type EditorCapabilityToken, type PointEditRequest, type PointEditingScope, type PointOwnerEdit } from "../editor/capability";
+export declare class Line extends BaseLine {
+    readonly type = "line";
+    constructor(options?: LineOption);
+    getEditorCapability<T>(token: EditorCapabilityToken<T>): T | undefined;
+    resolvePointScope(worldPoint: PointView): {
+        readonly kind: "owner";
+    };
+    hasPointScope(scope: PointEditingScope): scope is {
+        readonly kind: "owner";
+    };
+    getPointControls(_scope: PointEditingScope): import("..").PointControlDescriptor[];
+    getPointScopeOutline(_scope: PointEditingScope): any;
+    resolvePointEdit(request: PointEditRequest): PointOwnerEdit | null;
+    paint(ctx?: CanvasRenderingContext2D): void;
+    paintHover(ctx: CanvasRenderingContext2D, scale: number): void;
+}

package/dist/line-tree/history-delta.d.ts

@@ -0,0 +1,22 @@
+import type { AnchorId, SubpathId } from "@fulate/core";
+import type { LineTreeBranch, LineTreePoint, LineTreeTopology } from "./types";
+interface LineTreeRecordState<T> {
+    readonly index: number;
+    readonly value: T;
+}
+interface LineTreeRecordChange<Id, Value> {
+    readonly id: Id;
+    readonly before?: LineTreeRecordState<Value>;
+    readonly after?: LineTreeRecordState<Value>;
+}
+export interface LineTreeTopologyDelta {
+    readonly rootSubpathId?: {
+        readonly before: SubpathId | undefined;
+        readonly after: SubpathId | undefined;
+    };
+    readonly points: readonly LineTreeRecordChange<AnchorId, LineTreePoint>[];
+    readonly branches: readonly LineTreeRecordChange<SubpathId, LineTreeBranch>[];
+}
+export declare function createLineTreeTopologyDelta(before: LineTreeTopology, after: LineTreeTopology): LineTreeTopologyDelta | null;
+export declare function applyLineTreeTopologyDelta(topology: LineTreeTopology, delta: LineTreeTopologyDelta, direction: "before" | "after"): LineTreeTopology;
+export {};

package/dist/line-tree/index.d.ts

@@ -0,0 +1,74 @@
+import { ChangeImpact, Element, ElementProperties, type ElementTransformBaseline, type ConnectionPortRef, type Layer, type OwnerPropertyChange, type PropertyChanges, type ReparentTransformIntent, type Root, type AnchorId, type SubpathId, type TransformIntent } from "@fulate/core";
+import { type PointView } from "@fulate/share";
+import { SelectionBehaviorMode, SelectionDiveMode, SelectionSnapMode, type EditorCapabilityToken, type PointEditRequest, type PointEditingScope, type PointOwnerEdit } from "../editor/capability";
+import { type BindableEndpoint, type EndpointRelation, type EndpointRelationBinding } from "../connection/types";
+import { LineTreeTransform } from "./transform";
+import type { LineTreeOption, LineTreeTopology } from "./types";
+type LineTreePatch = Omit<LineTreeOption, "key" | "children">;
+interface LineTreeTransformOwnedState {
+    readonly topology: LineTreeTopology;
+    readonly effective?: {
+        readonly topology: LineTreeTopology;
+        readonly reference: ElementTransformBaseline["reference"];
+    };
+}
+export declare class LineTreeProperties extends ElementProperties {
+    topology: LineTreeTopology;
+    constructor(options?: LineTreeOption);
+    getImpact(changes: PropertyChanges): ChangeImpact;
+}
+export declare class LineTree extends Element<LineTreeProperties, LineTreeOption, LineTreePatch> {
+    readonly type = "lineTree";
+    get topology(): LineTreeTopology;
+    private endpointRelationIndex;
+    constructor(options?: LineTreeOption);
+    /** 把 root/leaf source relations 同步到 Root 唯一 reverse index。 */
+    private syncEndpointRelations;
+    protected getDefaultConnectionPortSchema(): any[];
+    getBindableEndpoints(): readonly BindableEndpoint[];
+    getEndpointRelationBindings(): readonly EndpointRelationBinding[];
+    readonly transform: LineTreeTransform<this>;
+    protected resolveOptions(options: LineTreePatch): LineTreePatch;
+    replaceTopology(topology: LineTreeTopology): this;
+    getEditorCapability<T>(token: EditorCapabilityToken<T>): T | undefined;
+    getSelectionBehavior(): {
+        readonly mode: SelectionBehaviorMode.Standard;
+        readonly dive: SelectionDiveMode.None;
+        readonly snap: SelectionSnapMode.Enabled;
+    };
+    getTransformPolicy(): {
+        readonly move: true;
+        readonly resize: "both";
+        readonly rotate: true;
+        readonly rotationPivot: "adjustable";
+    };
+    private materializeEffectiveTopology;
+    private preservePoseForTopology;
+    captureTransformBaseline(): ElementTransformBaseline<LineTreeTransformOwnedState>;
+    resolveTransformChange(baseline: Readonly<ElementTransformBaseline<LineTreeTransformOwnedState>>, intent: Readonly<TransformIntent | ReparentTransformIntent>): OwnerPropertyChange;
+    getWorldSnapPointsView(): readonly PointView[];
+    getEndpointRole(anchorId: AnchorId): "input" | "output";
+    getEndpointRelation(anchorId: AnchorId): EndpointRelation;
+    resolveConnectEndpointChange(anchorId: AnchorId, target: ConnectionPortRef): OwnerPropertyChange | null;
+    resolveDisconnectEndpointChange(anchorIds: readonly AnchorId[], localPositions?: ReadonlyMap<AnchorId, PointView>): OwnerPropertyChange | null;
+    resolvePointScope(point: PointView, current?: PointEditingScope): PointEditingScope | null;
+    hasPointScope(scope: PointEditingScope): boolean;
+    getPointControls(scope: PointEditingScope): import("..").PointControlDescriptor[];
+    getPointScopeOutline(scope: PointEditingScope): readonly PointView[];
+    resolvePointEdit(request: PointEditRequest): PointOwnerEdit | null;
+    getBranch(subpathId: SubpathId): import("./types").LineTreeBranch;
+    resolveSubpathAtWorldPoint(point: PointView, preferredSubpathId?: SubpathId): SubpathId;
+    /** @internal Tools 的 L 扩展只读取已提交分支的尾点。 */
+    getBranchTailSource(subpathId: SubpathId): import("./types").LineTreeBranchTailSource;
+    /** @internal Transform source-pick 只命中分支尾点，不命中树干。 */
+    resolveBranchTailAtWorldPoint(point: PointView): import("./types").LineTreeBranchTailSource;
+    paint(ctx?: CanvasRenderingContext2D): void;
+    paintHover(ctx: CanvasRenderingContext2D, scale: number): void;
+    paintBranchHighlight(ctx: CanvasRenderingContext2D, scale: number, subpathId: SubpathId): void;
+    protected onPropertiesChanged(current: LineTreeProperties, changes: PropertyChanges): void;
+    protected onActivate(root: Root | null, layer: Layer | null): void;
+    protected onDeactivate(root: Root | null, layer: Layer | null): void;
+}
+export { LineTreeTransform } from "./transform";
+export { EMPTY_LINE_TREE_TOPOLOGY, DEFAULT_LINE_TREE_BRANCH_STYLE, addLineTreeBranchAtTail, createLineTreeTopology, getLineTreeBranch, getLineTreeBindableEndpoints, getLineTreeEndpointRelationBindings, getLineTreeEndpointRole, getLineTreeJunctionAnchorIds, getLineTreePoint, getLineTreePointReferenceCounts, insertLineTreePoint, moveLineTreePoint, removeLineTreeBranch, removeLineTreePoint, remapLineTreeRelations, scaleLineTreeTopology, updateLineTreeBranchStyle } from "./topology";
+export type { LineTreeBranch, LineTreeBranchRemoval, LineTreeBranchTailSource, LineTreeBranchStyle, LineTreeBranchVertex, LineTreeOption, LineTreePoint, LineTreeTopology } from "./types";

package/dist/line-tree/topology.d.ts

@@ -0,0 +1,39 @@
+import { type AnchorId, type SegmentId, type SubpathId } from "@fulate/core";
+import type { PointView } from "@fulate/share";
+import type { Rect } from "@fulate/share";
+import type { LineEndpointRelationPatch } from "../line/base";
+import type { BindableEndpoint, EndpointRelation, EndpointRelationBinding } from "../connection/types";
+import type { LineTreeBranch, LineTreeBranchRemoval, LineTreeBranchStyle, LineTreePoint, LineTreeTopology } from "./types";
+export declare const EMPTY_LINE_TREE_TOPOLOGY: LineTreeTopology;
+export declare const DEFAULT_LINE_TREE_BRANCH_STYLE: LineTreeBranchStyle;
+export declare function getLineTreeTopologyBounds(topology: LineTreeTopology): Readonly<Rect> | null;
+export declare function createLineTreeTopology(points: readonly PointView[], style?: LineTreeBranchStyle, relations?: LineEndpointRelationPatch): LineTreeTopology;
+export declare function getLineTreePoint(topology: LineTreeTopology, anchorId: AnchorId): LineTreePoint;
+export declare function getLineTreeBranch(topology: LineTreeTopology, subpathId: SubpathId): LineTreeBranch;
+export declare function getLineTreePointReferenceCounts(topology: LineTreeTopology): Map<AnchorId, number>;
+export declare function getLineTreeJunctionAnchorIds(topology: LineTreeTopology): AnchorId[];
+export declare function getLineTreeEndpointRelationBindings(topology: LineTreeTopology, elementKey: string): readonly EndpointRelationBinding[];
+export declare function getLineTreeBindableEndpoints(topology: LineTreeTopology, elementKey: string): readonly BindableEndpoint[];
+export declare function getLineTreeEndpointRole(topology: LineTreeTopology, anchorId: AnchorId): "input" | "output";
+export declare function moveLineTreePoint(topology: LineTreeTopology, anchorId: AnchorId, point: PointView, relation: EndpointRelation | undefined): LineTreeTopology;
+export declare function insertLineTreePoint(topology: LineTreeTopology, segmentId: SegmentId, point: PointView): {
+    topology: {
+        points: LineTreePoint[];
+        branches: LineTreeBranch[];
+        rootSubpathId: SubpathId | undefined;
+    };
+    anchorId: AnchorId;
+};
+export declare function removeLineTreePoint(topology: LineTreeTopology, anchorId: AnchorId): LineTreeTopology;
+export declare function addLineTreeBranchAtTail(topology: LineTreeTopology, parentSubpathId: SubpathId, points: readonly PointView[], style?: LineTreeBranchStyle, tailRelation?: EndpointRelation): {
+    topology: {
+        points: LineTreePoint[];
+        branches: LineTreeBranch[];
+        rootSubpathId: SubpathId | undefined;
+    };
+    subpathId: SubpathId;
+};
+export declare function removeLineTreeBranch(topology: LineTreeTopology, subpathId: SubpathId): LineTreeBranchRemoval;
+export declare function updateLineTreeBranchStyle(topology: LineTreeTopology, subpathId: SubpathId, style: LineTreeBranchStyle): LineTreeTopology;
+export declare function scaleLineTreeTopology(topology: LineTreeTopology, scaleX: number, scaleY: number): LineTreeTopology;
+export declare function remapLineTreeRelations(topology: LineTreeTopology, keyMap: ReadonlyMap<string, string>): LineTreeTopology;

package/dist/line-tree/transform.d.ts

@@ -0,0 +1,54 @@
+import { ElementTransform, type AnchorId, type GeometrySnapshot, type SubpathId } from "@fulate/core";
+import { type PointView, type Rect } from "@fulate/share";
+import type { LineTree } from "./index";
+import type { LineTreeBranch, LineTreeBranchTailSource, LineTreePoint } from "./types";
+export declare class LineTreeTransform<E extends LineTree = LineTree> extends ElementTransform<E> {
+    private topologySource;
+    private pointById;
+    private branchById;
+    private junctionAnchorIds;
+    private junctionAnchorIdSet;
+    private layoutBounds;
+    private resolvedPointById;
+    private worldGeometrySource;
+    private worldBranchPoints;
+    private worldPointById;
+    private worldSnapPoints;
+    private worldMatrixA;
+    private worldMatrixB;
+    private worldMatrixC;
+    private worldMatrixD;
+    private worldMatrixE;
+    private worldMatrixF;
+    private ensureTopologyViews;
+    getPoint(anchorId: AnchorId): LineTreePoint;
+    getBranch(subpathId: SubpathId): LineTreeBranch;
+    getResolvedPoint(anchorId: AnchorId): LineTreePoint;
+    getJunctionAnchorIds(): readonly AnchorId[];
+    isJunctionAnchor(anchorId: AnchorId): boolean;
+    protected buildLayoutReferenceBounds(): Readonly<Rect>;
+    protected getWorldMatrixReferenceBounds(): Readonly<Rect>;
+    protected worldMatrixAffectsLocalGeometry(): boolean;
+    private resolveEndpointPoint;
+    protected buildGeometrySnapshot(revision: number, layoutReferenceBounds?: Readonly<Rect>): GeometrySnapshot;
+    protected buildLocalHitBounds(snapshot: GeometrySnapshot): Readonly<Rect>;
+    private getVisualPadding;
+    protected buildVisualBounds(snapshot: GeometrySnapshot): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    protected buildVisualOutline(snapshot: GeometrySnapshot): PointView[];
+    protected getOwnContentBoundsView(): Readonly<Rect>;
+    protected buildWorldVisualBounds(): import("@fulate/share").Bound;
+    hasInView(): boolean;
+    private updateWorldPoints;
+    getWorldBranchPointsView(subpathId: SubpathId): readonly PointView[];
+    getWorldPointView(anchorId: AnchorId): PointView;
+    getWorldSnapPointsView(): readonly PointView[];
+    getBranchTailSource(subpathId: SubpathId): LineTreeBranchTailSource;
+    resolveBranchTailAtWorldPoint(point: PointView): LineTreeBranchTailSource | undefined;
+    resolveSubpathAtWorldPoint(point: PointView, preferredSubpathId?: SubpathId): SubpathId;
+    hasPointHint(point: PointView): boolean;
+}

package/dist/line-tree/types.d.ts

@@ -0,0 +1,46 @@
+import type { AnchorId, BaseElementOption, SegmentId, SubpathId } from "@fulate/core";
+import type { PointView } from "@fulate/share";
+import type { EndpointRelation } from "../connection/types";
+import type { LineDecoration } from "../line/base";
+import type { LineTree } from "./index";
+export interface LineTreePoint {
+    readonly anchorId: AnchorId;
+    readonly point: PointView;
+    readonly relation?: EndpointRelation;
+}
+export interface LineTreeBranchStyle {
+    /** 显式分支线色；省略时使用 Root Skin 的 `lineStroke`。 */
+    readonly strokeColor?: string;
+    readonly strokeWidth: number;
+    readonly headDecoration: LineDecoration;
+    readonly tailDecoration: LineDecoration;
+}
+export interface LineTreeBranchVertex {
+    readonly anchorId: AnchorId;
+    readonly segmentId?: SegmentId;
+}
+export interface LineTreeBranch {
+    readonly subpathId: SubpathId;
+    readonly parentSubpathId?: SubpathId;
+    readonly closed: false;
+    readonly vertices: readonly LineTreeBranchVertex[];
+    readonly style: LineTreeBranchStyle;
+}
+export interface LineTreeTopology {
+    readonly rootSubpathId: SubpathId | undefined;
+    readonly points: readonly LineTreePoint[];
+    readonly branches: readonly LineTreeBranch[];
+}
+export interface LineTreeOption extends Omit<BaseElementOption<LineTree>, "children" | "ports"> {
+    topology?: LineTreeTopology;
+}
+export interface LineTreeBranchRemoval {
+    readonly topology: LineTreeTopology;
+    readonly parentSubpathId: SubpathId | undefined;
+}
+export interface LineTreeBranchTailSource {
+    readonly subpathId: SubpathId;
+    readonly anchorId: AnchorId;
+    readonly local: PointView;
+    readonly world: PointView;
+}

package/dist/paint/circle.d.ts

@@ -0,0 +1,3 @@
+import type { PointView } from "@fulate/share";
+/** 在当前 Canvas path 中加入圆形；不创建场景或 Geometry 对象。 */
+export declare function traceCirclePath(ctx: CanvasRenderingContext2D, center: PointView, radius: number): void;

package/dist/point-controls.d.ts

@@ -0,0 +1,6 @@
+import { type AnchorId, type ResolvedSegmentShape, type SegmentId } from "@fulate/core";
+import type { PointView } from "@fulate/share";
+import type { PointControlDescriptor } from "./editor/capability";
+export declare function createAnchorPointControl(anchorId: AnchorId, local: PointView, role: "endpoint" | "vertex", deletable: boolean): PointControlDescriptor;
+export declare function createSegmentPointControl(segmentId: SegmentId, start: PointView, end: PointView, shape?: ResolvedSegmentShape): PointControlDescriptor;
+export declare function createHandlePointControl(segmentId: SegmentId, role: "cubic-control-1" | "cubic-control-2", local: PointView, anchorLocal: PointView): PointControlDescriptor;

package/dist/polygon.d.ts

@@ -0,0 +1,52 @@
+import { type Edge, type Rect, type PointView } from "@fulate/share";
+import { ChangeImpact, ShapeProperties, type AuthoredSubpath, type GeometrySnapshot, type OwnerPropertyChange, type PropertyChanges, type ReparentTransformIntent, type ShapeOption, type ShapeOptionPatch, type ElementTransformBaseline, type TransformIntent } from "@fulate/core";
+import { type EditorCapabilityToken, type PointEditRequest, type PointEditingScope, type PointOwnerEdit } from "./editor/capability";
+import { EditorShape, EditorShapeTransform } from "./editor/shape";
+export interface PolygonOption extends ShapeOption<Polygon> {
+    /** 普通创建传 points；JSON/History/clipboard restore 直接传 canonical contour。 */
+    contour?: readonly PointView[] | AuthoredSubpath;
+}
+type PolygonPatch = ShapeOptionPatch<PolygonOption>;
+interface PolygonStateOption extends Omit<PolygonOption, "contour"> {
+    contour?: AuthoredSubpath;
+}
+declare class PolygonProperties extends ShapeProperties {
+    contour: AuthoredSubpath;
+    constructor(options?: PolygonStateOption);
+    getImpact(changes: PropertyChanges): ChangeImpact;
+}
+export declare class PolygonTransform<E extends Polygon = Polygon> extends EditorShapeTransform<E> {
+    protected buildLayoutReferenceBounds(): Readonly<Rect> | null;
+    protected buildGeometrySnapshot(revision: number, layoutReferenceBounds?: Readonly<Rect>): GeometrySnapshot;
+    protected buildVisualOutline(snapshot: GeometrySnapshot): PointView[];
+}
+/** Polygon owns exactly one closed straight canonical contour. */
+export declare class Polygon extends EditorShape<PolygonProperties, PolygonOption> {
+    readonly type = "polygon";
+    get contour(): AuthoredSubpath<import("@fulate/core").AuthoredPathAnchor>;
+    constructor(options?: PolygonOption);
+    protected resolveOptions(options: PolygonPatch): Partial<Omit<PolygonOption, "key" | "children">>;
+    getEditorCapability<T>(token: EditorCapabilityToken<T>): T | undefined;
+    resolvePointScope(worldPoint: PointView): {
+        readonly kind: "owner";
+    };
+    hasPointScope(scope: PointEditingScope): scope is {
+        readonly kind: "owner";
+    };
+    getPointControls(_scope: PointEditingScope): import(".").PointControlDescriptor[];
+    getPointScopeOutline(_scope: PointEditingScope): any;
+    resolvePointEdit(request: PointEditRequest): PointOwnerEdit | null;
+    captureTransformBaseline(): ElementTransformBaseline<AuthoredSubpath<import("@fulate/core").AuthoredPathAnchor>>;
+    resolveTransformChange(baseline: Readonly<ElementTransformBaseline<AuthoredSubpath>>, intent: Readonly<TransformIntent | ReparentTransformIntent>): OwnerPropertyChange;
+    protected buildPath(ctx: CanvasRenderingContext2D): void;
+    protected buildBorderPath(ctx: CanvasRenderingContext2D): void;
+    getEdgeSegment(edge: Edge): {
+        start: PointView;
+        end: PointView;
+    };
+    protected getDefaultConnectionPortSchema(): {
+        id: string;
+        localPosition: () => PointView;
+    }[];
+}
+export {};

package/dist/rectangle.d.ts

@@ -0,0 +1,27 @@
+import { ChangeImpact, type ElementTransformClass, ShapeProperties, type GeometrySnapshot, type PropertyChanges, type ShapeOption, type ShapeOptionPatch } from "@fulate/core";
+import { type Edge, type PointView } from "@fulate/share";
+import { EditorShape, EditorShapeTransform } from "./editor/shape";
+export interface RectangleOption<T = Rectangle> extends ShapeOption<T> {
+    radius?: number | null;
+}
+export type RectangleOptionPatch<O extends RectangleOption<any> = RectangleOption> = ShapeOptionPatch<O>;
+export declare class RectangleProperties extends ShapeProperties {
+    radius: number | null;
+    constructor(options?: RectangleOption);
+    getImpact(changes: PropertyChanges): ChangeImpact;
+}
+/** Rectangle rounded canonical geometry companion runtime。 */
+export declare class RectangleTransform<E extends Rectangle = Rectangle> extends EditorShapeTransform<E> {
+    protected buildGeometrySnapshot(revision: number, layoutReferenceBounds?: Readonly<import("@fulate/share").Rect>): GeometrySnapshot;
+}
+export declare class Rectangle<P extends RectangleProperties = RectangleProperties, O extends RectangleOption<any> = RectangleOption<any>> extends EditorShape<P, O> {
+    readonly type: string;
+    get radius(): number;
+    constructor(options?: NoInfer<O>, properties?: P, Transform?: ElementTransformClass);
+    protected buildPath(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Rectangle Ports follow its width/height box. Subclasses with different
+     * Port geometry must override this method.
+     */
+    getConnectionPortPosition(edge: Edge, ratio: number): PointView;
+}

package/dist/ripple.d.ts

@@ -0,0 +1,29 @@
+import { ChangeImpact, type Layer, type PropertyChanges, type Root } from "@fulate/core";
+import { Rectangle, RectangleProperties, type RectangleOption } from "./rectangle";
+export interface RippleOption extends RectangleOption<RippleOverlay> {
+    rippleColor?: string;
+    rippleOpacity?: number;
+    duration?: number;
+}
+declare class RippleProperties extends RectangleProperties {
+    rippleColor: string;
+    rippleOpacity: number;
+    duration: number;
+    constructor(options?: RippleOption);
+    getImpact(changes: PropertyChanges): ChangeImpact;
+}
+/** 拥有自身瞬时状态与 Tween，并在离开活动 Root 时结束它们。 */
+export declare class RippleOverlay extends Rectangle<RippleProperties, RippleOption> {
+    readonly type = "ripple";
+    get rippleColor(): string;
+    get rippleOpacity(): number;
+    get duration(): number;
+    private ripples;
+    constructor(options?: RippleOption);
+    /** 从全局逻辑坐标触发涟漪 */
+    trigger(globalX: number, globalY: number): void;
+    private spawn;
+    protected onDeactivate(root: Root | null, layer: Layer | null): void;
+    protected paintHost(ctx: CanvasRenderingContext2D): void;
+}
+export {};

package/dist/scrollview.d.ts

@@ -0,0 +1,68 @@
+import { ChangeImpact, CustomEvent, type Layer, type PropertyChanges, type Root } from "@fulate/core";
+import { Rectangle, RectangleProperties, RectangleTransform, type RectangleOption } from "./rectangle";
+import type { PointView } from "@fulate/share";
+export interface ScrollViewOption extends RectangleOption<ScrollView> {
+    scrollX?: number;
+    scrollY?: number;
+    contentWidth?: number;
+    contentHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    scrollbarSize?: number;
+    scrollbarColor?: string;
+    scrollbarTrackColor?: string;
+    scrollEndThreshold?: number;
+}
+declare class ScrollViewProperties extends RectangleProperties {
+    scrollX: number;
+    scrollY: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    scrollbarSize: number;
+    scrollbarColor: string;
+    scrollbarTrackColor: string;
+    scrollEndThreshold: number;
+    constructor(options?: ScrollViewOption);
+    getImpact(changes: PropertyChanges): ChangeImpact;
+}
+export declare class ScrollViewTransform<E extends ScrollView = ScrollView> extends RectangleTransform<E> {
+    private readonly childWorldMatrix;
+    protected onChildrenChanged(): void;
+    protected onDescendantDirty(): void;
+    protected getChildWorldMatrixView(): DOMMatrixReadOnly;
+    protected resolveFitSize(): void;
+}
+export declare class ScrollView extends Rectangle<ScrollViewProperties, ScrollViewOption> {
+    readonly type = "scrollview";
+    get scrollX(): number;
+    get scrollY(): number;
+    get maxWidth(): number;
+    get maxHeight(): number;
+    get scrollbarSize(): number;
+    get scrollbarColor(): string;
+    get scrollbarTrackColor(): string;
+    get scrollEndThreshold(): number;
+    contentWidth: number;
+    contentHeight: number;
+    private verticalThumb;
+    private horizontalThumb;
+    private dragging;
+    private dragAxis;
+    private dragStartScroll;
+    private dragStartPointer;
+    private interactionAbort;
+    constructor(options?: ScrollViewOption);
+    protected fireCallbacks(event: CustomEvent): void;
+    protected onActivate(root: Root | null, layer: Layer | null): void;
+    protected onDeactivate(root: Root | null, layer: Layer | null): void;
+    getChildClipRect(): Readonly<import("@fulate/share").Rect>;
+    /** ScrollView paints a rectangular viewport even when its border is rounded. */
+    containsChildClipPoint(point: PointView): boolean;
+    scrollTo(x: number, y: number): void;
+    scrollBy(dx: number, dy: number): void;
+    protected paintHost(ctx: CanvasRenderingContext2D): void;
+    protected paintScrollbars(ctx: CanvasRenderingContext2D): void;
+    private hitThumb;
+    private initDragInteraction;
+}
+export {};

package/dist/text/block.d.ts

@@ -0,0 +1,31 @@
+import type { Rect } from "@fulate/share";
+import { TextLayoutSnapshot, type TextLayoutMetrics } from "./layout";
+import { type ResolvedTextStyle } from "./style";
+export interface TextBlockLayoutInput {
+    readonly text: string;
+    readonly style: ResolvedTextStyle;
+    readonly width?: number;
+    readonly height?: number;
+    readonly overflow: "hidden" | "visible";
+    readonly wordWrap?: boolean;
+    readonly maxLines?: number;
+    readonly ellipsis?: boolean;
+}
+/** Text 与内部组合共享的唯一准备和最终排版 owner。 */
+export declare class TextBlock {
+    private prepared;
+    private metrics;
+    private metricsKey;
+    private snapshot;
+    private snapshotKey;
+    get layout(): TextLayoutSnapshot;
+    /** Yoga 只需要这个紧凑结果；这里不生成 PaintLine/source range。 */
+    measure(input: TextBlockLayoutInput): TextLayoutMetrics;
+    /** Final width 已确定后生成一次 PaintLine snapshot，后续直接复用。 */
+    sync(input: TextBlockLayoutInput): TextLayoutSnapshot;
+    invalidate(): void;
+    private getPrepared;
+    private getLayoutKey;
+}
+/** 返回与共享 glyph painter 一致的文字 visual bounds。 */
+export declare function getTextBlockVisualBounds(layout: TextLayoutSnapshot, style: ResolvedTextStyle, width: number, height: number): Rect | null;