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

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

@@ -1,41 +1,353 @@
 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>;
+/**
+ * 节点字体规格——family / size / weight / style 全部可选；
+ * 单字段透传到 SVG `<text>` 的 `font-*` 属性 / `font-size`。
+ *
+ * 取代 alpha.1 的标量 `fontSize` 字段（已删）。
+ */
+export declare const FontSchema: z.ZodObject<{
+    family: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+    weight: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["normal", "bold"]>, z.ZodNumber]>>;
+    style: z.ZodOptional<z.ZodEnum<["normal", "italic", "oblique"]>>;
+}, "strip", z.ZodTypeAny, {
+    family?: string | undefined;
+    size?: number | undefined;
+    weight?: number | "normal" | "bold" | undefined;
+    style?: "normal" | "italic" | "oblique" | undefined;
+}, {
+    family?: string | undefined;
+    size?: number | undefined;
+    weight?: number | "normal" | "bold" | undefined;
+    style?: "normal" | "italic" | "oblique" | undefined;
+}>;
+/** 节点字体规格（IR 层）——所有字段可选，编译期解析默认值 */
+export type IRFont = z.infer<typeof FontSchema>;
+/**
+ * 单行文本规格——纯字符串走块级默认样式；对象形式可对该行覆盖 fill / opacity / font。
+ *
+ * 行级覆盖只生效于本行的 `<tspan>`：
+ * - `fill`：仅这一行颜色
+ * - `opacity`：仅这一行 0~1 透明度
+ * - `font`：family / size / weight / style 任意子集；未填字段继承块级 font
+ *
+ * 块级 `align` / `lineHeight` 不可被行覆盖（多行块整体属性）。
+ */
+export declare const LineSpecSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
+    text: z.ZodString;
+    fill: z.ZodOptional<z.ZodString>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+    font: z.ZodOptional<z.ZodObject<{
+        family: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["normal", "bold"]>, z.ZodNumber]>>;
+        style: z.ZodOptional<z.ZodEnum<["normal", "italic", "oblique"]>>;
+    }, "strip", z.ZodTypeAny, {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    }, {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    fill?: string | undefined;
+    opacity?: number | undefined;
+    font?: {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    } | undefined;
+}, {
+    text: string;
+    fill?: string | undefined;
+    opacity?: number | undefined;
+    font?: {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    } | undefined;
+}>]>;
+/** 行规格 IR 类型（string 或对象） */
+export type IRLineSpec = z.infer<typeof LineSpecSchema>;
+/**
+ * 节点文本——单行字符串或非空多行数组（每元素一个 LineSpec）：
+ * - `'Hello'` 等价于 `[{ text: 'Hello' }]`，按一行渲染
+ * - `['Line 1', 'Line 2']` 两行无样式覆盖
+ * - `[{ text: 'Heading', fill: 'red', font: { weight: 'bold' } }, 'body']` 混排
+ *
+ * 选 `Array<LineSpec>` 而非 `'\n'` 字符串：JSON 友好（无 escape）；行级覆盖天然落字段。
+ */
+export declare const NodeTextSchema: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+    text: z.ZodString;
+    fill: z.ZodOptional<z.ZodString>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+    font: z.ZodOptional<z.ZodObject<{
+        family: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["normal", "bold"]>, z.ZodNumber]>>;
+        style: z.ZodOptional<z.ZodEnum<["normal", "italic", "oblique"]>>;
+    }, "strip", z.ZodTypeAny, {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    }, {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    fill?: string | undefined;
+    opacity?: number | undefined;
+    font?: {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    } | undefined;
+}, {
+    text: string;
+    fill?: string | undefined;
+    opacity?: number | undefined;
+    font?: {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    } | undefined;
+}>]>, "many">]>;
+/** 节点文本对齐（多行内文本对齐）——TikZ `align=` 同义词 */
+export declare const NODE_TEXT_ALIGNS: {
+    readonly left: "left";
+    readonly center: "center";
+    readonly right: "right";
+};
+/** 多行文本对齐字面量类型 */
+export type NodeTextAlign = ValueOf<typeof NODE_TEXT_ALIGNS>;
 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>;
