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

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

@@ -0,0 +1,38 @@
+import { Position } from './point';
+export type SegmentSample = {
+    /** t 处的点坐标 */
+    point: Position;
+    /** t 处的切线方向（单位向量；零向量时回退到 [1, 0]） */
+    tangent: Position;
+};
+/** 直线段 from → to */
+export declare const lineSegmentSample: (from: Position, to: Position, t: number) => SegmentSample;
+/**
+ * 二次贝塞尔 from → control → to。
+ * P(t)  = (1-t)²·P0 + 2(1-t)t·P1 + t²·P2
+ * P'(t) = 2(1-t)(P1-P0) + 2t(P2-P1)
+ */
+export declare const quadSegmentSample: (from: Position, control: Position, to: Position, t: number) => SegmentSample;
+/**
+ * 三次贝塞尔 from → c1 → c2 → to。
+ * P'(t) = 3(1-t)²(P1-P0) + 6(1-t)t(P2-P1) + 3t²(P3-P2)
+ */
+export declare const cubicSegmentSample: (from: Position, c1: Position, c2: Position, to: Position, t: number) => SegmentSample;
+/**
+ * 折角段 from → corner → to。
+ * t∈[0, 0.5] 走第一段（参数 2t）；t∈(0.5, 1] 走第二段（参数 2t-1）。
+ * t=0.5 落在 corner，切线取第一段方向（与"靠近 prev 一侧"一致）。
+ */
+export declare const foldSegmentSample: (from: Position, corner: Position, to: Position, t: number) => SegmentSample;
+/**
+ * 弧段（与 ir/path arc 同约定，角度单位为度）。
+ * 切线沿"扫描方向"——endAngle ≥ startAngle 时为 (-sin, cos)，否则反向。
+ */
+export declare const arcSegmentSample: (center: Position, radius: number, startAngleDeg: number, endAngleDeg: number, t: number) => SegmentSample;
+/**
+ * 整圆——从 0°（east）开始，与 compile/path circlePath 输出方向（右→左→右，sweep=1）一致。
+ */
+export declare const circleSegmentSample: (center: Position, radius: number, t: number) => SegmentSample;
+/** 整椭圆——参数化 (rx·cos(2πt), ry·sin(2πt)) */
+export declare const ellipseSegmentSample: (center: Position, rx: number, ry: number, t: number) => SegmentSample;
+//# sourceMappingURL=segment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAuBxC,MAAM,MAAM,aAAa,GAAG;IAC1B,cAAc;IACd,KAAK,EAAE,QAAQ,CAAC;IAChB,oCAAoC;IACpC,OAAO,EAAE,QAAQ,CAAC;CACnB,CAAC;AAQF,oBAAoB;AACpB,eAAO,MAAM,iBAAiB,GAC5B,MAAM,QAAQ,EACd,IAAI,QAAQ,EACZ,GAAG,MAAM,KACR,aAGD,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM,QAAQ,EACd,SAAS,QAAQ,EACjB,IAAI,QAAQ,EACZ,GAAG,MAAM,KACR,aASF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC7B,MAAM,QAAQ,EACd,IAAI,QAAQ,EACZ,IAAI,QAAQ,EACZ,IAAI,QAAQ,EACZ,GAAG,MAAM,KACR,aAqBF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM,QAAQ,EACd,QAAQ,QAAQ,EAChB,IAAI,QAAQ,EACZ,GAAG,MAAM,KACR,aAGF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,QAAQ,EAChB,QAAQ,MAAM,EACd,eAAe,MAAM,EACrB,aAAa,MAAM,EACnB,GAAG,MAAM,KACR,aAUF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,QAAQ,EAChB,QAAQ,MAAM,EACd,GAAG,MAAM,KACR,aASF,CAAC;AAEF,0CAA0C;AAC1C,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,QAAQ,EAChB,IAAI,MAAM,EACV,IAAI,MAAM,EACV,GAAG,MAAM,KACR,aASF,CAAC"}

package/dist/es/geometry/segment.js

