@retikz/core 0.1.0 → 0.2.0-alpha.1

package/dist/lib/compile/compile.cjs

@@ -1,4 +1,6 @@
 const require_rect = require("../geometry/rect.cjs");
+const require_name_stack = require("./name-stack.cjs");
+const require_scope = require("./scope.cjs");
 const require_position = require("./position.cjs");
 const require_node = require("./node.cjs");
 const require_text_metrics = require("./text-metrics.cjs");
@@ -7,15 +9,16 @@ const require_precision = require("./precision.cjs");
 const require_layout = require("./layout.cjs");
 //#region src/compile/compile.ts
 /**
-* 把 coordinate 注册成 0×0 NodeLayout
-* @description 让后续 path target / `at.of` 引用时 boundaryPoint 命中中心，符合"占位无形状边界"语义
+* 构造一个落在指定全局点的 0×0 rectangle NodeLayout
+* @description coordinate / scope.id 入场临时占位等"无形状只有位置"句柄共享此结构，
+*   让后续 path target / `at.of` / `offset.of` / `polar.origin` 引用时 boundaryPoint 命中中心。
 */
-var coordinateAsLayout = (id, center) => ({
+var zeroSizeRectAt = (id, [cx, cy]) => ({
 	id,
 	shape: "rectangle",
 	rect: {
-		x: center[0],
-		y: center[1],
+		x: cx,
+		y: cy,
 		width: 0,
 		height: 0,
 		rotate: 0
@@ -29,6 +32,20 @@ var coordinateAsLayout = (id, center) => ({
 	fontSize: 0
 });
 /**
+* 把 coordinate 注册成 0×0 NodeLayout
+* @description 让后续 path target / `at.of` 引用时 boundaryPoint 命中中心，符合"占位无形状边界"语义
+*/
+var coordinateAsLayout = (id, center) => zeroSizeRectAt(id, center);
+/**
+* scope.id 入场时的临时占位 NodeLayout
+* @description scope 子树尚未处理时先放 0×0 占位（落在 scope 局部原点经累积 chain 投到全局的位置），
+*   让 scope 子树内任何 lookup 不返回 undefined（占位语义自洽）。
+*   子树 Pass 1 处理完毕后由 `registerScopeAsLayout` 算出真 bbox layout 覆盖此占位（NameStack.replaceLayout 不发 duplicate warn）
+*/
+var scopePlaceholderLayout = (id, chain) => {
+	return zeroSizeRectAt(id, chain.length === 0 ? [0, 0] : require_scope.applyTransformChain([0, 0], chain));
+};
+/**
 * 默认 warn dispatcher：dev 模式 console.warn、生产静默
 * @description 用户传 onWarn 时使用用户的；不传走此 fallback
 */
@@ -36,9 +53,29 @@ var defaultWarnDispatcher = (warning) => {
 	if (typeof process !== "undefined" && process.env.NODE_ENV === "production") return;
 	console.warn(`[retikz] ${warning.code} at ${warning.path}: ${warning.message}`);
 };
+/** scope.transforms 解析失败时根据失败成因映射的 warn code */
+var scopeTransformWarnCode = (scope) => {
+	for (const t of scope.transforms ?? []) {
+		if (t.kind === "offset-translate") return "OFFSET_BASE_UNRESOLVED";
+		if (t.kind === "at-translate") return "AT_TARGET_UNRESOLVED";
+		if (t.kind === "polar-translate") return "POLAR_ORIGIN_UNRESOLVED";
+	}
+	return "UNRESOLVED_NODE_REFERENCE";
+};
+/** 把 DuplicateRegisterInfo 翻成 CompileWarning（含可读 message + 双 IR locator） */
+var formatDuplicateWarning = (info) => {
+	const frameNote = info.frameDepth === 0 ? "frame depth: 0 (root namespace)" : `frame depth: ${info.frameDepth} (under <Scope localNamespace>)`;
+	const firstLoc = info.firstIrPath ?? "(unknown earlier location)";
+	const secondLoc = info.secondIrPath ?? "(unknown current location)";
+	return {
+		code: "DUPLICATE_NODE_ID",
+		message: `Duplicate id '${info.id}' registered in the same namespace frame (${frameNote}); first defined at ${firstLoc}, redefined at ${secondLoc}. The later definition overrides the earlier one (last-wins).`,
+		path: secondLoc
+	};
+};
 /**
 * IR → Scene 纯函数转换，所有 adapter 共享
-* @description Pass 1 处理 Node/coordinate 并注册 nodeIndex、发 primitive、累积 bbox；Pass 2 解析 Path 端点写 d 字符串；末端按 precision 折算 layout
+* @description Pass 1 递归处理 node / coordinate / scope，把 scope 树下沉为嵌套 GroupPrim；scope.transforms 中的 4 种 translate 变体按 lowerScopeTransforms 展平为 Cartesian transform；node 在 Scene primitive 树里是局部坐标 + GroupPrim transform 链、在 NameStack 中存全局坐标供其他节点 / path 引用。NameStack 用栈式 frame 管理命名空间：默认全局扁平、`<Scope localNamespace>` 推入子 frame；scope.id 始终在父 frame 注册（外部句柄）；id lookup 从栈顶向栈底 inside-out 搜索；同 frame 重复 id 触发 DUPLICATE_NODE_ID warn + 后定义覆盖前定义。Pass 2 解析 path 端点写 d 字符串，path primitive 发到 Pass 1 记录的对应容器；末端按 precision 折算 layout
 */
 var compileToScene = (ir, options = {}) => {
 	const measureText = options.measureText ?? require_text_metrics.fallbackMeasurer;
@@ -47,46 +84,117 @@ var compileToScene = (ir, options = {}) => {
 	const nodeDistance = options.nodeDistance;
 	const onWarn = options.onWarn ?? defaultWarnDispatcher;
 	const primitives = [];
-	const nodeIndex = /* @__PURE__ */ new Map();
+	const nameStack = new require_name_stack.NameStack({ onDuplicate: (info) => onWarn(formatDuplicateWarning(info)) });
 	const allPoints = [];
-	const nodeLayouts = /* @__PURE__ */ new Map();
-	for (let i = 0; i < ir.children.length; i++) {
-		const child = ir.children[i];
-		if (child.type === "node") {
-			const layout = require_node.layoutNode(child, measureText, nodeIndex, nodeDistance);
-			if (child.id) nodeIndex.set(child.id, layout);
-			nodeLayouts.set(i, layout);
-		} else if (child.type === "coordinate") {
-			const center = require_position.resolvePosition(child.position, nodeIndex, nodeDistance);
-			if (!center) {
-				onWarn({
-					code: "POLAR_ORIGIN_UNRESOLVED",
-					message: `Cannot resolve position for coordinate '${child.id}'; polar.origin or at.of may reference an undefined node`,
-					path: `children[${i}].coordinate.position`
+	/**
+	* 解析一批本层收集的 pending paths（lookup-only 阶段）
+	* @description path primitive 一律 push 到顶层 `primitives` —— 端点已是全局坐标，不能进 GroupPrim 否则被 scope.transform 二次 apply。NameStack 切到 pass2 守门：path 解析中误调 register 抛 internal error；解析完切回 pass1 让上层 scope 子树继续 register 子节点。
+	*   `item.scopeChain` 记录该 path 所属 scope 累积 transform 链——传给 emitPathPrimitive，
+	*   让 step.to 内的 polar/at/offset 字面量按"当前 scope 局部度量 + 末端 apply chain"投影回全局。
+	*/
+	const resolvePendingPaths = (pending) => {
+		if (pending.length === 0) return;
+		nameStack.enterLookupPhase();
+		try {
+			for (const item of pending) {
+				const result = require_index.emitPathPrimitive(item.path, nameStack, round, measureText, {
+					onWarn,
+					irPath: item.irPath,
+					scopeChain: item.scopeChain
 				});
-				throw new Error(`Cannot resolve position for coordinate ${child.id}; polar.origin or at.of may reference an undefined node`);
+				if (result) {
+					for (const prim of result.primitives) primitives.push(prim);
+					for (const p of result.points) allPoints.push(p);
+				}
 			}
-			nodeIndex.set(child.id, coordinateAsLayout(child.id, center));
+		} finally {
+			nameStack.exitLookupPhase();
 		}
-	}
-	for (let i = 0; i < ir.children.length; i++) {
-		const child = ir.children[i];
-		if (child.type === "node") {
-			const layout = nodeLayouts.get(i);
-			if (!layout) continue;
-			for (const prim of require_node.emitNodePrimitives(layout, round)) primitives.push(prim);
-			allPoints.push(require_rect.rect.anchor(layout.rect, "north-west"), require_rect.rect.anchor(layout.rect, "north-east"), require_rect.rect.anchor(layout.rect, "south-west"), require_rect.rect.anchor(layout.rect, "south-east"));
-		} else if (child.type === "path") {
-			const result = require_index.emitPathPrimitive(child, nodeIndex, round, measureText, {
-				onWarn,
-				irPath: `children[${i}].path`
+	};
+	/**
+	* 递归处理一组 IR child，把 node / coordinate 发到 sink、把本层 path 收集到 pathsAccumulator、scope 下沉为 GroupPrim
+	* @description **不**在内部 resolve pathsAccumulator——调用方负责在合适时机（scope 入口：bbox replaceLayout 之后 / popFrame 之前；顶层：所有处理结束后）调用 resolvePendingPaths。这样 scope.id 的 placeholder→real bbox 替换在本层 path 端点 lookup 之前完成，避免 "scope 内 path 自引用本 scope.id 拿到 placeholder" 的 latent bug，同时保留 ADR-02 的 "本层 path 在本层 frame 还在栈顶时 resolve" inside-out lookup 语义。
+	* @param children 当前层级的 IR child 数组
+	* @param chain 从根到当前层级累积的 Cartesian-only transform 链
+	* @param sink 当前层级 Scene primitive 落点（顶层 = primitives，scope 内 = GroupPrim.children）
+	* @param locatorPrefix IR locator 前缀（如 `''` 表示顶层、`children[2].scope.` 表示某 scope 内）
+	* @param layoutsAccumulator 当前 scope 子树所有"实体"layout（node / coordinate / 嵌套 scope.id synthetic）累积——专给上层 scope.id bbox 计算用；顶层调用传一个共享数组（用得着就用，丢弃也不影响）
+	* @param pathsAccumulator 当前层级收集的 pending paths——由调用方分配并在合适时机 resolve
+	*/
+	const processChildren = (children, chain, sink, locatorPrefix, layoutsAccumulator, pathsAccumulator) => {
+		for (let i = 0; i < children.length; i++) {
+			const child = children[i];
+			if (child.type === "node") {
+				const layout = require_node.layoutNode(child, measureText, nameStack, nodeDistance, chain);
+				const globalLayout = chain.length === 0 ? layout : require_scope.projectLayoutToGlobal(layout, chain);
+				if (child.id) nameStack.register(child.id, globalLayout, `${locatorPrefix}children[${i}].node.id`);
+				for (const prim of require_node.emitNodePrimitives(layout, round)) sink.push(prim);
+				allPoints.push(require_rect.rect.anchor(globalLayout.rect, "north-west"), require_rect.rect.anchor(globalLayout.rect, "north-east"), require_rect.rect.anchor(globalLayout.rect, "south-west"), require_rect.rect.anchor(globalLayout.rect, "south-east"));
+				layoutsAccumulator.push(globalLayout);
+			} else if (child.type === "coordinate") {
+				const localCenter = require_position.resolvePosition(child.position, nameStack, nodeDistance, chain);
+				if (!localCenter) {
+					onWarn({
+						code: "POLAR_ORIGIN_UNRESOLVED",
+						message: `Cannot resolve position for coordinate '${child.id}'; polar.origin or at.of may reference an undefined node`,
+						path: `${locatorPrefix}children[${i}].coordinate.position`
+					});
+					throw new Error(`Cannot resolve position for coordinate ${child.id}; polar.origin or at.of may reference an undefined node`);
+				}
+				const globalCenter = chain.length === 0 ? localCenter : require_scope.applyTransformChain(localCenter, chain);
+				const coordLayout = coordinateAsLayout(child.id, globalCenter);
+				nameStack.register(child.id, coordLayout, `${locatorPrefix}children[${i}].coordinate.id`);
+				layoutsAccumulator.push(coordLayout);
+			} else if (child.type === "scope") {
+				const loweredOwn = require_scope.lowerScopeTransforms(child.transforms ?? [], nameStack, nodeDistance);
+				if (loweredOwn === null) onWarn({
+					code: scopeTransformWarnCode(child),
+					message: `Cannot resolve one of scope.transforms; referent (at.of / offset.of / polar.origin) is undefined or defined later in the IR`,
+					path: `${locatorPrefix}children[${i}].scope.transforms`
+				});
+				const ownTransforms = loweredOwn ?? [];
+				const innerChain = [...chain, ...ownTransforms];
+				const parentFrameDepth = nameStack.depth - 1;
+				if (child.id) nameStack.register(child.id, scopePlaceholderLayout(child.id, innerChain), `${locatorPrefix}children[${i}].scope.id`);
+				const pushedFrame = child.localNamespace === true;
+				if (pushedFrame) nameStack.pushFrame();
+				const innerSink = [];
+				/** 本 scope 子树的 layouts 累积器；子树结束后用于算 bbox */
+				const innerLayouts = [];
+				/** 本 scope 子树收集的 pending paths——在 bbox replaceLayout 后 / popFrame 前 resolve，
+				*  让 scope 内 path 自引用本 scope.id 端点取真 bbox 而非 placeholder */
+				const innerPaths = [];
+				try {
+					processChildren(child.children, innerChain, innerSink, `${locatorPrefix}children[${i}].scope.`, innerLayouts, innerPaths);
+					if (child.id) {
+						const bbox = require_scope.computeScopeBoundingBox(innerLayouts);
+						const fallbackOrigin = innerChain.length === 0 ? [0, 0] : require_scope.applyTransformChain([0, 0], innerChain);
+						const bboxLayout = require_scope.registerScopeAsLayout(child.id, bbox, fallbackOrigin);
+						nameStack.replaceLayout(child.id, bboxLayout, parentFrameDepth);
+						layoutsAccumulator.push(bboxLayout);
+					} else for (const innerLayout of innerLayouts) layoutsAccumulator.push(innerLayout);
+					resolvePendingPaths(innerPaths);
+				} finally {
+					if (pushedFrame) nameStack.popFrame();
+				}
+				const hasOwnTransforms = ownTransforms.length > 0;
+				if (innerSink.length === 0 && !hasOwnTransforms && child.id === void 0) continue;
+				const group = {
+					type: "group",
+					children: innerSink
+				};
+				if (hasOwnTransforms) group.transforms = [...ownTransforms];
+				sink.push(group);
+			} else pathsAccumulator.push({
+				path: child,
+				irPath: `${locatorPrefix}children[${i}].path`,
+				scopeChain: chain
 			});
-			if (result) {
-				for (const prim of result.primitives) primitives.push(prim);
-				for (const p of result.points) allPoints.push(p);
-			}
 		}
-	}
+	};
+	const rootPaths = [];
+	processChildren(ir.children, [], primitives, "", [], rootPaths);
+	resolvePendingPaths(rootPaths);
 	return {
 		primitives,
 		layout: require_layout.computeLayout(allPoints, layoutPadding, round)

package/dist/lib/compile/compile.d.ts

@@ -7,7 +7,7 @@ export type CompileWarning = {
      * 警告类型代码（机器可读）
      * @description 用户可按 code 分支处理；未来 alpha 加新 code 不破坏调用方
      */
-    code: 'UNRESOLVED_NODE_REFERENCE' | 'PATH_TOO_SHORT' | 'ANCHOR_RESOLUTION_FAILED' | 'OFFSET_BASE_UNRESOLVED' | 'POLAR_ORIGIN_UNRESOLVED' | 'AT_TARGET_UNRESOLVED' | 'RELATIVE_INITIAL_NO_PREV_END' | 'BBOX_EXTREME_INPUT' | (string & {});
+    code: 'UNRESOLVED_NODE_REFERENCE' | 'PATH_TOO_SHORT' | 'ANCHOR_RESOLUTION_FAILED' | 'OFFSET_BASE_UNRESOLVED' | 'POLAR_ORIGIN_UNRESOLVED' | 'AT_TARGET_UNRESOLVED' | 'RELATIVE_INITIAL_NO_PREV_END' | 'BBOX_EXTREME_INPUT' | 'DUPLICATE_NODE_ID' | (string & {});
     /** 人类可读消息（英文） */
     message: string;
     /** IR locator 路径（jq-like，如 `'children[3].path.children[1].to'`） */
@@ -37,7 +37,7 @@ export type CompileOptions = {
 };
 /**
  * IR → Scene 纯函数转换，所有 adapter 共享
- * @description Pass 1 处理 Node/coordinate 并注册 nodeIndex、发 primitive、累积 bbox；Pass 2 解析 Path 端点写 d 字符串；末端按 precision 折算 layout
+ * @description Pass 1 递归处理 node / coordinate / scope，把 scope 树下沉为嵌套 GroupPrim；scope.transforms 中的 4 种 translate 变体按 lowerScopeTransforms 展平为 Cartesian transform；node 在 Scene primitive 树里是局部坐标 + GroupPrim transform 链、在 NameStack 中存全局坐标供其他节点 / path 引用。NameStack 用栈式 frame 管理命名空间：默认全局扁平、`<Scope localNamespace>` 推入子 frame；scope.id 始终在父 frame 注册（外部句柄）；id lookup 从栈顶向栈底 inside-out 搜索；同 frame 重复 id 触发 DUPLICATE_NODE_ID warn + 后定义覆盖前定义。Pass 2 解析 path 端点写 d 字符串，path primitive 发到 Pass 1 记录的对应容器；末端按 precision 折算 layout
  */
 export declare const compileToScene: (ir: IR, options?: CompileOptions) => Scene;
 //# sourceMappingURL=compile.d.ts.map

package/dist/lib/compile/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/compile/compile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAc,MAAM,OAAO,CAAC;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAkB,MAAM,cAAc,CAAC;AAK1D,OAAO,EAAE,KAAK,YAAY,EAAoB,MAAM,gBAAgB,CAAC;AAuBrE,uEAAuE;AACvE,MAAM,MAAM,cAAc,GAAG;IAC3B;;;OAGG;IACH,IAAI,EACA,2BAA2B,GAC3B,gBAAgB,GAChB,0BAA0B,GAC1B,wBAAwB,GACxB,yBAAyB,GACzB,sBAAsB,GACtB,8BAA8B,GAC9B,oBAAoB,GACpB,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;IAClB,iBAAiB;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,2BAA2B;AAC3B,MAAM,MAAM,cAAc,GAAG;IAC3B,oCAAoC;IACpC,WAAW,CAAC,EAAE,YAAY,CAAC;IAC3B,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;CAC5C,CAAC;AAWF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,IAAI,EAAE,EAAE,UAAS,cAAmB,KAAG,KAwErE,CAAC"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/compile/compile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAwC,MAAM,OAAO,CAAC;AACtE,OAAO,KAAK,EAAa,KAAK,EAA6B,MAAM,cAAc,CAAC;AAahF,OAAO,EAAE,KAAK,YAAY,EAAoB,MAAM,gBAAgB,CAAC;AA2CrE,uEAAuE;AACvE,MAAM,MAAM,cAAc,GAAG;IAC3B;;;OAGG;IACH,IAAI,EACA,2BAA2B,GAC3B,gBAAgB,GAChB,0BAA0B,GAC1B,wBAAwB,GACxB,yBAAyB,GACzB,sBAAsB,GACtB,8BAA8B,GAC9B,oBAAoB,GACpB,mBAAmB,GACnB,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;IAClB,iBAAiB;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,2BAA2B;AAC3B,MAAM,MAAM,cAAc,GAAG;IAC3B,oCAAoC;IACpC,WAAW,CAAC,EAAE,YAAY,CAAC;IAC3B,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;CAC5C,CAAC;AAsDF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,IAAI,EAAE,EAAE,UAAS,cAAmB,KAAG,KAoMrE,CAAC"}

package/dist/lib/compile/index.d.ts

@@ -4,6 +4,7 @@ export * from './parseTarget';
 export * from './path/index';
 export * from './position';
 export * from './precision';
+export * from './scope';
 export * from './text-metrics';
 export * from './layout';
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/compile/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/compile/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/compile/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC"}

package/dist/lib/compile/name-stack.cjs

@@ -0,0 +1,104 @@
+//#region src/compile/name-stack.ts
+/**
+* 栈式 namespace frame —— 默认全局扁平、`<Scope localNamespace>` 时 pushFrame 隔离
+* @description 内部维护 `Array<Map<string, NodeLayout>>`，栈底是根 frame；
+*   register 写入栈顶 frame；lookup 从栈顶向栈底 inside-out 搜索（内层 shadowing 外层）；
+*   同 frame 同 id 触发 onDuplicate + last-wins 覆盖（不抛错）；跨 frame 同 id 不算 duplicate；
+*   Pass 1 = register-only，Pass 2 = lookup-only，phase 状态守护违规调用
+*/
+var NameStack = class {
+	/** 栈式 frame 容器；栈底（index 0）= 根 frame，栈顶（last）= 当前 frame */
+	frames;
+	/** 与每个 frame 对应的"已注册 id → 首次 register 时的 irPath"映射，用于 duplicate warn 复述位置 */
+	firstIrPaths;
+	onDuplicate;
+	/** 当前阶段；compile Pass 1 = 'pass1'（register 合法），Pass 2 = 'pass2'（只能 lookup） */
+	currentPhase = "pass1";
+	constructor(options = {}) {
+		this.frames = [/* @__PURE__ */ new Map()];
+		this.firstIrPaths = [/* @__PURE__ */ new Map()];
+		this.onDuplicate = options.onDuplicate;
+	}
+	/** 当前栈深（≥ 1；根 frame 永远存在） */
+	get depth() {
+		return this.frames.length;
+	}
+	/** 当前阶段（'pass1' / 'pass2'） */
+	get phase() {
+		return this.currentPhase;
+	}
+	/** 推入新 frame；通常对应 `<Scope localNamespace>` 入场 */
+	pushFrame() {
+		this.frames.push(/* @__PURE__ */ new Map());
+		this.firstIrPaths.push(/* @__PURE__ */ new Map());
+	}
+	/**
+	* 弹出栈顶 frame；通常对应 `<Scope localNamespace>` 出场
+	* @description 禁止把栈弹空（根 frame 必须始终存在）；意外调用抛 internal error 暴露 bug
+	*/
+	popFrame() {
+		if (this.frames.length <= 1) throw new Error("NameStack.popFrame: cannot pop the root frame (internal invariant violated)");
+		this.frames.pop();
+		this.firstIrPaths.pop();
+	}
+	/** 切换到 Pass 2（lookup-only）阶段；切换后 register 调用一律抛 internal error */
+	enterLookupPhase() {
+		this.currentPhase = "pass2";
+	}
+	/** 切回 Pass 1（register + lookup 均可）阶段；用于嵌套 path-resolve 完成后继续处理上层 scope 子树 */
+	exitLookupPhase() {
+		this.currentPhase = "pass1";
+	}
+	/**
+	* 注册一条 id → NodeLayout 到栈顶 frame
+	* @description 若栈顶 frame 已有同 id：触发 onDuplicate 回调（first register 不触发），用新 layout last-wins 覆盖；返回是否覆盖了已有 entry
+	* @param id 要注册的 id（node.id / coordinate.id / scope.id）
+	* @param layout 对应的 NodeLayout
+	* @param irPath 触发此次 register 的 IR locator（jq-like 路径），用于 duplicate warn
+	* @returns true = 当前 frame 已有同 id 被覆盖；false = 新 entry
+	*/
+	register(id, layout, irPath) {
+		if (this.currentPhase !== "pass1") throw new Error(`NameStack.register('${id}'): only allowed during pass1; current phase is '${this.currentPhase}'`);
+		const topFrame = this.frames[this.frames.length - 1];
+		const topFirstPaths = this.firstIrPaths[this.firstIrPaths.length - 1];
+		const wasOverwritten = topFrame.has(id);
+		if (wasOverwritten) this.onDuplicate?.({
+			id,
+			frameDepth: this.frames.length - 1,
+			firstIrPath: topFirstPaths.get(id),
+			secondIrPath: irPath
+		});
+		else topFirstPaths.set(id, irPath);
+		topFrame.set(id, layout);
+		return wasOverwritten;
+	}
+	/**
+	* 在指定深度的 frame 上替换已注册 id 对应的 layout，**不触发** onDuplicate 回调
+	* @description 专为"scope.id 入场注册临时占位 layout、子树结束后用真 bbox layout 覆盖"流程设计——
+	*   同一 scope.id 的两次 register 是预期的 placeholder → real-bbox 接力，不是命名冲突；
+	*   此 API 跳过 duplicate 检测但保留 firstIrPath（不刷新 first-register 位置）。
+	*   若指定 frame 不存在该 id（说明 id 没被 register 过），抛 internal error 暴露调用方 bug
+	* @param id 要替换的 id（必须已在该 frame 注册过）
+	* @param layout 新的 NodeLayout（覆盖旧值）
+	* @param frameDepth 0 = 根 frame；通常传 scope 入场前的栈深 - 1
+	*/
+	replaceLayout(id, layout, frameDepth) {
+		if (this.currentPhase !== "pass1") throw new Error(`NameStack.replaceLayout('${id}'): only allowed during pass1; current phase is '${this.currentPhase}'`);
+		if (frameDepth < 0 || frameDepth >= this.frames.length) throw new Error(`NameStack.replaceLayout('${id}'): frameDepth ${frameDepth} out of range (stack depth ${this.frames.length})`);
+		const targetFrame = this.frames[frameDepth];
+		if (!targetFrame.has(id)) throw new Error(`NameStack.replaceLayout('${id}'): id not previously registered in frame at depth ${frameDepth}`);
+		targetFrame.set(id, layout);
+	}
+	/**
+	* inside-out 查找 id 对应的 NodeLayout
+	* @description 从栈顶向栈底依次查找；首个命中的 frame 返回；都没命中返回 undefined。内层可见外层（shadowing），外层不可见内层
+	*/
+	lookup(id) {
+		for (let i = this.frames.length - 1; i >= 0; i--) {
+			const layout = this.frames[i].get(id);
+			if (layout !== void 0) return layout;
+		}
+	}
+};
+//#endregion
+exports.NameStack = NameStack;

package/dist/lib/compile/name-stack.d.ts

@@ -0,0 +1,81 @@
+import { NodeLayout } from './node';
+/**
+ * 单条 duplicate warn 由 NameStack 通过 onDuplicate 回调向外发出的载荷
+ * @description 由 compile 层把 NameStack 内部 frame depth + 前后两次 IR locator 翻译成 CompileWarning（含可读 message）；NameStack 不知道 CompileWarning 的具体形态，避免反向耦合
+ */
+export type DuplicateRegisterInfo = {
+    /** 同 frame 内重复出现的 id（两次 register 都用此 id） */
+    id: string;
+    /** 当前 frame 在栈中的深度（0 = 根 frame；每层 pushFrame 自增 1） */
+    frameDepth: number;
+    /** 先注册的那一条的 IR locator（jq-like 路径），register 时传入；缺失则 undefined */
+    firstIrPath?: string;
+    /** 后注册（本次触发覆盖）的那一条的 IR locator */
+    secondIrPath?: string;
+};
+/** NameStack 构造选项 */
+export type NameStackOptions = {
+    /**
+     * 同 frame 重复 register 时的回调
+     * @description 第 N 次 register（N ≥ 2）发一次；first register 不发；NameStack 不直接发 CompileWarning，由 compile 层翻译
+     */
+    onDuplicate?: (info: DuplicateRegisterInfo) => void;
+};
+/**
+ * 栈式 namespace frame —— 默认全局扁平、`<Scope localNamespace>` 时 pushFrame 隔离
+ * @description 内部维护 `Array<Map<string, NodeLayout>>`，栈底是根 frame；
+ *   register 写入栈顶 frame；lookup 从栈顶向栈底 inside-out 搜索（内层 shadowing 外层）；
+ *   同 frame 同 id 触发 onDuplicate + last-wins 覆盖（不抛错）；跨 frame 同 id 不算 duplicate；
+ *   Pass 1 = register-only，Pass 2 = lookup-only，phase 状态守护违规调用
+ */
+export declare class NameStack {
+    /** 栈式 frame 容器；栈底（index 0）= 根 frame，栈顶（last）= 当前 frame */
+    private readonly frames;
+    /** 与每个 frame 对应的"已注册 id → 首次 register 时的 irPath"映射，用于 duplicate warn 复述位置 */
+    private readonly firstIrPaths;
+    private readonly onDuplicate?;
+    /** 当前阶段；compile Pass 1 = 'pass1'（register 合法），Pass 2 = 'pass2'（只能 lookup） */
+    private currentPhase;
+    constructor(options?: NameStackOptions);
+    /** 当前栈深（≥ 1；根 frame 永远存在） */
+    get depth(): number;
+    /** 当前阶段（'pass1' / 'pass2'） */
+    get phase(): 'pass1' | 'pass2';
+    /** 推入新 frame；通常对应 `<Scope localNamespace>` 入场 */
+    pushFrame(): void;
+    /**
+     * 弹出栈顶 frame；通常对应 `<Scope localNamespace>` 出场
+     * @description 禁止把栈弹空（根 frame 必须始终存在）；意外调用抛 internal error 暴露 bug
+     */
+    popFrame(): void;
+    /** 切换到 Pass 2（lookup-only）阶段；切换后 register 调用一律抛 internal error */
+    enterLookupPhase(): void;
+    /** 切回 Pass 1（register + lookup 均可）阶段；用于嵌套 path-resolve 完成后继续处理上层 scope 子树 */
+    exitLookupPhase(): void;
+    /**
+     * 注册一条 id → NodeLayout 到栈顶 frame
+     * @description 若栈顶 frame 已有同 id：触发 onDuplicate 回调（first register 不触发），用新 layout last-wins 覆盖；返回是否覆盖了已有 entry
+     * @param id 要注册的 id（node.id / coordinate.id / scope.id）
+     * @param layout 对应的 NodeLayout
+     * @param irPath 触发此次 register 的 IR locator（jq-like 路径），用于 duplicate warn
+     * @returns true = 当前 frame 已有同 id 被覆盖；false = 新 entry
+     */
+    register(id: string, layout: NodeLayout, irPath?: string): boolean;
+    /**
+     * 在指定深度的 frame 上替换已注册 id 对应的 layout，**不触发** onDuplicate 回调
+     * @description 专为"scope.id 入场注册临时占位 layout、子树结束后用真 bbox layout 覆盖"流程设计——
+     *   同一 scope.id 的两次 register 是预期的 placeholder → real-bbox 接力，不是命名冲突；
+     *   此 API 跳过 duplicate 检测但保留 firstIrPath（不刷新 first-register 位置）。
+     *   若指定 frame 不存在该 id（说明 id 没被 register 过），抛 internal error 暴露调用方 bug
+     * @param id 要替换的 id（必须已在该 frame 注册过）
+     * @param layout 新的 NodeLayout（覆盖旧值）
+     * @param frameDepth 0 = 根 frame；通常传 scope 入场前的栈深 - 1
+     */
+    replaceLayout(id: string, layout: NodeLayout, frameDepth: number): void;
+    /**
+     * inside-out 查找 id 对应的 NodeLayout
+     * @description 从栈顶向栈底依次查找；首个命中的 frame 返回；都没命中返回 undefined。内层可见外层（shadowing），外层不可见内层
+     */
+    lookup(id: string): NodeLayout | undefined;
+}
+//# sourceMappingURL=name-stack.d.ts.map

package/dist/lib/compile/name-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name-stack.d.ts","sourceRoot":"","sources":["../../../src/compile/name-stack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEzC;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,4CAA4C;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kCAAkC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,qBAAqB;AACrB,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,CAAC;CACrD,CAAC;AAEF;;;;;;GAMG;AACH,qBAAa,SAAS;IACpB,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,6EAA6E;IAC7E,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyC;IACtE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAwC;IACrE,6EAA6E;IAC7E,OAAO,CAAC,YAAY,CAA8B;gBAEtC,OAAO,GAAE,gBAAqB;IAM1C,6BAA6B;IAC7B,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,8BAA8B;IAC9B,IAAI,KAAK,IAAI,OAAO,GAAG,OAAO,CAE7B;IAED,iDAAiD;IACjD,SAAS,IAAI,IAAI;IAKjB;;;OAGG;IACH,QAAQ,IAAI,IAAI;IAQhB,kEAAkE;IAClE,gBAAgB,IAAI,IAAI;IAIxB,6EAA6E;IAC7E,eAAe,IAAI,IAAI;IAIvB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO;IAuBlE;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAoBvE;;;OAGG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;CAO3C"}

package/dist/lib/compile/node.cjs

@@ -130,11 +130,16 @@ var labelCenter = (layout, label) => {
 };
 /**
 * 取节点 shape 在指定角度方向的边界点
-* @description 角度约定与 PolarPosition 一致（度数：0°=+x，90°=+y 即 screen 下方）；不应用 margin（同 anchorOf）；用于 `'A.30'` 落点
+* @description 角度是节点**局部坐标系**下的极角（度数：0°=局部 +x，90°=局部 +y）。layout.rect.rotate 把局部基绕中心旋转，得到世界系下的视觉方向；shape boundaryPoint 内部用 rotate-aware 投影，所以这里把局部 (cos, sin) 经 rect.rotate 旋转后加到中心当作世界系 toward 传入。不应用 margin（同 anchorOf）；用于 `'A.30'` 落点
 */
 var angleBoundaryOf = (layout, angleDeg) => {
 	const rad = angleDeg * Math.PI / 180;
-	const toward = [layout.rect.x + Math.cos(rad), layout.rect.y + Math.sin(rad)];
+	const lx = Math.cos(rad);
+	const ly = Math.sin(rad);
+	const rot = layout.rect.rotate ?? 0;
+	const cosR = Math.cos(rot);
+	const sinR = Math.sin(rot);
+	const toward = [layout.rect.x + lx * cosR - ly * sinR, layout.rect.y + lx * sinR + ly * cosR];
 	switch (layout.shape) {
 		case "rectangle": return require_rect.rect.boundaryPoint(rectOf(layout, 0), toward);
 		case "circle": return require_circle.circle.boundaryPoint(circleOf(layout, 0), toward);
@@ -144,9 +149,12 @@ var angleBoundaryOf = (layout, angleDeg) => {
 };
 /**
 * IR Node → 内部 NodeLayout
-* @description 文本度量 + padding 推内框半轴；按 shape 算外接边界（circle 取半对角线、ellipse ×√2、diamond ×2）；解析 position 为几何中心；rotate 度数转弧度
+* @description 文本度量 + padding 推内框半轴；按 shape 算外接边界（circle 取半对角线、ellipse ×√2、diamond ×2）；解析 position 为几何中心；rotate 度数转弧度。
+*   `scopeChain` 非空时 `resolvePosition` 返回**当前 scope 局部坐标**（relative position 在当前
+*   scope 局部度量），调用方负责后续 `projectLayoutToGlobal` / `applyTransformChain` 投回全局；
+*   笛卡尔字面量 `Position` 已在 scope 局部度量，行为延续 v0.1。
 */
-var layoutNode = (node, measureText, nodeIndex, nodeDistance) => {
+var layoutNode = (node, measureText, nameStack, nodeDistance, scopeChain = []) => {
 	const sx = node.xScale ?? node.scale ?? 1;
 	const sy = node.yScale ?? node.scale ?? 1;
 	const fontScale = Math.min(sx, sy);
@@ -217,7 +225,7 @@ var layoutNode = (node, measureText, nodeIndex, nodeDistance) => {
 			break;
 	}
 	const rotateDeg = node.rotate ?? 0;
-	const center = require_position.resolvePosition(node.position, nodeIndex, nodeDistance);
+	const center = require_position.resolvePosition(node.position, nameStack, nodeDistance, scopeChain);
 	if (!center) throw new Error(`Cannot resolve position for node ${node.id ?? "(unnamed)"}; polar.origin or at.of may reference an undefined node`);
 	const labels = (node.label === void 0 ? void 0 : Array.isArray(node.label) ? node.label : [node.label])?.map((lab) => {
 		const labFont = lab.font;

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

@@ -1,7 +1,8 @@
 import { Position } from '../geometry/point';
 import { Rect, RectAnchor } from '../geometry/rect';
 import { AtDirection, IRNode, NodeShape } from '../ir';
-import { ScenePrimitive, TextLine } from '../primitive';
+import { ScenePrimitive, TextLine, Transform } from '../primitive';
+import { NameStack } from './name-stack';
 import { TextMeasurer } from './text-metrics';
 export type NodeLayout = {
     /** 节点 id（其他位置可引用） */
@@ -88,14 +89,17 @@ export declare const boundaryPointOf: (layout: NodeLayout, toward: Position) =>
 export declare const anchorOf: (layout: NodeLayout, name: RectAnchor) => Position;
 /**
  * 取节点 shape 在指定角度方向的边界点
- * @description 角度约定与 PolarPosition 一致（度数：0°=+x，90°=+y 即 screen 下方）；不应用 margin（同 anchorOf）；用于 `'A.30'` 落点
+ * @description 角度是节点**局部坐标系**下的极角（度数：0°=局部 +x，90°=局部 +y）。layout.rect.rotate 把局部基绕中心旋转，得到世界系下的视觉方向；shape boundaryPoint 内部用 rotate-aware 投影，所以这里把局部 (cos, sin) 经 rect.rotate 旋转后加到中心当作世界系 toward 传入。不应用 margin（同 anchorOf）；用于 `'A.30'` 落点
  */
 export declare const angleBoundaryOf: (layout: NodeLayout, angleDeg: number) => Position;
 /**
  * IR Node → 内部 NodeLayout
- * @description 文本度量 + padding 推内框半轴；按 shape 算外接边界（circle 取半对角线、ellipse ×√2、diamond ×2）；解析 position 为几何中心；rotate 度数转弧度
+ * @description 文本度量 + padding 推内框半轴；按 shape 算外接边界（circle 取半对角线、ellipse ×√2、diamond ×2）；解析 position 为几何中心；rotate 度数转弧度。
+ *   `scopeChain` 非空时 `resolvePosition` 返回**当前 scope 局部坐标**（relative position 在当前
+ *   scope 局部度量），调用方负责后续 `projectLayoutToGlobal` / `applyTransformChain` 投回全局；
+ *   笛卡尔字面量 `Position` 已在 scope 局部度量，行为延续 v0.1。
  */
-export declare const layoutNode: (node: IRNode, measureText: TextMeasurer, nodeIndex: Map<string, NodeLayout>, nodeDistance?: number) => NodeLayout;
+export declare const layoutNode: (node: IRNode, measureText: TextMeasurer, nameStack: NameStack, nodeDistance?: number, scopeChain?: ReadonlyArray<Transform>) => NodeLayout;
 /**
  * NodeLayout → Scene primitives
  * @description shape 主体按 shape 分发（rect/ellipse/path）；text 始终走 TextPrim；有旋转时外层 GroupPrim 用 `rotate(deg cx cy)` 统一包裹（text 必须靠 group 旋转）

package/dist/lib/compile/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/compile/node.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/compile/node.ts"],"names":[],"mappings":"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"}

package/dist/lib/compile/path/anchor.cjs

@@ -1,44 +1,55 @@
+const require_scope = require("../scope.cjs");
 const require_position = require("../position.cjs");
 const require_node = require("../node.cjs");
+const require_anchor_cache = require("../anchor-cache.cjs");
 const require_parseTarget = require("../parseTarget.cjs");
 //#region src/compile/path/anchor.ts
 /**
 * 求 step.to 的参考点（给 boundary clip 算方向 / 折角 corner 用）
-* @description 三态：`'A'`(auto) 节点中心；`'A.<anchor>'`/`'A.<deg>'` 显式锚点 refPoint=endpoint 位置不随邻居变。直接坐标/极坐标解析为笛卡尔
+* @description 三态：`'A'`(auto) 节点中心；`'A.<anchor>'`/`'A.<deg>'` 显式锚点 refPoint=endpoint 位置不随邻居变。直接坐标/极坐标解析为笛卡尔。
+*   string id lookup 拿到的 layout 已是全局坐标——不走 scopeChain 投影；Position / Polar /
+*   At / Offset 字面量经 `resolvePosition(..., scopeChain)` 拿到当前 scope 局部坐标后
+*   `applyTransformChain` 投回全局。`scopeChain=[]` 等价 v0.1（恒等）。
 */
-var refPointOfTarget = (target, nodeIndex) => {
+var refPointOfTarget = (target, nameStack, scopeChain = []) => {
 	if (typeof target === "string") {
 		const ref = require_parseTarget.parseNodeRef(target);
-		const node = nodeIndex.get(ref.id);
+		const node = nameStack.lookup(ref.id);
 		if (!node) return null;
 		switch (ref.kind) {
 			case "node": return [node.rect.x, node.rect.y];
-			case "anchor": return require_node.anchorOf(node, ref.anchor);
-			case "angle": return require_node.angleBoundaryOf(node, ref.angle);
+			case "anchor": return require_anchor_cache.resolveAnchor(node, ref.anchor);
+			case "angle": return require_anchor_cache.resolveAnchor(node, String(ref.angle));
 		}
 	}
 	if (typeof target === "object" && !Array.isArray(target) && ("relative" in target || "relativeAccumulate" in target)) return null;
-	return require_position.resolvePosition(target, nodeIndex);
+	const local = require_position.resolvePosition(target, nameStack, void 0, scopeChain);
+	if (!local) return null;
+	return scopeChain.length === 0 ? local : require_scope.applyTransformChain(local, scopeChain);
 };
 /** 折角中间点：`-|` → (curr.x, prev.y)；`|-` → (prev.x, curr.y) */
 var cornerOf = (prev, curr, via) => via === "-|" ? [curr[0], prev[1]] : [prev[0], curr[1]];
 /**
 * 在 toward 方向算 step.to 的实际绘制端点
-* @description 节点 auto `'A'`：按 shape 走 boundaryPointOf 求中心→toward 射线交点；命名 anchor/角度：位置已定不受 toward 影响；直接坐标/极坐标：解析后返回；失败返回 null
+* @description 节点 auto `'A'`：按 shape 走 boundaryPointOf 求中心→toward 射线交点；命名 anchor/角度：位置已定不受 toward 影响；直接坐标/极坐标：解析后返回；失败返回 null。
+*   string id lookup 拿到的 layout 已是全局坐标；Position / Polar / At / Offset 字面量经
+*   `resolvePosition(..., scopeChain)` 拿到当前 scope 局部坐标后 `applyTransformChain` 投回全局。
 */
-var clipForTarget = (target, toward, nodeIndex) => {
+var clipForTarget = (target, toward, nameStack, scopeChain = []) => {
 	if (typeof target === "string") {
 		const ref = require_parseTarget.parseNodeRef(target);
-		const node = nodeIndex.get(ref.id);
+		const node = nameStack.lookup(ref.id);
 		if (!node) return null;
 		switch (ref.kind) {
 			case "node": return require_node.boundaryPointOf(node, toward);
-			case "anchor": return require_node.anchorOf(node, ref.anchor);
-			case "angle": return require_node.angleBoundaryOf(node, ref.angle);
+			case "anchor": return require_anchor_cache.resolveAnchor(node, ref.anchor);
+			case "angle": return require_anchor_cache.resolveAnchor(node, String(ref.angle));
 		}
 	}
 	if (typeof target === "object" && !Array.isArray(target) && ("relative" in target || "relativeAccumulate" in target)) return null;
-	return require_position.resolvePosition(target, nodeIndex);
+	const local = require_position.resolvePosition(target, nameStack, void 0, scopeChain);
+	if (!local) return null;
+	return scopeChain.length === 0 ? local : require_scope.applyTransformChain(local, scopeChain);
 };
 /** 两个 IRPosition 两分量精确相等（未 round） */
 var samePoint = (a, b) => !!a && !!b && a[0] === b[0] && a[1] === b[1];