@retikz/core 0.1.0-alpha.0 → 0.1.0-alpha.1

package/dist/es/geometry/ellipse.js

@@ -0,0 +1,86 @@
+//#region src/geometry/ellipse.ts
+var SQRT_HALF = Math.SQRT1_2;
+var localToWorld = (e, local) => {
+	const angle = e.rotate ?? 0;
+	if (angle === 0) return [e.x + local[0], e.y + local[1]];
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	return [e.x + local[0] * cos - local[1] * sin, e.y + local[0] * sin + local[1] * cos];
+};
+var worldToLocal = (e, world) => {
+	const tx = world[0] - e.x;
+	const ty = world[1] - e.y;
+	const angle = e.rotate ?? 0;
+	if (angle === 0) return [tx, ty];
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	return [tx * cos + ty * sin, -tx * sin + ty * cos];
+};
+/** 椭圆相关基础工具 */
+var ellipse = {
+	/** 中心 */
+	center: (e) => [e.x, e.y],
+	/** 判断点是否在椭圆内（含边界，考虑旋转） */
+	contains: (e, p) => {
+		const [lx, ly] = worldToLocal(e, p);
+		return lx * lx / (e.rx * e.rx) + ly * ly / (e.ry * e.ry) <= 1;
+	},
+	/**
+	* 9 个标准 anchor 的世界坐标。
+	* 对角 anchor（NE/NW/SE/SW）取参数曲线 t=π/4 处的点：
+	* (rx·cos(π/4), ry·sin(π/4)) = (rx/√2, ry/√2)。
+	* 这与 TikZ 椭圆对角 anchor 的"参数等分"约定一致。
+	*/
+	anchor: (e, name) => {
+		let lx = 0;
+		let ly = 0;
+		switch (name) {
+			case "center": break;
+			case "north":
+				ly = -e.ry;
+				break;
+			case "south":
+				ly = e.ry;
+				break;
+			case "east":
+				lx = e.rx;
+				break;
+			case "west":
+				lx = -e.rx;
+				break;
+			case "north-east":
+				lx = e.rx * SQRT_HALF;
+				ly = -e.ry * SQRT_HALF;
+				break;
+			case "north-west":
+				lx = -e.rx * SQRT_HALF;
+				ly = -e.ry * SQRT_HALF;
+				break;
+			case "south-east":
+				lx = e.rx * SQRT_HALF;
+				ly = e.ry * SQRT_HALF;
+				break;
+			case "south-west":
+				lx = -e.rx * SQRT_HALF;
+				ly = e.ry * SQRT_HALF;
+				break;
+		}
+		return localToWorld(e, [lx, ly]);
+	},
+	/**
+	* 从中心向 toward 方向画射线，求与椭圆的交点。
+	* 椭圆方程：(x/rx)² + (y/ry)² = 1。
+	* 沿方向 (lx, ly) 缩放 t 倍命中：t² × ((lx/rx)² + (ly/ry)²) = 1
+	* → t = 1 / √((lx/rx)² + (ly/ry)²)。
+	*/
+	boundaryPoint: (e, toward) => {
+		const [lx, ly] = worldToLocal(e, toward);
+		if (lx === 0 && ly === 0) return [e.x, e.y];
+		const a = lx / e.rx;
+		const b = ly / e.ry;
+		const t = 1 / Math.sqrt(a * a + b * b);
+		return localToWorld(e, [lx * t, ly * t]);
+	}
+};
+//#endregion
+export { ellipse };

package/dist/es/geometry/index.d.ts

@@ -1,4 +1,7 @@
 export * from './point';
 export * from './rect';
+export * from './circle';
+export * from './ellipse';
+export * from './diamond';
 export * from './polar';
 //# sourceMappingURL=index.d.ts.map

package/dist/es/geometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}

package/dist/es/index.d.ts

@@ -6,13 +6,15 @@
  *
  * 本包零 React、零 DOM 依赖。
  */