@@ -0,0 +1,82 @@
+//#region src/geometry/segment.ts
+var DEG_TO_RAD = Math.PI / 180;
+var normalize = (v) => {
+	const len = Math.hypot(v[0], v[1]);
+	if (len === 0) return [1, 0];
+	return [v[0] / len, v[1] / len];
+};
+/** 直线段 from → to */
+var lineSegmentSample = (from, to, t) => ({
+	point: [from[0] + (to[0] - from[0]) * t, from[1] + (to[1] - from[1]) * t],
+	tangent: normalize([to[0] - from[0], to[1] - from[1]])
+});
+/**
+* 二次贝塞尔 from → control → to。
+* P(t)  = (1-t)²·P0 + 2(1-t)t·P1 + t²·P2
+* P'(t) = 2(1-t)(P1-P0) + 2t(P2-P1)
+*/
+var quadSegmentSample = (from, control, to, t) => {
+	const u = 1 - t;
+	return {
+		point: [u * u * from[0] + 2 * u * t * control[0] + t * t * to[0], u * u * from[1] + 2 * u * t * control[1] + t * t * to[1]],
+		tangent: normalize([2 * u * (control[0] - from[0]) + 2 * t * (to[0] - control[0]), 2 * u * (control[1] - from[1]) + 2 * t * (to[1] - control[1])])
+	};
+};
+/**
+* 三次贝塞尔 from → c1 → c2 → to。
+* P'(t) = 3(1-t)²(P1-P0) + 6(1-t)t(P2-P1) + 3t²(P3-P2)
+*/
+var cubicSegmentSample = (from, c1, c2, to, t) => {
+	const u = 1 - t;
+	return {
+		point: [u * u * u * from[0] + 3 * u * u * t * c1[0] + 3 * u * t * t * c2[0] + t * t * t * to[0], u * u * u * from[1] + 3 * u * u * t * c1[1] + 3 * u * t * t * c2[1] + t * t * t * to[1]],
+		tangent: normalize([3 * u * u * (c1[0] - from[0]) + 6 * u * t * (c2[0] - c1[0]) + 3 * t * t * (to[0] - c2[0]), 3 * u * u * (c1[1] - from[1]) + 6 * u * t * (c2[1] - c1[1]) + 3 * t * t * (to[1] - c2[1])])
+	};
+};
+/**
+* 折角段 from → corner → to。
+* t∈[0, 0.5] 走第一段（参数 2t）；t∈(0.5, 1] 走第二段（参数 2t-1）。
+* t=0.5 落在 corner，切线取第一段方向（与"靠近 prev 一侧"一致）。
+*/
+var foldSegmentSample = (from, corner, to, t) => {
+	if (t <= .5) return lineSegmentSample(from, corner, t * 2);
+	return lineSegmentSample(corner, to, t * 2 - 1);
+};
+/**
+* 弧段（与 ir/path arc 同约定，角度单位为度）。
+* 切线沿"扫描方向"——endAngle ≥ startAngle 时为 (-sin, cos)，否则反向。
+*/
+var arcSegmentSample = (center, radius, startAngleDeg, endAngleDeg, t) => {
+	const rad = (startAngleDeg + t * (endAngleDeg - startAngleDeg)) * DEG_TO_RAD;
+	const cos = Math.cos(rad);
+	const sin = Math.sin(rad);
+	const sweepSign = endAngleDeg >= startAngleDeg ? 1 : -1;
+	return {
+		point: [center[0] + radius * cos, center[1] + radius * sin],
+		tangent: normalize([-sin * sweepSign, cos * sweepSign])
+	};
+};
+/**
+* 整圆——从 0°（east）开始，与 compile/path circlePath 输出方向（右→左→右，sweep=1）一致。
+*/
+var circleSegmentSample = (center, radius, t) => {
+	const rad = t * 360 * DEG_TO_RAD;
+	const cos = Math.cos(rad);
+	const sin = Math.sin(rad);
+	return {
+		point: [center[0] + radius * cos, center[1] + radius * sin],
+		tangent: normalize([-sin, cos])
+	};
+};
+/** 整椭圆——参数化 (rx·cos(2πt), ry·sin(2πt)) */
+var ellipseSegmentSample = (center, rx, ry, t) => {
+	const rad = t * 360 * DEG_TO_RAD;
+	const cos = Math.cos(rad);
+	const sin = Math.sin(rad);
+	return {
+		point: [center[0] + rx * cos, center[1] + ry * sin],
+		tangent: normalize([-rx * sin, ry * cos])
+	};
+};
+//#endregion
+export { arcSegmentSample, circleSegmentSample, cubicSegmentSample, ellipseSegmentSample, foldSegmentSample, lineSegmentSample, quadSegmentSample };

package/dist/es/index.d.ts

