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

package/dist/es/geometry/polar.js

@@ -0,0 +1,45 @@
+import { point } from "./point.js";
+//#region src/geometry/polar.ts
+var DEG_TO_RAD = Math.PI / 180;
+var RAD_TO_DEG = 180 / Math.PI;
+/**
+* 极坐标 ↔ 笛卡尔坐标 转换工具集。
+*
+* 注意 polar 不参与几何计算——参与计算时一律先用 `polar.toPosition` 转成 Position。
+* 详见本文件顶部的整体说明。
+*/
+var polar = {
+	/**
+	* 极坐标 → 笛卡尔位置（递归处理 origin）。
+	* **限制**：origin 为字符串（节点 id）时本方法无法解析，会抛错——
+	* 字符串解析依赖 Scene 编译器的 nodeIndex 上下文。
+	*/
+	toPosition: (p) => {
+		let origin;
+		if (!p.origin) origin = [0, 0];
+		else if (typeof p.origin === "string") throw new Error("polar.toPosition: cannot resolve string origin (node id) without node context; use the Scene compiler");
+		else if (Array.isArray(p.origin)) origin = p.origin;
+		else origin = polar.toPosition(p.origin);
+		const rad = p.angle * DEG_TO_RAD;
+		return [origin[0] + Math.cos(rad) * p.radius, origin[1] + Math.sin(rad) * p.radius];
+	},
+	/** 笛卡尔位置 → 极坐标（angle 落在 (-180, 180]，origin 取默认 [0, 0]） */
+	fromPosition: (p) => ({
+		angle: Math.atan2(p[1], p[0]) * RAD_TO_DEG,
+		radius: Math.hypot(p[0], p[1])
+	}),
+	/** 在某个原点附近按极坐标偏移；返回结果点的世界笛卡尔坐标 */
+	offsetFrom: (origin, offset) => {
+		const rad = offset.angle * DEG_TO_RAD;
+		return [origin[0] + Math.cos(rad) * offset.radius, origin[1] + Math.sin(rad) * offset.radius];
+	},
+	/**
+	* 判断两个点是否相同（跨坐标系）。每个参数可以是笛卡尔 [x, y] 或 PolarPosition；
+	* 极坐标先转为笛卡尔，再按 precision 指定的小数位数四舍五入比较。
+	* 实际是 `point.equalPolar` 的别名（同一份实现，两处可发现）。
+	* @param precision 小数点后位数；默认 2
+	*/
+	equal: (a, b, precision = 2) => point.equalPolar(a, b, precision)
+};
+//#endregion
+export { polar };

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