-export { PositionSchema, PolarPositionSchema, TargetSchema, MoveStepSchema, LineStepSchema, StepSchema, NodeSchema, PathSchema, ChildSchema, SceneSchema, CURRENT_IR_VERSION, } from './ir';
-export type { IRPosition, IRTarget, IRMoveStep, IRLineStep, IRStep, IRNode, IRPath, IRChild, IR, } from './ir';
-export type { ScenePrimitive, RectPrim, TextPrim, PathPrim, GroupPrim, ViewBox, Scene, } from './primitive';
+export { PositionSchema, PolarPositionSchema, TargetSchema, MoveStepSchema, LineStepSchema, FoldStepSchema, CycleStepSchema, StepSchema, NodeSchema, PathSchema, ChildSchema, SceneSchema, CURRENT_IR_VERSION, } from './ir';
+export type { IRPosition, IRTarget, IRMoveStep, IRLineStep, IRFoldStep, IRCycleStep, IRStep, IRNode, IRPath, IRChild, IR, ArrowShape, NodeShape, } from './ir';
+export { ARROW_SHAPES, NODE_SHAPES } from './ir';
+export type { ScenePrimitive, RectPrim, EllipsePrim, TextPrim, PathPrim, GroupPrim, ViewBox, Scene, } from './primitive';
 export type { FontSpec, TextMetrics, TextMeasurer, CompileOptions, } from './compile';
 export { fallbackMeasurer, compileToScene } from './compile';
-export type { WayItem, WayDSL } from './parsers';
-export { parseWay } from './parsers';
-export type { Position, Rect, RectAnchor, PolarPosition } from './geometry';
-export { point, rect, RECT_ANCHORS, polar } from './geometry';
+export type { WayItem, WayDSL, WayCycle, WayVia } from './parsers';
+export { parseWay, DrawWay } from './parsers';
+export type { Position, Rect, RectAnchor, Circle, CircleAnchor, Ellipse, EllipseAnchor, Diamond, DiamondAnchor, PolarPosition, } from './geometry';
+export { point, rect, circle, ellipse, diamond, RECT_ANCHORS, polar } from './geometry';
+export type { ValueOf } from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/es/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACX,kBAAkB,GACnB,MAAM,MAAM,CAAC;AACd,YAAY,EACV,UAAU,EACV,QAAQ,EACR,UAAU,EACV,UAAU,EACV,MAAM,EACN,MAAM,EACN,MAAM,EACN,OAAO,EACP,EAAE,GACH,MAAM,MAAM,CAAC;AAGd,YAAY,EACV,cAAc,EACd,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,OAAO,EACP,KAAK,GACN,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,cAAc,GACf,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG7D,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAIrC,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,cAAc,EACd,eAAe,EACf,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACX,kBAAkB,GACnB,MAAM,MAAM,CAAC;AACd,YAAY,EACV,UAAU,EACV,QAAQ,EACR,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,MAAM,EACN,MAAM,EACN,MAAM,EACN,OAAO,EACP,EAAE,EACF,UAAU,EACV,SAAS,GACV,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,MAAM,CAAC;AAGjD,YAAY,EACV,cAAc,EACd,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,OAAO,EACP,KAAK,GACN,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,cAAc,GACf,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG7D,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAI9C,YAAY,EACV,QAAQ,EACR,IAAI,EACJ,UAAU,EACV,MAAM,EACN,YAAY,EACZ,OAAO,EACP,aAAa,EACb,OAAO,EACP,aAAa,EACb,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxF,YAAY,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC"}

package/dist/es/index.js

@@ -1,14 +1,18 @@
 import { PositionSchema } from "./ir/position/position.js";
 import { PolarPositionSchema } from "./ir/position/polar-position.js";
+import { ARROW_SHAPES } from "./ir/path/arrow.js";
 import { TargetSchema } from "./ir/path/target.js";
-import { LineStepSchema, MoveStepSchema, StepSchema } from "./ir/path/step.js";
+import { CycleStepSchema, FoldStepSchema, LineStepSchema, MoveStepSchema, StepSchema } from "./ir/path/step.js";
 import { PathSchema } from "./ir/path/path.js";
-import { NodeSchema } from "./ir/node.js";
+import { NODE_SHAPES, NodeSchema } from "./ir/node.js";
 import { CURRENT_IR_VERSION, ChildSchema, SceneSchema } from "./ir/scene.js";
 import { RECT_ANCHORS, rect } from "./geometry/rect.js";
+import { circle } from "./geometry/circle.js";
+import { diamond } from "./geometry/diamond.js";
+import { ellipse } from "./geometry/ellipse.js";
 import { fallbackMeasurer } from "./compile/text-metrics.js";
 import { compileToScene } from "./compile/compile.js";