@@ -6,14 +6,14 @@
  *
  * 本包零 React、零 DOM 依赖。
  */
-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 { PositionSchema, PolarPositionSchema, TargetSchema, RelTargetSchema, RelAccumulateTargetSchema, MoveStepSchema, LineStepSchema, FoldStepSchema, CycleStepSchema, CurveStepSchema, CubicStepSchema, BendStepSchema, ArcStepSchema, CirclePathStepSchema, EllipsePathStepSchema, ControlPointSchema, StepLabelSchema, StepSchema, NodeSchema, FontSchema, NodeTextSchema, LineSpecSchema, PathSchema, ChildSchema, SceneSchema, CURRENT_IR_VERSION, } from './ir';
+export type { IRPosition, IRTarget, IRRelTarget, IRRelAccumulateTarget, IRMoveStep, IRLineStep, IRFoldStep, IRCycleStep, IRCurveStep, IRCubicStep, IRBendStep, IRArcStep, IRCirclePathStep, IREllipsePathStep, IRControlPoint, IRStepLabel, IRStep, IRNode, IRFont, IRLineSpec, IRPath, IRChild, IR, ArrowShape, NodeShape, NodeTextAlign, } from './ir';
+export { ARROW_SHAPES, NODE_SHAPES, NODE_TEXT_ALIGNS } from './ir';
+export type { ScenePrimitive, RectPrim, EllipsePrim, TextPrim, TextLine, PathPrim, GroupPrim, ViewBox, Scene, } from './primitive';
 export type { FontSpec, TextMetrics, TextMeasurer, CompileOptions, } from './compile';
 export { fallbackMeasurer, compileToScene } from './compile';
-export type { WayItem, WayDSL, WayCycle, WayVia } from './parsers';
-export { parseWay, DrawWay } from './parsers';
+export type { WayItem, WayDSL, WayCycle, WayVia, WayRelItem, WayLabel, WayLabelOp, } from './parsers';
+export { parseWay, DrawWay, parseTargetSugar } 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';

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,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,yBAAyB,EACzB,cAAc,EACd,cAAc,EACd,cAAc,EACd,eAAe,EACf,eAAe,EACf,eAAe,EACf,cAAc,EACd,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,cAAc,EACd,UAAU,EACV,WAAW,EACX,WAAW,EACX,kBAAkB,GACnB,MAAM,MAAM,CAAC;AACd,YAAY,EACV,UAAU,EACV,QAAQ,EACR,WAAW,EACX,qBAAqB,EACrB,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACX,WAAW,EACX,UAAU,EACV,SAAS,EACT,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACd,WAAW,EACX,MAAM,EACN,MAAM,EACN,MAAM,EACN,UAAU,EACV,MAAM,EACN,OAAO,EACP,EAAE,EACF,UAAU,EACV,SAAS,EACT,aAAa,GACd,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,MAAM,CAAC;AAGnE,YAAY,EACV,cAAc,EACd,QAAQ,EACR,WAAW,EACX,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,EACV,OAAO,EACP,MAAM,EACN,QAAQ,EACR,MAAM,EACN,UAAU,EACV,QAAQ,EACR,UAAU,GACX,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAIhE,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,10 +1,10 @@
 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 { CycleStepSchema, FoldStepSchema, LineStepSchema, MoveStepSchema, StepSchema } from "./ir/path/step.js";
+import { RelAccumulateTargetSchema, RelTargetSchema, TargetSchema } from "./ir/path/target.js";
+import { ArcStepSchema, BendStepSchema, CirclePathStepSchema, ControlPointSchema, CubicStepSchema, CurveStepSchema, CycleStepSchema, EllipsePathStepSchema, FoldStepSchema, LineStepSchema, MoveStepSchema, StepLabelSchema, StepSchema } from "./ir/path/step.js";
 import { PathSchema } from "./ir/path/path.js";
-import { NODE_SHAPES, NodeSchema } from "./ir/node.js";
+import { FontSchema, LineSpecSchema, NODE_SHAPES, NODE_TEXT_ALIGNS, NodeSchema, NodeTextSchema } 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";
@@ -12,7 +12,8 @@ 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 { parseTargetSugar } from "./parsers/parseTargetSugar.js";
 import { DrawWay, parseWay } from "./parsers/parseWay.js";
 import { polar } from "./geometry/polar.js";
 import { point } from "./geometry/point.js";