+    text: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        text: z.ZodString;
+        fill: z.ZodOptional<z.ZodString>;
+        opacity: z.ZodOptional<z.ZodNumber>;
+        font: z.ZodOptional<z.ZodObject<{
+            family: z.ZodOptional<z.ZodString>;
+            size: z.ZodOptional<z.ZodNumber>;
+            weight: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["normal", "bold"]>, z.ZodNumber]>>;
+            style: z.ZodOptional<z.ZodEnum<["normal", "italic", "oblique"]>>;
+        }, "strip", z.ZodTypeAny, {
+            family?: string | undefined;
+            size?: number | undefined;
+            weight?: number | "normal" | "bold" | undefined;
+            style?: "normal" | "italic" | "oblique" | undefined;
+        }, {
+            family?: string | undefined;
+            size?: number | undefined;
+            weight?: number | "normal" | "bold" | undefined;
+            style?: "normal" | "italic" | "oblique" | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        fill?: string | undefined;
+        opacity?: number | undefined;
+        font?: {
+            family?: string | undefined;
+            size?: number | undefined;
+            weight?: number | "normal" | "bold" | undefined;
+            style?: "normal" | "italic" | "oblique" | undefined;
+        } | undefined;
+    }, {
+        text: string;
+        fill?: string | undefined;
+        opacity?: number | undefined;
+        font?: {
+            family?: string | undefined;
+            size?: number | undefined;
+            weight?: number | "normal" | "bold" | undefined;
+            style?: "normal" | "italic" | "oblique" | undefined;
+        } | undefined;
+    }>]>, "many">]>>;
+    align: z.ZodOptional<z.ZodNativeEnum<{
+        readonly left: "left";
+        readonly center: "center";
+        readonly right: "right";
+    }>>;
+    lineHeight: z.ZodOptional<z.ZodNumber>;
     fill: z.ZodOptional<z.ZodString>;
+    fillOpacity: z.ZodOptional<z.ZodNumber>;
     stroke: z.ZodOptional<z.ZodString>;
+    drawOpacity: z.ZodOptional<z.ZodNumber>;
     strokeWidth: z.ZodOptional<z.ZodNumber>;
+    dashed: z.ZodOptional<z.ZodBoolean>;
+    dotted: z.ZodOptional<z.ZodBoolean>;
+    dashArray: z.ZodOptional<z.ZodString>;
+    roundedCorners: z.ZodOptional<z.ZodNumber>;
+    minimumWidth: z.ZodOptional<z.ZodNumber>;
+    minimumHeight: z.ZodOptional<z.ZodNumber>;
+    minimumSize: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    xScale: z.ZodOptional<z.ZodNumber>;
+    yScale: z.ZodOptional<z.ZodNumber>;
+    textColor: z.ZodOptional<z.ZodString>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+    innerXSep: z.ZodOptional<z.ZodNumber>;
+    innerYSep: z.ZodOptional<z.ZodNumber>;
+    outerSep: z.ZodOptional<z.ZodNumber>;
     padding: z.ZodOptional<z.ZodNumber>;
     margin: z.ZodOptional<z.ZodNumber>;
-    fontSize: z.ZodOptional<z.ZodNumber>;
+    font: z.ZodOptional<z.ZodObject<{
+        family: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["normal", "bold"]>, z.ZodNumber]>>;
+        style: z.ZodOptional<z.ZodEnum<["normal", "italic", "oblique"]>>;
+    }, "strip", z.ZodTypeAny, {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    }, {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     type: "node";
     position: [number, number] | import('./position').PolarPosition;
     fill?: string | undefined;
+    shape?: "diamond" | "circle" | "rectangle" | "ellipse" | undefined;
     stroke?: string | undefined;
     strokeWidth?: number | undefined;
+    text?: string | (string | {
+        text: string;
+        fill?: string | undefined;
+        opacity?: number | undefined;
+        font?: {
+            family?: string | undefined;
+            size?: number | undefined;
+            weight?: number | "normal" | "bold" | undefined;
+            style?: "normal" | "italic" | "oblique" | undefined;
+        } | undefined;
+    })[] | undefined;
+    opacity?: number | undefined;
+    font?: {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    } | undefined;
     id?: string | undefined;
     rotate?: number | undefined;
-    text?: string | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    lineHeight?: number | undefined;
+    fillOpacity?: number | undefined;
+    drawOpacity?: number | undefined;
+    dashed?: boolean | undefined;
+    dotted?: boolean | undefined;
+    dashArray?: string | undefined;
+    roundedCorners?: number | undefined;
+    minimumWidth?: number | undefined;
+    minimumHeight?: number | undefined;
+    minimumSize?: number | undefined;
+    scale?: number | undefined;
+    xScale?: number | undefined;
+    yScale?: number | undefined;
+    textColor?: string | undefined;
+    innerXSep?: number | undefined;
+    innerYSep?: number | undefined;
+    outerSep?: number | undefined;
     padding?: number | undefined;
     margin?: number | undefined;
-    fontSize?: number | undefined;
 }, {
     type: "node";
     position: [number, number] | import('./position').PolarPosition;
     fill?: string | undefined;
+    shape?: "diamond" | "circle" | "rectangle" | "ellipse" | undefined;
     stroke?: string | undefined;
     strokeWidth?: number | undefined;
+    text?: string | (string | {
+        text: string;
+        fill?: string | undefined;
+        opacity?: number | undefined;
+        font?: {
+            family?: string | undefined;
+            size?: number | undefined;
+            weight?: number | "normal" | "bold" | undefined;
+            style?: "normal" | "italic" | "oblique" | undefined;
+        } | undefined;
+    })[] | undefined;
+    opacity?: number | undefined;
+    font?: {
+        family?: string | undefined;
+        size?: number | undefined;
+        weight?: number | "normal" | "bold" | undefined;
+        style?: "normal" | "italic" | "oblique" | undefined;
+    } | undefined;
     id?: string | undefined;
     rotate?: number | undefined;
-    text?: string | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    lineHeight?: number | undefined;
+    fillOpacity?: number | undefined;
+    drawOpacity?: number | undefined;
+    dashed?: boolean | undefined;
+    dotted?: boolean | undefined;
+    dashArray?: string | undefined;
+    roundedCorners?: number | undefined;
+    minimumWidth?: number | undefined;
+    minimumHeight?: number | undefined;
+    minimumSize?: number | undefined;
+    scale?: number | undefined;
+    xScale?: number | undefined;
+    yScale?: number | undefined;
+    textColor?: string | undefined;
+    innerXSep?: number | undefined;
+    innerYSep?: number | undefined;
+    outerSep?: number | undefined;
     padding?: number | undefined;
     margin?: number | undefined;
-    fontSize?: number | undefined;
 }>;