-import { parseWay } from "./parsers/parseWay.js";
+import { DrawWay, parseWay } from "./parsers/parseWay.js";
 import { polar } from "./geometry/polar.js";
 import { point } from "./geometry/point.js";
-export { CURRENT_IR_VERSION, ChildSchema, LineStepSchema, MoveStepSchema, NodeSchema, PathSchema, PolarPositionSchema, PositionSchema, RECT_ANCHORS, SceneSchema, StepSchema, TargetSchema, compileToScene, fallbackMeasurer, parseWay, point, polar, rect };
+export { ARROW_SHAPES, CURRENT_IR_VERSION, ChildSchema, CycleStepSchema, DrawWay, FoldStepSchema, LineStepSchema, MoveStepSchema, NODE_SHAPES, NodeSchema, PathSchema, PolarPositionSchema, PositionSchema, RECT_ANCHORS, SceneSchema, StepSchema, TargetSchema, circle, compileToScene, diamond, ellipse, fallbackMeasurer, parseWay, point, polar, rect };

package/dist/es/ir/node.d.ts

@@ -1,7 +1,37 @@
 import { z } from 'zod';
+import { ValueOf } from '../types';
+/**
+ * 节点形状常量。值是 IR 中 `shape` 字段的字面字符串；
+ * 用 const + ValueOf 派生（不用 TS enum）。
+ *
+ * - `rectangle`：矩形（默认；UML 类、流程图常规节点）
+ * - `circle`：圆形（流程图起止、状态机）
+ * - `ellipse`：椭圆（状态机、集合图）
+ * - `diamond`：菱形（流程图判定）
+ *
+ * 每个 shape 的几何语义：node 的视觉边界包住"text 矩形 + padding"——
+ * - rectangle: 视觉 rect = text rect
+ * - circle:    外接圆，r = √(innerHalfW² + innerHalfH²)
+ * - ellipse:   外接椭圆，rx = innerHalfW×√2、ry = innerHalfH×√2
+ * - diamond:   外接菱形，halfA = 2×innerHalfW、halfB = 2×innerHalfH
+ */
+export declare const NODE_SHAPES: {
+    readonly rectangle: "rectangle";
+    readonly circle: "circle";
+    readonly ellipse: "ellipse";
+    readonly diamond: "diamond";
+};
+/** 节点形状字面量类型，由 `NODE_SHAPES` 派生 */
+export type NodeShape = ValueOf<typeof NODE_SHAPES>;
 export declare const NodeSchema: z.ZodObject<{
     type: z.ZodLiteral<"node">;
     id: z.ZodOptional<z.ZodString>;
+    shape: z.ZodOptional<z.ZodNativeEnum<{
+        readonly rectangle: "rectangle";
+        readonly circle: "circle";
+        readonly ellipse: "ellipse";
+        readonly diamond: "diamond";
+    }>>;
     position: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>]>;
     rotate: z.ZodOptional<z.ZodNumber>;
     text: z.ZodOptional<z.ZodString>;