@@ -0,0 +1,59 @@
+import { Position } from './point';
+/** 轴对齐矩形：几何中心 (x, y) + 宽高 + 可选绕中心旋转 */
+export type Rect = {
+    /** 矩形几何中心横坐标 */
+    x: number;
+    /** 矩形几何中心纵坐标 */
+    y: number;
+    /** 矩形宽度（user units） */
+    width: number;
+    /** 矩形高度（user units） */
+    height: number;
+    /** 绕几何中心的旋转角（弧度）；省略或 0 表示不旋转 */
+    rotate?: number;
+};
+/**
+ * 矩形 9 个标准 anchor 名常量集合，对应 TikZ 节点的 9 个标准 anchor。
+ * 与 `RectAnchor` 类型配对使用——值用 `RECT_ANCHORS.NORTH` 避免拼错，
+ * 类型位置用 `RectAnchor`。
+ */
+export declare const RECT_ANCHORS: {
+    /** 几何中心 */
+    readonly CENTER: "center";
+    /** 上边中点 */
+    readonly NORTH: "north";
+    /** 下边中点 */
+    readonly SOUTH: "south";
+    /** 右边中点 */
+    readonly EAST: "east";
+    /** 左边中点 */
+    readonly WEST: "west";
+    /** 右上角 */
+    readonly NORTH_EAST: "north-east";
+    /** 左上角 */
+    readonly NORTH_WEST: "north-west";
+    /** 右下角 */
+    readonly SOUTH_EAST: "south-east";
+    /** 左下角 */
+    readonly SOUTH_WEST: "south-west";
+};
+/** 矩形 anchor 名（与 TikZ 命名约定一致），由 `RECT_ANCHORS` 常量集合派生 */
+export type RectAnchor = (typeof RECT_ANCHORS)[keyof typeof RECT_ANCHORS];
+/** 矩形相关基础工具 */
+export declare const rect: {
+    /** 矩形几何中心点 */
+    center: (r: Rect) => Position;
+    /** 判断点是否落在矩形范围内（含边界，考虑旋转） */
+    contains: (r: Rect, p: Position) => boolean;
+    /**
+     * 取矩形 9 个标准 anchor 之一的世界坐标，考虑旋转。
+     * 名字与 TikZ 节点 anchor 一致（north / south / east / west / north-east / ... / center）。
+     */
+    anchor: (r: Rect, name: RectAnchor) => Position;
+    /**
+     * 从矩形中心向 toward 方向画射线，求与矩形边界的交点（考虑旋转）。
+     * 用于把 Path 端点贴到 Node 边界（避免线段穿过节点内部）。
+     */
+    boundaryPoint: (r: Rect, toward: Position) => Position;
+};
+//# sourceMappingURL=rect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../../src/geometry/rect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,uCAAuC;AACvC,MAAM,MAAM,IAAI,GAAG;IACjB,gBAAgB;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY;IACvB,WAAW;;IAEX,WAAW;;IAEX,WAAW;;IAEX,WAAW;;IAEX,WAAW;;IAEX,UAAU;;IAEV,UAAU;;IAEV,UAAU;;IAEV,UAAU;;CAEF,CAAC;AAEX,yDAAyD;AACzD,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAgC1E,eAAe;AACf,eAAO,MAAM,IAAI;IACf,cAAc;gBACF,IAAI,KAAG,QAAQ;IAC3B,6BAA6B;kBACf,IAAI,KAAK,QAAQ,KAAG,OAAO;IAMzC;;;OAGG;gBACS,IAAI,QAAQ,UAAU,KAAG,QAAQ;IAuC7C;;;OAGG;uBACgB,IAAI,UAAU,QAAQ,KAAG,QAAQ;CAUrD,CAAC"}

package/dist/es/geometry/rect.js