-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 };
+export { ARROW_SHAPES, ArcStepSchema, BendStepSchema, CURRENT_IR_VERSION, ChildSchema, CirclePathStepSchema, ControlPointSchema, CubicStepSchema, CurveStepSchema, CycleStepSchema, DrawWay, EllipsePathStepSchema, FoldStepSchema, FontSchema, LineSpecSchema, LineStepSchema, MoveStepSchema, NODE_SHAPES, NODE_TEXT_ALIGNS, NodeSchema, NodeTextSchema, PathSchema, PolarPositionSchema, PositionSchema, RECT_ANCHORS, RelAccumulateTargetSchema, RelTargetSchema, SceneSchema, StepLabelSchema, StepSchema, TargetSchema, circle, compileToScene, diamond, ellipse, fallbackMeasurer, parseTargetSugar, parseWay, point, polar, rect };

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

@@ -23,6 +23,140 @@ export declare const NODE_SHAPES: {
 };
 /** 节点形状字面量类型，由 `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>;
@@ -34,39 +168,185 @@ export declare const NodeSchema: z.ZodObject<{
     }>>;
     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;
+    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;
     shape?: "diamond" | "circle" | "rectangle" | "ellipse" | undefined;
     stroke?: string | undefined;
     strokeWidth?: number | undefined;
+    opacity?: number | undefined;
+    fillOpacity?: number | undefined;
+    drawOpacity?: 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" | "right" | "center" | undefined;
+    lineHeight?: 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;
+    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;
     shape?: "diamond" | "circle" | "rectangle" | "ellipse" | undefined;
     stroke?: string | undefined;
     strokeWidth?: number | undefined;
+    opacity?: number | undefined;
+    fillOpacity?: number | undefined;
+    drawOpacity?: 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" | "right" | "center" | undefined;
+    lineHeight?: 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>;

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;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"}
+{"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/es/ir/node.js

@@ -23,19 +23,85 @@ var NODE_SHAPES = {
 	ellipse: "ellipse",
 	diamond: "diamond"
 };
+/**
+* 节点字体规格——family / size / weight / style 全部可选；
+* 单字段透传到 SVG `<text>` 的 `font-*` 属性 / `font-size`。
+*
+* 取代 alpha.1 的标量 `fontSize` 字段（已删）。
+*/
+var FontSchema = z.object({
+	family: z.string().optional().describe("CSS font-family string, e.g. \"serif\", \"monospace\", \"Inter, sans-serif\""),
+	size: z.number().positive().optional().describe("Font size in user units; falls back to the renderer default when omitted"),
+	weight: z.union([z.enum(["normal", "bold"]), z.number()]).optional().describe("CSS font-weight: keyword `normal` / `bold` or numeric 100..900"),
+	style: z.enum([
+		"normal",
+		"italic",
+		"oblique"
+	]).optional().describe("CSS font-style")
+}).describe("Font properties for the node text label; all fields optional, nested object form (replaces the alpha.1 `fontSize` scalar).");
+/**
+* 单行文本规格——纯字符串走块级默认样式；对象形式可对该行覆盖 fill / opacity / font。
+*
+* 行级覆盖只生效于本行的 `<tspan>`：
+* - `fill`：仅这一行颜色
+* - `opacity`：仅这一行 0~1 透明度
+* - `font`：family / size / weight / style 任意子集；未填字段继承块级 font
+*
+* 块级 `align` / `lineHeight` 不可被行覆盖（多行块整体属性）。
+*/
+var LineSpecSchema = z.union([z.string(), z.object({
+	text: z.string().describe("Line content"),
+	fill: z.string().optional().describe("Per-line text color; overrides block default"),
+	opacity: z.number().min(0).max(1).optional().describe("Per-line opacity 0..1"),
+	font: FontSchema.optional().describe("Per-line font overrides; missing fields inherit from block-level `font`")
+})]).describe("Single line of text: bare string for default styling, or an object with per-line `fill` / `opacity` / `font` overrides.");
+/**
+* 节点文本——单行字符串或非空多行数组（每元素一个 LineSpec）：
+* - `'Hello'` 等价于 `[{ text: 'Hello' }]`，按一行渲染
+* - `['Line 1', 'Line 2']` 两行无样式覆盖
+* - `[{ text: 'Heading', fill: 'red', font: { weight: 'bold' } }, 'body']` 混排
+*
+* 选 `Array<LineSpec>` 而非 `'\n'` 字符串：JSON 友好（无 escape）；行级覆盖天然落字段。
+*/
+var NodeTextSchema = z.union([z.string(), z.array(LineSpecSchema).min(1)]).describe("Text label rendered inside the node: a single string for one line, or a non-empty array of line specs (string for default, object for per-line overrides).");
+/** 节点文本对齐（多行内文本对齐）——TikZ `align=` 同义词 */
+var NODE_TEXT_ALIGNS = {
+	left: "left",
+	center: "center",
+	right: "right"
+};
 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"),