@@ -15,6 +45,7 @@ export declare const NodeSchema: z.ZodObject<{
     type: "node";
     position: [number, number] | import('./position').PolarPosition;
     fill?: string | undefined;
+    shape?: "diamond" | "circle" | "rectangle" | "ellipse" | undefined;
     stroke?: string | undefined;
     strokeWidth?: number | undefined;
     id?: string | undefined;
@@ -27,6 +58,7 @@ export declare const NodeSchema: z.ZodObject<{
     type: "node";
     position: [number, number] | import('./position').PolarPosition;
     fill?: string | undefined;
+    shape?: "diamond" | "circle" | "rectangle" | "ellipse" | undefined;
     stroke?: string | undefined;
     strokeWidth?: number | undefined;
     id?: string | undefined;
@@ -36,6 +68,6 @@ export declare const NodeSchema: z.ZodObject<{
     margin?: number | undefined;
     fontSize?: number | undefined;
 }>;
-/** 节点：矩形 + 可选文本标签，是最基础的有定位图元 */
+/** 节点：可定位的形状容器（矩形 / 圆 / 椭圆 / 菱形）+ 可选文本标签 */
 export type IRNode = z.infer<typeof NodeSchema>;
 //# sourceMappingURL=node.d.ts.map

package/dist/es/ir/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/ir/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEpB,CAAC;AAEJ,gCAAgC;AAChC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/ir/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAGxC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;;;;;CAKd,CAAC;AAEX,mCAAmC;AACnC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,WAAW,CAAC,CAAC;AAEpD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuEpB,CAAC;AAEJ,4CAA4C;AAC5C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/es/ir/node.js

@@ -2,18 +2,40 @@ import { PositionSchema } from "./position/position.js";
 import { PolarPositionSchema } from "./position/polar-position.js";
 import { z } from "zod";
 //#region src/ir/node.ts
+/**
+* 节点形状常量。值是 IR 中 `shape` 字段的字面字符串；
+* 用 const + ValueOf 派生（不用 TS enum）。
+*
+* - `rectangle`：矩形（默认；UML 类、流程图常规节点）
+* - `circle`：圆形（流程图起止、状态机）
+* - `ellipse`：椭圆（状态机、集合图）
+* - `diamond`：菱形（流程图判定）
+*
+* 每个 shape 的几何语义：node 的视觉边界包住"text 矩形 + padding"——
+* - rectangle: 视觉 rect = text rect
+* - circle:    外接圆，r = √(innerHalfW² + innerHalfH²)
+* - ellipse:   外接椭圆，rx = innerHalfW×√2、ry = innerHalfH×√2
+* - diamond:   外接菱形，halfA = 2×innerHalfW、halfB = 2×innerHalfH
+*/
+var NODE_SHAPES = {
+	rectangle: "rectangle",
+	circle: "circle",
+	ellipse: "ellipse",
+	diamond: "diamond"
+};
 var NodeSchema = z.object({
 	type: z.literal("node").describe("Discriminator marking this child as a node"),
 	id: z.string().min(1).optional().describe("Optional unique id; required if any path needs to reference this node by string"),
+	shape: z.nativeEnum(NODE_SHAPES).optional().describe("Node visual shape; defaults to `rectangle`. The boundary fully contains text + padding (circumscribed for circle / ellipse / diamond)."),
 	position: z.union([PositionSchema, PolarPositionSchema]).describe("Center point of the node content box; Cartesian [x, y] or polar (resolved at compile time)"),
 	rotate: z.number().optional().describe("Rotation in degrees around the node center; positive = clockwise (matches TikZ rotate=...)"),
 	text: z.string().optional().describe("Text label rendered inside the node; omit for an empty node"),
-	fill: z.string().optional().describe("Background color of the node rectangle; any CSS color (e.g. \"lightblue\", \"#fafafa\", \"rgba(...)\")"),
-	stroke: z.string().optional().describe("Border color of the node rectangle; any CSS color. Defaults to currentColor when omitted"),
+	fill: z.string().optional().describe("Background color of the node shape; any CSS color (e.g. \"lightblue\", \"#fafafa\", \"rgba(...)\")"),
+	stroke: z.string().optional().describe("Border color of the node shape; any CSS color. Defaults to currentColor when omitted"),
 	strokeWidth: z.number().optional().describe("Border width in user units; defaults to 1 when omitted"),
 	padding: z.number().optional().describe("Inner padding in user units between the text content and the node border"),
 	margin: z.number().nonnegative().optional().describe("Outer margin in user units: distance between the visual border and where paths attach. Lines stop this far from the border. Defaults to 0."),
 	fontSize: z.number().optional().describe("Text font size in user units; defaults to a fixed size for now (TikZ font sizes will be supported later)")
-}).describe("Rectangle node with optional text label; the basic positional drawing primitive");
+}).describe("Node primitive: a positioned, optionally textual shape (rectangle / circle / ellipse / diamond)");
 //#endregion
-export { NodeSchema };
+export { NODE_SHAPES, NodeSchema };

package/dist/es/ir/path/arrow.d.ts