-/** 节点：矩形 + 可选文本标签，是最基础的有定位图元 */
+/** 节点：可定位的形状容器（矩形 / 圆 / 椭圆 / 菱形）+ 可选文本标签 */
 export type IRNode = z.infer<typeof NodeSchema>;
 //# sourceMappingURL=node.d.ts.map

package/dist/lib/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;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;EAwBpB,CAAC;AAEJ,oCAAoC;AACpC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEhD;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsBxB,CAAC;AAEJ,4BAA4B;AAC5B,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAIxB,CAAC;AAEJ,yCAAyC;AACzC,eAAO,MAAM,gBAAgB;;;;CAInB,CAAC;AAEX,kBAAkB;AAClB,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyKpB,CAAC;AAEJ,4CAA4C;AAC5C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/lib/ir/path/arrow.cjs

@@ -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
+exports.ARROW_SHAPES = ARROW_SHAPES;

package/dist/lib/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/lib/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/lib/ir/path/index.d.ts

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

package/dist/lib/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/lib/ir/path/path.cjs

@@ -1,3 +1,4 @@
+const require_arrow = require("./arrow.cjs");
 const require_step = require("./step.cjs");
 let zod = require("zod");
 //#region src/ir/path/path.ts
@@ -6,6 +7,15 @@ var PathSchema = zod.z.object({
 	stroke: zod.z.string().optional().describe("Stroke color of the path; any CSS color. Defaults to currentColor when omitted"),
 	strokeWidth: zod.z.number().optional().describe("Stroke width in user units; defaults to 1 when omitted"),
 	strokeDasharray: zod.z.string().optional().describe("SVG stroke-dasharray pattern (e.g. \"4 2\"); leave empty for solid line"),
+	arrow: zod.z.enum([
+		"none",
+		"->",
+		"<-",
+		"<->"
+	]).optional().describe("Path-level arrow direction. omitted/`none` = no arrows; `->` = arrow at end; `<-` = at start; `<->` = both."),
+	arrowShape: zod.z.nativeEnum(require_arrow.ARROW_SHAPES).optional().describe("Arrow tip shape; default `normal` (filled triangle). Other values: `open` (hollow triangle), `stealth` (sharp barb), `diamond`, `circle`."),
+	fill: zod.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: zod.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: zod.z.array(require_step.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/lib/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/lib/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/lib/ir/path/step.cjs

@@ -11,8 +11,25 @@ var LineStepSchema = zod.z.object({
 	kind: zod.z.literal("line").describe("Draw a straight line from the current cursor to the target (like SVG path \"L\")"),
 	to: require_target.TargetSchema.describe("Destination point of the line segment")
 }).describe("Line action: straight-line segment from cursor to target");
-var StepSchema = zod.z.discriminatedUnion("kind", [MoveStepSchema, LineStepSchema]).describe("A single path action; the discriminator field is `kind`");
+var FoldStepSchema = zod.z.object({
+	type: zod.z.literal("step").describe("Discriminator marking this as a path step node"),
+	kind: zod.z.literal("step").describe("Folded right-angle segment from cursor to target through one intermediate point (TikZ `-|` / `|-`)"),
+	via: zod.z.enum(["-|", "|-"]).describe("Folding direction: `-|` first horizontal then vertical; `|-` first vertical then horizontal"),
+	to: require_target.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 = zod.z.object({
+	type: zod.z.literal("step").describe("Discriminator marking this as a path step node"),
+	kind: zod.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 = zod.z.discriminatedUnion("kind", [
+	MoveStepSchema,
+	LineStepSchema,
+	FoldStepSchema,
+	CycleStepSchema
+]).describe("A single path action; the discriminator field is `kind`");
 //#endregion
+exports.CycleStepSchema = CycleStepSchema;
+exports.FoldStepSchema = FoldStepSchema;
 exports.LineStepSchema = LineStepSchema;
 exports.MoveStepSchema = MoveStepSchema;
 exports.StepSchema = StepSchema;

package/dist/lib/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