@@ -0,0 +1,120 @@
+//#region src/geometry/rect.ts
+/**
+* 矩形 9 个标准 anchor 名常量集合，对应 TikZ 节点的 9 个标准 anchor。
+* 与 `RectAnchor` 类型配对使用——值用 `RECT_ANCHORS.NORTH` 避免拼错，
+* 类型位置用 `RectAnchor`。
+*/
+var RECT_ANCHORS = {
+	/** 几何中心 */
+	CENTER: "center",
+	/** 上边中点 */
+	NORTH: "north",
+	/** 下边中点 */
+	SOUTH: "south",
+	/** 右边中点 */
+	EAST: "east",
+	/** 左边中点 */
+	WEST: "west",
+	/** 右上角 */
+	NORTH_EAST: "north-east",
+	/** 左上角 */
+	NORTH_WEST: "north-west",
+	/** 右下角 */
+	SOUTH_EAST: "south-east",
+	/** 左下角 */
+	SOUTH_WEST: "south-west"
+};
+/**
+* 把"以矩形中心为原点的本地坐标"转换为世界坐标。
+* 考虑 rect.rotate（弧度）的旋转。
+*/
+var localToWorld = (r, local) => {
+	const angle = r.rotate ?? 0;
+	if (angle === 0) return [r.x + local[0], r.y + local[1]];
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	return [r.x + local[0] * cos - local[1] * sin, r.y + local[0] * sin + local[1] * cos];
+};
+/**
+* 把世界坐标转换为"以矩形中心为原点的本地坐标"。
+* 与 localToWorld 互为逆变换。
+*/
+var worldToLocal = (r, world) => {
+	const tx = world[0] - r.x;
+	const ty = world[1] - r.y;
+	const angle = r.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 rect = {
+	/** 矩形几何中心点 */
+	center: (r) => [r.x, r.y],
+	/** 判断点是否落在矩形范围内（含边界，考虑旋转） */
+	contains: (r, p) => {
+		const [lx, ly] = worldToLocal(r, p);
+		const halfW = r.width / 2;
+		const halfH = r.height / 2;
+		return lx >= -halfW && lx <= halfW && ly >= -halfH && ly <= halfH;
+	},
+	/**
+	* 取矩形 9 个标准 anchor 之一的世界坐标，考虑旋转。
+	* 名字与 TikZ 节点 anchor 一致（north / south / east / west / north-east / ... / center）。
+	*/
+	anchor: (r, name) => {
+		const halfW = r.width / 2;
+		const halfH = r.height / 2;
+		let lx = 0;
+		let ly = 0;
+		switch (name) {
+			case "center": break;
+			case "north":
+				ly = -halfH;
+				break;
+			case "south":
+				ly = halfH;
+				break;
+			case "east":
+				lx = halfW;
+				break;
+			case "west":
+				lx = -halfW;
+				break;
+			case "north-east":
+				lx = halfW;
+				ly = -halfH;
+				break;
+			case "north-west":
+				lx = -halfW;
+				ly = -halfH;
+				break;
+			case "south-east":
+				lx = halfW;
+				ly = halfH;
+				break;
+			case "south-west":
+				lx = -halfW;
+				ly = halfH;
+				break;
+		}
+		return localToWorld(r, [lx, ly]);
+	},
+	/**
+	* 从矩形中心向 toward 方向画射线，求与矩形边界的交点（考虑旋转）。
+	* 用于把 Path 端点贴到 Node 边界（避免线段穿过节点内部）。
+	*/
+	boundaryPoint: (r, toward) => {
+		const [localX, localY] = worldToLocal(r, toward);
+		if (localX === 0 && localY === 0) return [r.x, r.y];
+		const halfW = r.width / 2;
+		const halfH = r.height / 2;
+		const tx = localX === 0 ? Infinity : halfW / Math.abs(localX);
+		const ty = localY === 0 ? Infinity : halfH / Math.abs(localY);
+		const t = Math.min(tx, ty);
+		return localToWorld(r, [localX * t, localY * t]);
+	}
+};
+//#endregion
+export { RECT_ANCHORS, rect };

package/dist/es/index.d.ts

@@ -1,10 +1,18 @@
-export { default as Draw } from './components/draw';
-export type { DrawProps } from './components/draw';
-export { default as Node } from './components/node';
-export type { NodeProps } from './components/node';
-export { default as PathNode } from './components/path-node';
-export type { PathNodeProps } from './components/path-node';
-export { default as Scope } from './components/Scope';
-export type { ScopeProps } from './components/Scope';
-export { default as TikZ } from './components/TikZ';
-export type { TikZProps } from './components/TikZ';
+/**
+ * @retikz/core 公开 API
+ *
+ * 任何 framework adapter（@retikz/react、@retikz/vue、@retikz/canvas、@retikz/ssr）
+ * 只能 import 本文件导出的内容，不准走子路径。
+ *
+ * 本包零 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 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';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/es/index.js

@@ -1,12 +1,14 @@
-import { default as default2 } from "./components/draw/Draw.js";
-import { default as default3 } from "./components/node/Node.js";
-import { default as default4 } from "./components/path-node/PathNode.js";
-import { default as default5 } from "./components/Scope.js";
-import { default as default6 } from "./components/TikZ.js";
-export {
-  default2 as Draw,
-  default3 as Node,
-  default4 as PathNode,
-  default5 as Scope,
-  default6 as TikZ
-};
+import { PositionSchema } from "./ir/position/position.js";
+import { PolarPositionSchema } from "./ir/position/polar-position.js";
+import { TargetSchema } from "./ir/path/target.js";
+import { LineStepSchema, MoveStepSchema, StepSchema } from "./ir/path/step.js";
+import { PathSchema } from "./ir/path/path.js";
+import { NodeSchema } from "./ir/node.js";
+import { CURRENT_IR_VERSION, ChildSchema, SceneSchema } from "./ir/scene.js";
+import { RECT_ANCHORS, rect } from "./geometry/rect.js";
+import { fallbackMeasurer } from "./compile/text-metrics.js";
+import { compileToScene } from "./compile/compile.js";
+import { 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 };

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

@@ -0,0 +1,5 @@
+export * from './position';
+export * from './path';
+export * from './node';
+export * from './scene';
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const NodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"node">;
+    id: z.ZodOptional<z.ZodString>;
+    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>;
+    fill: z.ZodOptional<z.ZodString>;
+    stroke: z.ZodOptional<z.ZodString>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    padding: z.ZodOptional<z.ZodNumber>;
+    margin: z.ZodOptional<z.ZodNumber>;
+    fontSize: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "node";
+    position: [number, number] | import('./position').PolarPosition;
+    fill?: string | undefined;
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    id?: string | undefined;
+    rotate?: number | undefined;
+    text?: string | undefined;
+    padding?: number | undefined;
+    margin?: number | undefined;
+    fontSize?: number | undefined;
+}, {
+    type: "node";
+    position: [number, number] | import('./position').PolarPosition;
+    fill?: string | undefined;
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    id?: string | undefined;
+    rotate?: number | undefined;
+    text?: string | undefined;
+    padding?: number | undefined;
+    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

@@ -0,0 +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"}

package/dist/es/ir/node.js

@@ -0,0 +1,19 @@
+import { PositionSchema } from "./position/position.js";
+import { PolarPositionSchema } from "./position/polar-position.js";
+import { z } from "zod";
+//#region src/ir/node.ts
+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"),
+	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"),
+	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");
+//#endregion
+export { NodeSchema };

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

@@ -0,0 +1,4 @@
+export * from './path';
+export * from './step';
+export * from './target';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+export declare const PathSchema: z.ZodObject<{
+    type: z.ZodLiteral<"path">;
+    stroke: z.ZodOptional<z.ZodString>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    strokeDasharray: z.ZodOptional<z.ZodString>;
+    children: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        kind: z.ZodLiteral<"move">;
+        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: "move";
+        to: string | [number, number] | import('..').PolarPosition;
+    }, {
+        type: "step";
+        kind: "move";
+        to: string | [number, number] | import('..').PolarPosition;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        kind: z.ZodLiteral<"line">;
+        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: "line";
+        to: string | [number, number] | import('..').PolarPosition;
+    }, {
+        type: "step";
+        kind: "line";
+        to: string | [number, number] | import('..').PolarPosition;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "path";
+    children: ({
+        type: "step";
+        kind: "move";
+        to: string | [number, number] | import('..').PolarPosition;
+    } | {
+        type: "step";
+        kind: "line";
+        to: string | [number, number] | import('..').PolarPosition;
+    })[];
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeDasharray?: string | undefined;
+}, {
+    type: "path";
+    children: ({
+        type: "step";
+        kind: "move";
+        to: string | [number, number] | import('..').PolarPosition;
+    } | {
+        type: "step";
+        kind: "line";
+        to: string | [number, number] | import('..').PolarPosition;
+    })[];
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeDasharray?: string | undefined;
+}>;
+/** 路径：由若干 step 动作（move / line / ...）组成的绘制路径 */
+export type IRPath = z.infer<typeof PathSchema>;
+//# sourceMappingURL=path.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,12 @@
+import { StepSchema } from "./step.js";
+import { z } from "zod";
+//#region src/ir/path/path.ts
+var PathSchema = z.object({
+	type: z.literal("path").describe("Discriminator marking this child as a path"),
+	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"),
+	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
+export { PathSchema };

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare const MoveStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"move">;
+    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: "move";
+    to: string | [number, number] | import('..').PolarPosition;
+}, {
+    type: "step";
+    kind: "move";
+    to: string | [number, number] | import('..').PolarPosition;
+}>;
+export declare const LineStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"line">;
+    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: "line";
+    to: string | [number, number] | import('..').PolarPosition;
+}, {
+    type: "step";
+    kind: "line";
+    to: string | [number, number] | import('..').PolarPosition;
+}>;
+export declare const StepSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"move">;
+    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: "move";
+    to: string | [number, number] | import('..').PolarPosition;
+}, {
+    type: "step";
+    kind: "move";
+    to: string | [number, number] | import('..').PolarPosition;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"line">;
+    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: "line";
+    to: string | [number, number] | import('..').PolarPosition;
+}, {
+    type: "step";
+    kind: "line";
+    to: string | [number, number] | import('..').PolarPosition;
+}>]>;
+/** Move step：移动游标但不绘制 */
+export type IRMoveStep = z.infer<typeof MoveStepSchema>;
+/** Line step：从游标到目标画直线 */
+export type IRLineStep = z.infer<typeof LineStepSchema>;
+/**
+ * 路径上的一个动作。v0.1.0-alpha 仅支持 'move' 与 'line'。
+ * 后续会加 'step'（折角）、'curve'、'cubic'、'rel'、'close' 等。
+ */
+export type IRStep = z.infer<typeof StepSchema>;
+//# sourceMappingURL=step.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,16 @@
+import { TargetSchema } from "./target.js";
+import { z } from "zod";
+//#region src/ir/path/step.ts
+var MoveStepSchema = z.object({
+	type: z.literal("step").describe("Discriminator marking this as a path step node"),
+	kind: z.literal("move").describe("Move the cursor to the target without drawing (like SVG path \"M\")"),
+	to: TargetSchema.describe("Destination point of the move")
+}).describe("Move action: relocate the path cursor without drawing");
+var LineStepSchema = z.object({
+	type: z.literal("step").describe("Discriminator marking this as a path step node"),
+	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`");
+//#endregion
+export { LineStepSchema, MoveStepSchema, StepSchema };

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

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare const TargetSchema: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+/** 路径端点：直接坐标 [x, y]、极坐标，或节点 id 字符串 */
+export type IRTarget = z.infer<typeof TargetSchema>;
+//# sourceMappingURL=target.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/target.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,YAAY,0JAItB,CAAC;AAEJ,sCAAsC;AACtC,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

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

@@ -0,0 +1,11 @@
+import { PositionSchema } from "../position/position.js";
+import { PolarPositionSchema } from "../position/polar-position.js";
+import { z } from "zod";
+//#region src/ir/path/target.ts
+var TargetSchema = z.union([
+	PositionSchema,
+	PolarPositionSchema,
+	z.string().min(1)
+]).describe("Path endpoint: Cartesian [x, y], polar position (resolved at compile time), or node id reference");
+//#endregion
+export { TargetSchema };

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

@@ -0,0 +1,3 @@
+export * from './position';
+export * from './polar-position';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ir/position/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC"}

package/dist/es/ir/position/polar-position.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { PolarPosition } from '../../geometry/polar';
+/**
+ * 极坐标点 schema（递归——origin 可嵌套）。
+ * 用 z.lazy 处理自引用；TS 类型从 geometry/polar 导入并 cast 到 schema。
+ */
+export declare const PolarPositionSchema: z.ZodType<PolarPosition>;
+export type { PolarPosition } from '../../geometry/polar';
+//# sourceMappingURL=polar-position.d.ts.map

package/dist/es/ir/position/polar-position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polar-position.d.ts","sourceRoot":"","sources":["../../../../src/ir/position/polar-position.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAG1D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAmBxD,CAAC;AAGF,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/es/ir/position/polar-position.js

@@ -0,0 +1,18 @@
+import { PositionSchema } from "./position.js";
+import { z } from "zod";
+//#region src/ir/position/polar-position.ts
+/**
+* 极坐标点 schema（递归——origin 可嵌套）。
+* 用 z.lazy 处理自引用；TS 类型从 geometry/polar 导入并 cast 到 schema。
+*/
+var PolarPositionSchema = z.lazy(() => z.object({
+	origin: z.union([
+		z.string().min(1),
+		PositionSchema,
+		PolarPositionSchema
+	]).optional().describe("Origin reference: node id string, Cartesian [x, y], or nested PolarPosition (chained); defaults to [0, 0] when omitted"),
+	angle: z.number().describe("Angle in degrees, counter-clockwise positive (TikZ convention)"),
+	radius: z.number().describe("Radius / distance in user units")
+}).describe("Polar coordinate position; resolved to Cartesian at Scene compile time"));
+//#endregion
+export { PolarPositionSchema };

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

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare const PositionSchema: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+/** 笛卡尔坐标 [x, y] */
+export type IRPosition = z.infer<typeof PositionSchema>;
+//# sourceMappingURL=position.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"position.d.ts","sourceRoot":"","sources":["../../../../src/ir/position/position.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc,8CAEa,CAAC;AAEzC,mBAAmB;AACnB,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/es/ir/position/position.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+//#region src/ir/position/position.ts
+var PositionSchema = z.tuple([z.number(), z.number()]).describe("Cartesian position [x, y]");
+//#endregion
+export { PositionSchema };