@@ -0,0 +1,26 @@
+import { ValueOf } from '../../types';
+/**
+ * 箭头形状常量。值就是 IR / Scene 中 arrow 字段的字面字符串；
+ * 用 const 而不是 TS enum——避免 enum 在数值场景生成 reverse-mapping、
+ * 在 string 场景与字面量类型不互通的两个坑。
+ *
+ * - `normal`：实心三角（默认；最常见）
+ * - `open`：空心三角（UML 泛化 / 继承）
+ * - `stealth`：尖锐倒钩三角（流图常见、视觉锐利）
+ * - `diamond`：实心菱形（UML 组合）
+ * - `openDiamond`：空心菱形（UML 聚合）
+ * - `circle`：实心圆点（连接点 / dot end）
+ * - `openCircle`：空心圆点（白圈 / o-end）
+ */
+export declare const ARROW_SHAPES: {
+    readonly normal: "normal";
+    readonly open: "open";
+    readonly stealth: "stealth";
+    readonly diamond: "diamond";
+    readonly openDiamond: "openDiamond";
+    readonly circle: "circle";
+    readonly openCircle: "openCircle";
+};
+/** 箭头形状字面量类型，由 `ARROW_SHAPES` 派生 */
+export type ArrowShape = ValueOf<typeof ARROW_SHAPES>;
+//# sourceMappingURL=arrow.d.ts.map

package/dist/es/ir/path/arrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/arrow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY;;;;;;;;CAQf,CAAC;AAEX,oCAAoC;AACpC,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/es/ir/path/arrow.js

@@ -0,0 +1,25 @@
+//#region src/ir/path/arrow.ts
+/**
+* 箭头形状常量。值就是 IR / Scene 中 arrow 字段的字面字符串；
+* 用 const 而不是 TS enum——避免 enum 在数值场景生成 reverse-mapping、
+* 在 string 场景与字面量类型不互通的两个坑。
+*
+* - `normal`：实心三角（默认；最常见）
+* - `open`：空心三角（UML 泛化 / 继承）
+* - `stealth`：尖锐倒钩三角（流图常见、视觉锐利）
+* - `diamond`：实心菱形（UML 组合）
+* - `openDiamond`：空心菱形（UML 聚合）
+* - `circle`：实心圆点（连接点 / dot end）
+* - `openCircle`：空心圆点（白圈 / o-end）
+*/
+var ARROW_SHAPES = {
+	normal: "normal",
+	open: "open",
+	stealth: "stealth",
+	diamond: "diamond",
+	openDiamond: "openDiamond",
+	circle: "circle",
+	openCircle: "openCircle"
+};
+//#endregion
+export { ARROW_SHAPES };

package/dist/es/ir/path/index.d.ts

@@ -1,3 +1,4 @@
+export * from './arrow';
 export * from './path';
 export * from './step';
 export * from './target';

package/dist/es/ir/path/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}

package/dist/es/ir/path/path.d.ts