+	text: NodeTextSchema.optional(),
+	align: z.nativeEnum(NODE_TEXT_ALIGNS).optional().describe("Multi-line text alignment within the text block; `left` / `center` / `right`. Defaults to `center` (matches TikZ)."),
+	lineHeight: z.number().positive().optional().describe("Line height in user units; falls back to `font.size × 1.2` when omitted."),
 	fill: z.string().optional().describe("Background color of the node shape; any CSS color (e.g. \"lightblue\", \"#fafafa\", \"rgba(...)\")"),
+	fillOpacity: z.number().min(0).max(1).optional().describe("Fill opacity 0..1; affects only the shape fill, leaves stroke / text alone."),
 	stroke: z.string().optional().describe("Border color of the node shape; any CSS color. Defaults to currentColor when omitted"),
+	drawOpacity: z.number().min(0).max(1).optional().describe("Stroke opacity 0..1 (TikZ `draw opacity`); affects only the border."),
 	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)")
+	dashed: z.boolean().optional().describe("Border style preset: dashed line (TikZ `dashed`); compiled to a default dash pattern. `dashArray` takes precedence."),
+	dotted: z.boolean().optional().describe("Border style preset: dotted line (TikZ `dotted`); compiled to a default dot pattern. `dashArray` and `dashed` take precedence."),
+	dashArray: z.string().optional().describe("Explicit SVG stroke-dasharray value (e.g. \"4 2\"); overrides `dashed` / `dotted`."),
+	roundedCorners: z.number().nonnegative().optional().describe("Corner radius in user units; only effective on `rectangle` shape (rx / ry on `<rect>`)."),
+	minimumWidth: z.number().nonnegative().optional().describe("Minimum visual border width in user units; floors the bounding box width."),
+	minimumHeight: z.number().nonnegative().optional().describe("Minimum visual border height in user units; floors the bounding box height."),
+	minimumSize: z.number().nonnegative().optional().describe("Symmetric alias for `minimumWidth` + `minimumHeight`; axis-specific fields take precedence."),
+	scale: z.number().positive().optional().describe("Uniform scale factor; multiplies all node dimensions (border, padding, text, fontSize) at layout time. Affects path attachment positions."),
+	xScale: z.number().positive().optional().describe("Horizontal scale factor; overrides `scale` for the X axis."),
+	yScale: z.number().positive().optional().describe("Vertical scale factor; overrides `scale` for the Y axis."),
+	textColor: z.string().optional().describe("Text label color; any CSS color. Defaults to `currentColor`."),
+	opacity: z.number().min(0).max(1).optional().describe("Whole-node opacity 0..1; applies uniformly to shape and text."),
+	innerXSep: z.number().nonnegative().optional().describe("Inner horizontal padding from text to border in user units. Falls back to `padding` then default."),
+	innerYSep: z.number().nonnegative().optional().describe("Inner vertical padding from text to border in user units. Falls back to `padding` then default."),
+	outerSep: z.number().nonnegative().optional().describe("Outer margin from border to path attachment point in user units; does NOT change the visible border. Falls back to `margin`."),
+	padding: z.number().nonnegative().optional().describe("Symmetric inner padding (alias for `innerXSep` + `innerYSep`); axis-specific fields take precedence."),
+	margin: z.number().nonnegative().optional().describe("Symmetric outer margin (alias for `outerSep`); axis-specific field takes precedence."),
+	font: FontSchema.optional().describe("Font spec for the inner text label (family / size / weight / style); all fields optional, all fall back to renderer defaults.")
 }).describe("Node primitive: a positioned, optionally textual shape (rectangle / circle / ellipse / diamond)");
 //#endregion
-export { NODE_SHAPES, NodeSchema };
+export { FontSchema, LineSpecSchema, NODE_SHAPES, NODE_TEXT_ALIGNS, NodeSchema, NodeTextSchema };