@@ -4,6 +4,18 @@ export declare const PathSchema: z.ZodObject<{
     stroke: z.ZodOptional<z.ZodString>;
     strokeWidth: z.ZodOptional<z.ZodNumber>;
     strokeDasharray: z.ZodOptional<z.ZodString>;
+    arrow: z.ZodOptional<z.ZodEnum<["none", "->", "<-", "<->"]>>;
+    arrowShape: z.ZodOptional<z.ZodNativeEnum<{
+        readonly normal: "normal";
+        readonly open: "open";
+        readonly stealth: "stealth";
+        readonly diamond: "diamond";
+        readonly openDiamond: "openDiamond";
+        readonly circle: "circle";
+        readonly openCircle: "openCircle";
+    }>>;
+    fill: z.ZodOptional<z.ZodString>;
+    fillRule: z.ZodOptional<z.ZodEnum<["nonzero", "evenodd"]>>;
     children: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         type: z.ZodLiteral<"step">;
         kind: z.ZodLiteral<"move">;
@@ -28,6 +40,30 @@ export declare const PathSchema: z.ZodObject<{
         type: "step";
         kind: "line";
         to: string | [number, number] | import('..').PolarPosition;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        kind: z.ZodLiteral<"step">;
+        via: z.ZodEnum<["-|", "|-"]>;
+        to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('..').PolarPosition;
+        via: "-|" | "|-";
+    }, {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('..').PolarPosition;
+        via: "-|" | "|-";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        kind: z.ZodLiteral<"cycle">;
+    }, "strip", z.ZodTypeAny, {
+        type: "step";
+        kind: "cycle";
+    }, {
+        type: "step";
+        kind: "cycle";
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     type: "path";
@@ -39,10 +75,22 @@ export declare const PathSchema: z.ZodObject<{
         type: "step";
         kind: "line";
         to: string | [number, number] | import('..').PolarPosition;
+    } | {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('..').PolarPosition;
+        via: "-|" | "|-";
+    } | {
+        type: "step";
+        kind: "cycle";
     })[];
+    fill?: string | undefined;
     stroke?: string | undefined;
     strokeWidth?: number | undefined;
     strokeDasharray?: string | undefined;
+    arrow?: "none" | "->" | "<-" | "<->" | undefined;
+    arrowShape?: "normal" | "open" | "stealth" | "diamond" | "openDiamond" | "circle" | "openCircle" | undefined;
+    fillRule?: "nonzero" | "evenodd" | undefined;
 }, {
     type: "path";
     children: ({
@@ -53,10 +101,22 @@ export declare const PathSchema: z.ZodObject<{
         type: "step";
         kind: "line";
         to: string | [number, number] | import('..').PolarPosition;
+    } | {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('..').PolarPosition;
+        via: "-|" | "|-";
+    } | {
+        type: "step";
+        kind: "cycle";
     })[];
+    fill?: string | undefined;
     stroke?: string | undefined;
     strokeWidth?: number | undefined;
     strokeDasharray?: string | undefined;
+    arrow?: "none" | "->" | "<-" | "<->" | undefined;
+    arrowShape?: "normal" | "open" | "stealth" | "diamond" | "openDiamond" | "circle" | "openCircle" | undefined;
+    fillRule?: "nonzero" | "evenodd" | undefined;
 }>;
 /** 路径：由若干 step 动作（move / line / ...）组成的绘制路径 */
 export type IRPath = z.infer<typeof PathSchema>;

package/dist/es/ir/path/path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BpB,CAAC;AAEJ,+CAA+C;AAC/C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsDpB,CAAC;AAEJ,+CAA+C;AAC/C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/es/ir/path/path.js

@@ -1,3 +1,4 @@
+import { ARROW_SHAPES } from "./arrow.js";
 import { StepSchema } from "./step.js";
 import { z } from "zod";
 //#region src/ir/path/path.ts
@@ -6,6 +7,15 @@ var PathSchema = z.object({
 	stroke: z.string().optional().describe("Stroke color of the path; any CSS color. Defaults to currentColor when omitted"),
 	strokeWidth: z.number().optional().describe("Stroke width in user units; defaults to 1 when omitted"),
 	strokeDasharray: z.string().optional().describe("SVG stroke-dasharray pattern (e.g. \"4 2\"); leave empty for solid line"),
+	arrow: z.enum([
+		"none",
+		"->",
+		"<-",
+		"<->"
+	]).optional().describe("Path-level arrow direction. omitted/`none` = no arrows; `->` = arrow at end; `<-` = at start; `<->` = both."),
+	arrowShape: z.nativeEnum(ARROW_SHAPES).optional().describe("Arrow tip shape; default `normal` (filled triangle). Other values: `open` (hollow triangle), `stealth` (sharp barb), `diamond`, `circle`."),
+	fill: z.string().optional().describe("Fill color of the closed region; any CSS color. Omitted = no fill (stroke only). Pairs with `cycle` step for filled shapes."),
+	fillRule: z.enum(["nonzero", "evenodd"]).optional().describe("How self-intersecting / nested sub-paths are filled. `nonzero` (default, SVG default) winds-by-direction; `evenodd` toggles fill on each crossing — useful for ring / donut shapes."),
 	children: z.array(StepSchema).min(2).describe("Sequence of step actions defining the path; the first should usually be a `move`")
 }).describe("A drawn path composed of a sequence of step actions (move / line / ...)");
 //#endregion

package/dist/es/ir/path/step.d.ts

@@ -25,6 +25,32 @@ export declare const LineStepSchema: z.ZodObject<{
     kind: "line";
     to: string | [number, number] | import('..').PolarPosition;
 }>;
+export declare const FoldStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"step">;
+    via: z.ZodEnum<["-|", "|-"]>;
+    to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "step";
+    to: string | [number, number] | import('..').PolarPosition;
+    via: "-|" | "|-";
+}, {
+    type: "step";
+    kind: "step";
+    to: string | [number, number] | import('..').PolarPosition;
+    via: "-|" | "|-";
+}>;
+export declare const CycleStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"cycle">;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "cycle";
+}, {
+    type: "step";
+    kind: "cycle";
+}>;
 export declare const StepSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
     type: z.ZodLiteral<"step">;
     kind: z.ZodLiteral<"move">;
@@ -49,14 +75,42 @@ export declare const StepSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
     type: "step";
     kind: "line";
     to: string | [number, number] | import('..').PolarPosition;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"step">;
+    via: z.ZodEnum<["-|", "|-"]>;
+    to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "step";
+    to: string | [number, number] | import('..').PolarPosition;
+    via: "-|" | "|-";
+}, {
+    type: "step";
+    kind: "step";
+    to: string | [number, number] | import('..').PolarPosition;
+    via: "-|" | "|-";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"cycle">;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "cycle";
+}, {
+    type: "step";
+    kind: "cycle";
 }>]>;
 /** Move step：移动游标但不绘制 */
 export type IRMoveStep = z.infer<typeof MoveStepSchema>;
 /** Line step：从游标到目标画直线 */
 export type IRLineStep = z.infer<typeof LineStepSchema>;
+/** Fold step：折角段，从游标到目标经一个直角中间点（TikZ `-|` / `|-`） */
+export type IRFoldStep = z.infer<typeof FoldStepSchema>;
+/** Cycle step：把当前子路径闭合回起点（TikZ `cycle` / SVG `Z`） */
+export type IRCycleStep = z.infer<typeof CycleStepSchema>;
 /**
- * 路径上的一个动作。v0.1.0-alpha 仅支持 'move' 与 'line'。
- * 后续会加 'step'（折角）、'curve'、'cubic'、'rel'、'close' 等。
+ * 路径上的一个动作。v0.1.0-alpha.1 支持 'move' / 'line' / 'step'（折角）/ 'cycle'（闭合）。
+ * 后续会加 'curve'、'cubic'、'rel' 等。
  */
 export type IRStep = z.infer<typeof StepSchema>;
 //# sourceMappingURL=step.d.ts.map

package/dist/es/ir/path/step.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/step.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,cAAc;;;;;;;;;;;;EAQyC,CAAC;AAErE,eAAO,MAAM,cAAc;;;;;;;;;;;;EAQ4C,CAAC;AAExE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;IAE+C,CAAC;AAEvE,yBAAyB;AACzB,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD,0BAA0B;AAC1B,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}
+{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/step.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,cAAc;;;;;;;;;;;;EAQyC,CAAC;AAErE,eAAO,MAAM,cAAc;;;;;;;;;;;;EAQ4C,CAAC;AAExE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAiBxB,CAAC;AAEJ,eAAO,MAAM,eAAe;;;;;;;;;EAWzB,CAAC;AAEJ,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE+C,CAAC;AAEvE,yBAAyB;AACzB,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD,0BAA0B;AAC1B,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD,qDAAqD;AACrD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD,qDAAqD;AACrD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE1D;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/es/ir/path/step.js

@@ -11,6 +11,21 @@ var LineStepSchema = z.object({
 	kind: z.literal("line").describe("Draw a straight line from the current cursor to the target (like SVG path \"L\")"),
 	to: TargetSchema.describe("Destination point of the line segment")
 }).describe("Line action: straight-line segment from cursor to target");
-var StepSchema = z.discriminatedUnion("kind", [MoveStepSchema, LineStepSchema]).describe("A single path action; the discriminator field is `kind`");
+var FoldStepSchema = z.object({
+	type: z.literal("step").describe("Discriminator marking this as a path step node"),
+	kind: z.literal("step").describe("Folded right-angle segment from cursor to target through one intermediate point (TikZ `-|` / `|-`)"),
+	via: z.enum(["-|", "|-"]).describe("Folding direction: `-|` first horizontal then vertical; `|-` first vertical then horizontal"),
+	to: TargetSchema.describe("Destination point of the folded segment")
+}).describe("Fold action: TikZ-style right-angle fold with a single intermediate point chosen by `via`");
+var CycleStepSchema = z.object({
+	type: z.literal("step").describe("Discriminator marking this as a path step node"),
+	kind: z.literal("cycle").describe("Close the path back to the most recent move target (TikZ `cycle` / SVG path \"Z\")")
+}).describe("Cycle action: close the current sub-path back to its starting point; carries no `to` field");
+var StepSchema = z.discriminatedUnion("kind", [
+	MoveStepSchema,
+	LineStepSchema,
+	FoldStepSchema,
+	CycleStepSchema
+]).describe("A single path action; the discriminator field is `kind`");
 //#endregion
-export { LineStepSchema, MoveStepSchema, StepSchema };
+export { CycleStepSchema, FoldStepSchema, LineStepSchema, MoveStepSchema, StepSchema };