feat: complete native traffic signal workflow

.trellis/spec/pipeline/cli-and-stages.md

@@ -414,6 +414,294 @@ GeoJSON，native Blender 构建通过 `catalog.NATIVE_ROAD_LAYERS` 消费它们
 正确：道路方向箭头进入 `direction_arrows.geojson`；只有 OSM 明确标注的动作进入
 `turn_arrows.geojson`。工作台用两个开关呈现，Blender 复用同一现有箭头材质。
 
+## Native 普通路口圆角
+
+### 1. 范围与触发条件
+
+`compile-native-roads.js` 为普通 T / 十字路口生成 `intersection_surface.geojson`
+和 `sidewalk_surface.geojson` 的路口边界。路口道路面必须在同一 cutback 处结束，不能
+用未裁剪的道路矩形覆盖圆角边界。
+
+### 2. 几何契约
+
+- 相邻道路边缘使用两条支持切线的交点作为二次曲线控制点；采样段数由
+  `JUNCTION_CURVE_SEGMENTS` 统一控制。
+- 机动车路口边界、人行道内侧路缘和人行道外侧边界都必须使用同一切线圆角规则；外侧
+  不能只对内侧采样点做线性偏移，避免内外曲率不一致。
+- `boundary_mode` 使用 `rounded-approach-envelope`，无法安全构造的角保持确定性直线
+  回退，并写入 `junction-rounded-corner-fallback` warning。
+- 已发布的 connector 必须包含在最终边界内，边界退化或 connector 越界时才允许使用
+  `connector-convex-fallback`。
+
+### 3. 校验与错误矩阵
+
+| 条件 | 结果 |
+|---|---|
+| 支持切线交点有限且曲线不过远 | 生成采样圆角 |
+| 切线近似平行或交点退化 | 保留该角直线并记录 `junction-rounded-corner-fallback` |
+| 边界自相交或 connector 越界 | 使用 connector 凸包兜底；仍自相交则不发布路口面 |
+
+### 4. 必需测试
+
+- `npm run test:native-road`：普通 T / 十字路口的圆角顶点数、内收方向、内外人行道
+  曲线和 continuation 语义。
+- `npm run test:road-workbench`：工作台仍能加载 native 路口及人行道图层。
+- `npm run road:compile -- --config config/areas/nantaizi-lake-innovation-valley.json`。
+- `npm run road:check -- --config config/areas/nantaizi-lake-innovation-valley.json`。
+
+### 5. 错误与正确写法
+
+错误：先对路缘生成圆角，再把外侧边界按每个采样点线性平移；这会导致内外曲率不同，
+在人行道角落留下不一致的折面。
+
+正确：对内侧和外侧分别用相同的道路边缘支持切线规则生成曲线，仅在外侧切线退化时
+使用确定性的偏移回退。
+
+## Native 道路中心虚线
+
+### 1. 范围与触发条件
+
+`node scripts/compile-native-roads.js --config <area>` 为可确认的双向非 service
+道路段写入 `native-road/layers/center_lines.geojson`。这是原生几何：只能依据
+canonical OSM 中心线、native 双方向道路模型和 native 路口 cutback 生成，osm2streets
+的 `center_lines.geojson` 只可作为视觉基准，绝不能作为输入。
+
+### 2. 调用形式
+
+```bash
+npm run road:compile -- --config config/areas/nantaizi-lake-innovation-valley.json
+npm run road:workbench -- --config config/areas/nantaizi-lake-innovation-valley.json
+npm run build:area -- --config config/areas/nantaizi-lake-innovation-valley.json --stages blender,cesium,preview --road-provider native
+```
+
+工作台 `GET /api/state` 通过 `layers.centerLines` 返回该 FeatureCollection；native
+Blender adapter 必须将 source `center_lines` 映射到既有 `center_lines` material layer。
+
+### 3. 契约
+
+- 每一 dash 均为 Polygon，长 `2m`、宽 `0.25m`、确定性间隔 `2m`，使用
+  `native-road-center-line/v1` provenance。
+- 要素必须含有 `native_id`、`segment_id`、`road_id`、`directional_road_ids`、
+  `osm_way_ids`、`dash_index`、`dash_length_m`、`dash_gap_m` 与 `placement_rule`，以便
+  Workbench 用中文显示“道路中心虚线”并可回溯来源。
+- 只有同一 `segment_id` 恰有一条 forward 和一条 backward native road 时才生成；单向、
+  `highway=service` 或退化中心线都不能伪造中心线。退化中心线须写
+  `invalid-center-line` diagnostic。
+- 线段必须先经过 native junction cutback；再与 crosswalk、vehicle stop line 的控制面
+  求冲突，冲突 dash 直接略去。控制标线优先于中心虚线。
+- `compiled.json.layers.centerLines`、`comparison.json.nativeCenterLineFeatures`、
+  `build-area.js` 的 native input records 与 required-layer 验证必须全部使用
+  `layers/center_lines.geojson`；缺失时在 Blender 启动前失败，不得静默漏画。
+
+### 4. 校验与错误矩阵
+
+| 条件 | 结果 |
+|---|---|
+| 可确认的双向普通道路段 | 生成 2m / 0.25m 黄虚线，固定 2m gap |
+| 单向或 `highway=service` 道路 | 不生成中心虚线 |
+| 中心线不足两点、长度不可用 | `invalid-center-line` diagnostic，不写畸形 Polygon |
+| dash 进入 junction cutback | trim 后不生成该范围 dash |
+| dash 与斑马线或停止线相交 | 不生成冲突 dash |
+| native Blender 输入缺 `center_lines.geojson` | `ensureNativeRoadLayers()` 抛错 |
+
+### 5. 正常、基础与错误示例
+
+- 正常：一条有 forward/backward carriageway 的 residential 段在两个方向道路之间生成黄虚线。
+- 基础：没有双向证据的道路仍可有车道分隔线，但不产生道路中心虚线。
+- 错误：从 osm2streets 图层复制或裁剪中心线；这会将渲染器缺陷重新变成 native 数据依赖。
+
+### 6. 必需测试
+
+- `npm run test:native-road`：断言双向生成、provenance、2m 尺寸/间隔、单向和 service 跳过。
+- `npm run test:road-workbench`：断言 `centerLines` API、中文开关、选择溯源和概览计数。
+- `npm run road:compile -- --config config/areas/nantaizi-lake-innovation-valley.json`：输出合法图层，检查中心线与控制标线不重叠。
+- `npm run build:area -- --config config/areas/nantaizi-lake-innovation-valley.json --stages blender,cesium,preview --road-provider native`：日志列出 `center_lines`，且不运行 `package`。
+
+### 7. 错误与正确写法
+
+错误：只按一条 directional road 生成中心线，或忽略控制标线。
+
+```js
+const line = road.centerline;
+features.push(makeDash(line));
+```
+
+正确：先确认成对的双方向道路、做路口裁剪，再排除控制标线冲突。
+
+```js
+if (roads.length !== 2 || !forward || !backward || forward.highway === "service") continue;
+const line = trimLineAtJunctions(forward.centerline, forward.sourceNodeIds, junctionPlans);
+if (!ringsOverlapControl([ring], [...controls.crosswalks, ...controls.stopLines])) features.push(dash);
+```
+
+## Native 道路中心线样式覆写
+
+### 1. 范围与触发条件
+
+Road Workbench 选中 `native-road-center-line/v1` 要素后，可为其 `segment_id`
+保存样式覆写。覆写属于 `native-road-overrides.json`，不是对
+`center_lines.geojson` 的手工编辑；重新编译必须从覆写重建图层。
+
+### 2. 调用形式
+
+```json
+{
+  "id": "道路中心线:segment:way/123/1",
+  "kind": "center-line-style",
+  "segmentId": "segment:way/123/1",
+  "color": "white",
+  "pattern": "solid"
+}
+```
+
+### 3. 契约
+
+- `color` 只能是 `yellow` 或 `white`；`pattern` 只能是 `dashed` 或 `solid`。
+  目标 `segmentId` 必须属于当前 native road model。
+- `double: true` 只表示双黄实线，因此只能与 `color: "yellow"`、
+  `pattern: "solid"` 组合。编译器为每段的每个有效实线 mark 写两条相距 0.32m 的
+  平行 Polygon，并记录 `double: true`、`effective_style:
+  "double-yellow-solid"`；不得把它实现为可任意组合的双线开关。
+- 未覆写段保持黄色虚线（2m dash、2m gap）；`solid` 为 0 gap，但相邻的 2m
+  几何块须重叠 `0.04m`，避免投影精度造成可见裂缝。
+- 每个生成面记录 `color`、`pattern` 和 `effective_style`。Workbench 以这些属性
+  着色；native Blender 将 white centre lines 分派至 `Native Center Line White`，
+  yellow 则继续复用 `Center Line`。
+- 下拉框变化即暂存覆写，顶部“保存并重新生成”是唯一写盘/重编译动作；不要求用户
+  再点击一个容易遗漏的暂存按钮。
+
+### 4. 校验与错误矩阵
+
+| 条件 | 结果 |
+|---|---|
+| 合法颜色、图案和当前 segment | 保存后重新生成有效样式 |
+| 非法颜色/图案或不存在 segment | `validateOverrides()` 拒绝整个请求 |
+| 实线块触及控制标线 | 该块略去，不以连续性为由穿过控制标线 |
+| 白色中心线进入 native Blender | 使用白线材质，不改变 legacy 图层材质 |
+
+### 5. 正常、基础与错误示例
+
+- 正常：点选任意 dash，选择“白色实线”，保存重编译后整段显示连续白线。
+- 基础：选择“黄色虚线（默认）”仍是显式覆写，但几何与默认规则一致。
+- 错误：只在 Workbench 改填充色；Blender/Cesium 会继续显示旧黄色。
+
+### 6. 必需测试
+
+- `npm run test:native-road`：合法/非法样式覆写、solid 属性、控制标线避让。
+- `npm run test:road-workbench`：中文样式面板、下拉框自动暂存和 API payload。
+- `python3 -m unittest discover blender/tests`：catalog 仍是可导入的纯 Python。
+- Nantaizi native `blender,cesium,preview` 构建：既有 yellow centre lines 不回归。
+
+### 7. 错误与正确写法
+
+错误：实线块仅以零间隔精确相接，且每块使用高对比 outline。
+
+正确：小幅重叠相邻块，并让 Workbench 实线 stroke 与 fill 同色。
+
+## Native 道路外缘线样式覆写
+
+`edge_lines.geojson` 是车行道最外侧边界标线，使用 `native-road-edge-line/v1`
+provenance。单向道路生成左右两条外缘线；双向道路每个方向只生成远离道路中心的外缘
+线，双向道路中间分界由 `center_lines.geojson` 负责。默认是白色实线，必须带
+`road_id`、`side`（`left` / `right`）、`osm_way_ids`、`color`、`pattern` 与
+`effective_style`。
+
+区域配置中的 `nativeRoad.edgeLines` 默认是 `false`；因此 native Blender/Cesium 默认不
+生成或显示该层。只有明确设置为 `true` 才会发布 `edge_lines.geojson` 并交给下游消费。
+
+Road Workbench 点选外缘线后以中文显示其方向侧边，可暂存以下 area-local 覆写：
+
+```json
+{
+  "id": "道路外缘线:road:way/123:forward:left",
+  "kind": "edge-line-style",
+  "roadId": "road:way/123:forward",
+  "side": "left",
+  "color": "white",
+  "pattern": "solid"
+}
+```
+
+`roadId` 必须是当前 directional native road 的精确 ID，`side` 必须为 `left` 或 `right`。
+实线使用连续 offset line；虚线使用确定性
+2m mark / 2m gap。工作台的暂存与“保存并重新生成”是唯一的写盘路径，不能只改浏览器填充色；
+native Blender 将该层映射到既有 `lane_separators` material layer。
+
+## Native 控制标线
+
+### 1. 范围与触发条件
+
+`node scripts/compile-native-roads.js --config <area>` 为 native road provider
+生成 `crosswalks.geojson` 和 `vehicle_stop_lines.geojson`。这是原生道路的独立
+产物，禁止读取 osm2streets 的渲染图层作为几何输入。
+
+### 2. 调用形式
+
+```bash
+npm run road:compile -- --config config/areas/nantaizi-lake-innovation-valley.json
+npm run road:workbench -- --config config/areas/nantaizi-lake-innovation-valley.json
+```
+
+工作台 `GET /api/state` 通过 `layers.crosswalks` 和
+`layers.vehicleStopLines` 返回两个 FeatureCollection。
+
+### 3. 契约
+
+- 只有 `highway=crossing` 且 `crossing:markings` 不是 `no`、`none` 或
+  `unmarked` 的 OSM 节点可以生成斑马线。每个安全匹配点生成六条 stripe，带
+  `crossing_node_id`、`road_id`、`lane_id`、`osm_way_ids`、`direction`、
+  `placement_method`、`junction_inset_m` 和 `native-road-crosswalk/v1` provenance。
+- 停止线还必须对应一个启用的 native arrival endpoint，且过街节点位于该进口到
+  路口的安全距离内；其 provenance 是 `native-road-stop-line/v1`。不能确认进口
+  时保留斑马线并写 `crossing-no-safe-stop-line` diagnostic，不得猜测一条线。停止线
+  必须复用斑马线的 `junction_inset_m`，保持与斑马线的上游间距。
+- 有安全进口且存在普通路口 plan 时，斑马线中心推进到 cutback 内约 1.5 米；单次
+  最大推进 4 米。`junction_inset_m` 记录实际推进量，避免远离路口的 crossing 被过度
+  移动。
+- `catalog.NATIVE_ROAD_LAYERS` 将两个源层映射到现有的 `crosswalks` 和
+  `vehicle_stop_lines` 材质层。不得把它们加入 legacy `SCENE_LAYERS`。
+- 控制标线优先于箭头：默认直行箭头与其相交时跳过；路口转向箭头依次尝试在距路口
+  6、10、14、18、22 米处放置，均冲突时记录 `turn-arrow-control-conflict`。
+
+### 4. 校验与错误矩阵
+
+| 条件 | 结果 |
+|---|---|
+| 标记过街没有可匹配 native lane | `crossing-no-native-lane`，不生成任何控制标线 |
+| 有横道但没有安全进口方向 | 生成斑马线，记录 `crossing-no-safe-stop-line`，不生成停止线 |
+| 箭头与任一控制标线相交 | 直行箭头跳过；转向箭头后移或记录冲突 diagnostic |
+| native Blender 输入缺任一控制图层 | `ensureNativeRoadLayers()` 在启动 Blender 前失败 |
+
+### 5. 正常、基础与错误示例
+
+- 正常：一个靠近路口的 marked crossing 生成 6 条斑马线和 1 条进口停止线。
+- 基础：一条孤立的 marked crossing 可以生成斑马线，但不能凭邻近道路方向臆造停止线。
+- 错误：先生成箭头再叠加停止线，导致两者重叠；控制标线是道路控制语义，必须优先。
+
+### 6. 必需测试
+
+- `npm run test:native-road`：断言 marked / unmarked / 无 native lane 的输出，停止线的
+  provenance、斑马线与停止线共享 `junction_inset_m`，以及箭头遇控制标线时后移。
+- `npm run test:road-workbench`：断言 controls 开关、两条 API layer 和中文选中溯源。
+- `npm run road:compile -- --config config/areas/nantaizi-lake-innovation-valley.json`：核查两层
+  feature count 及每条停止线都是 native arrival direction。
+- `npm run build:area -- --config config/areas/nantaizi-lake-innovation-valley.json --stages blender,cesium,preview --road-provider native`：不运行 `package`。
+
+### 7. 错误与正确写法
+
+错误：以最近任意方向车道和固定正向偏移生成停止线。
+
+```js
+const stopCenter = offsetByMeters(nearestLane.point, nearestLane.axis, 2.7);
+```
+
+正确：先确认该方向的终点是一个已启用的路口 arrival，再在人行横道的上游生成停止线。
+
+```js
+const approach = candidates.find((item) => arrivalEndpointIds.has(`endpoint:${item.road.id}:end`));
+const stopCenter = offsetByMeters(laneCenterAtCrossing, approach.placement.axis, -2.7);
+```
+
 ## 斑马线与停止线来源
 
 ### 1. 范围与触发条件

.trellis/tasks/08-13-native-road-compiler/task.json

@@ -19,7 +19,11 @@
   "pr_url": null,
   "subtasks": [],
   "children": [
-    "08-14-native-road-lane-markings"
+    "08-14-native-road-lane-markings",
+    "08-17-native-road-control-markings",
+    "08-17-native-road-center-lines",
+    "08-17-native-rounded-junctions",
+    "08-18-native-traffic-signal-parity"
   ],
   "parent": null,
   "relatedFiles": [],

.trellis/tasks/08-18-native-traffic-signal-parity/check.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/08-18-native-traffic-signal-parity/design.md

@@ -0,0 +1,55 @@
+# Design
+
+## Source Of Truth And Migration
+
+The native compiler owns a versioned area-local signal model and override
+artifact. It is generated from OSM controls and native geometry inputs, then
+edited by the Workbench without QGIS. The existing
+`traffic_signal_assemblies.geojson` is a migration adapter: it can be imported
+into the native model and exported for legacy QGIS/reimport workflows, but a
+native compile never requires it to exist.
+
+The existing `buildTrafficSignalFeatures()` and validation functions remain the
+compatibility implementation for initial generation and import/export. Imported
+features retain their legacy `signal_uid` where valid; newly generated native
+features use the same deterministic identity rule so downstream runtime IDs do
+not fork.
+
+## Workbench API And Editing
+
+`GET /api/state` adds the normalized native signal model, source control
+metadata, migration provenance, and derived runtime signal records. A signal
+edit is represented as an atomic replacement of the validated native signal
+override artifact through a dedicated signal save endpoint. A separate import
+or export action handles the legacy QGIS collection; road overrides remain in
+their existing file and schema.
+
+The browser uses stable `signal_uid` values. It supports:
+
+- generate: choose an OSM traffic-signal control and arm, then create the
+  deterministic assembly using the existing generator contract;
+- move: update the Point coordinates while retaining stop-line/source fields;
+- rotate: update `heading_deg` with normalized degrees;
+- delete: remove the assembly from the editable collection;
+- edit enabled state, display ID, mast reach, z offset, and phase group.
+
+Every save validates uniqueness, identity, finite geometry, source references,
+and field ranges before an atomic write. Deleted features are absent from the
+runtime output; disabled features remain in the editable/QGIS layer but are
+omitted by `buildTrafficSignalsFromFeatures()`.
+
+## Delivery Flow
+
+The native road compile result includes signal assemblies and derived runtime
+metadata without adding them to road geometry layers. Native Blender/Cesium
+stages consume `traffic_signals.json` and dynamic GLB inputs generated directly
+from the native model. The legacy QGIS adapter may materialize the old GeoJSON,
+but it is not in the native build's critical path.
+
+## Compatibility And Rollback
+
+QGIS reimport continues to read/export the compatibility GeoJSON while the
+legacy path remains unchanged. If native signal editing fails validation, the
+previous atomic native override remains in place and the user receives a
+field-level error. Rollback is selecting the legacy provider or exporting the
+last native state to the QGIS adapter.

.trellis/tasks/08-18-native-traffic-signal-parity/implement.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/08-18-native-traffic-signal-parity/implement.md

@@ -0,0 +1,31 @@
+# Implementation Plan
+
+1. Define the native signal model/override artifact and migration adapter;
+   reuse existing generation, validation, and deterministic signal UID rules.
+2. Add QGIS import/export commands that translate
+   `traffic_signal_assemblies.geojson` to/from the native artifact without
+   making native compile depend on QGIS.
+3. Extend native compile/workbench state to expose signal assemblies, OSM
+   controls/arms, and derived runtime provenance.
+4. Add validated atomic signal save operations for generate, move, rotate,
+   delete, and field edits; preserve legacy ID compatibility.
+5. Add Workbench map styling, selection, editing controls, dirty state, save,
+   compile/reload, and clear error handling for signal assemblies.
+6. Ensure native Blender/Cesium/preview stages consume runtime signal data
+   generated from the native model, while legacy stages remain compatible.
+7. Add focused traffic-signal, Workbench, migration, and cross-layer round-trip tests;
+   run the existing legacy traffic-signal and preview suites.
+
+## Validation
+
+```bash
+npm run test:traffic-signals
+npm run test:preview-assets
+npm run test:road-workbench
+npm run road:compile -- --config config/areas/nantaizi-lake-innovation-valley.json
+npm run road:check -- --config config/areas/nantaizi-lake-innovation-valley.json
+```
+
+Manual acceptance must cover native-only generate/move/rotate/delete -> save ->
+recompile -> runtime JSON and preview, plus QGIS import/export compatibility;
+disabled signals must be omitted from runtime output.

.trellis/tasks/08-18-native-traffic-signal-parity/prd.md

@@ -0,0 +1,55 @@
+# Native traffic signal parity with QGIS
+
+## Goal
+
+Move traffic-signal ownership from the QGIS editing chain into the native road
+compiler and Workbench. Existing QGIS signal assemblies remain import/export
+compatibility data during migration, but native overrides become the long-term
+source for generation, editing, and Blender/Cesium/preview delivery.
+
+## Confirmed Facts
+
+- QGIS currently edits `traffic_signal_assemblies.geojson`; this is the
+  migration input/output contract, not the desired long-term authority.
+- `scripts/reimport-gpkg.js` validates and reimports that legacy layer.
+- `scripts/build-area.js` currently derives runtime `traffic_signals.json` from
+  the edited assemblies; the native path must replace this dependency.
+- Existing native road layers do not read traffic-signal artifacts. Historical
+  native Cesium work intentionally omitted signal runtime assets.
+- Stable signal identity and editable fields already include `signal_uid`,
+  enabled state, source/control/approach IDs, arm direction, pose, mast reach,
+  and phase-group/runtime data.
+
+## Requirements
+
+- R1: Native compile/workbench must own a versioned area-local signal model and
+  override artifact, with an explicit one-time/import compatibility path from
+  existing QGIS assemblies.
+- R2: Workbench state must expose signal provenance and the existing editable
+  signal fields using stable IDs, and support generating, moving, rotating,
+  and deleting signal assemblies.
+- R3: Native compile and preview delivery must generate runtime signal data
+  directly from the native model, preserving enabled/disabled state, arm
+  direction/pose, and phase-group data without requiring QGIS.
+- R4: A compatibility adapter must import/export the existing QGIS assembly
+  format during migration and preserve legacy signal IDs where possible.
+
+## Scope Boundary
+
+- Native signal model and overrides are the long-term source of truth.
+- QGIS GeoJSON/GeoPackage support is transitional compatibility only; do not
+  make native compile depend on QGIS or regenerate native edits from QGIS.
+- Do not redesign signal geometry, timing logic, or vehicle behavior in this
+  task.
+
+## Acceptance Criteria
+
+- [ ] A native compile/reopen round trip preserves edited signal assemblies,
+  stable IDs, enabled state, and provenance without QGIS running.
+- [ ] The Road Workbench can generate, inspect, move, rotate, and delete signal
+  assemblies, then save durable edits without breaking QGIS reimport.
+- [ ] Native Blender/Cesium/preview consume runtime signal data generated from
+  the native model, including disabled signals being omitted from runtime.
+- [ ] QGIS import/export compatibility and legacy build stages continue to
+  pass while the migration adapter exists.
+- [ ] Nantaizi has documented native-only and QGIS-imported round trips.

.trellis/tasks/08-18-native-traffic-signal-parity/task.json

@@ -0,0 +1,26 @@
+{
+  "id": "native-traffic-signal-parity",
+  "name": "native-traffic-signal-parity",
+  "title": "Align native traffic signals with QGIS",
+  "description": "",
+  "status": "in_progress",
+  "dev_type": null,
+  "scope": null,
+  "package": null,
+  "priority": "P2",
+  "creator": "dingkang",
+  "assignee": "dingkang",
+  "createdAt": "2026-08-18",
+  "completedAt": null,
+  "branch": null,
+  "base_branch": "feature/native-road-compiler",
+  "worktree_path": null,
+  "commit": null,
+  "pr_url": null,
+  "subtasks": [],
+  "children": [],
+  "parent": "08-13-native-road-compiler",
+  "relatedFiles": [],
+  "notes": "",
+  "meta": {}
+}

.trellis/tasks/archive/2026-08/08-17-native-lane-separator-styles/check.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/archive/2026-08/08-17-native-lane-separator-styles/design.md

@@ -0,0 +1,35 @@
+# Native Lane Separator Style Overrides Design
+
+## Contract
+
+The override is identified by the stable `roadId` plus the adjacent lane pair:
+
+```json
+{
+  "id": "车道分隔线:road:way/123:forward:1-2",
+  "kind": "lane-separator-style",
+  "roadId": "road:way/123:forward",
+  "leftLaneIndex": 1,
+  "rightLaneIndex": 2,
+  "color": "white",
+  "pattern": "dashed"
+}
+```
+
+The same `yellow|white` and `dashed|solid` enums are reused. A default is
+white dashed. The generated Polygon stores `color`, `pattern` and
+`effective_style`; source IDs remain unchanged.
+
+## Rendering
+
+The existing lane separator polygon represents the whole lane-pair path.
+`solid` retains it as one continuous feature. `dashed` samples regular dash
+polygons along the shared centreline with deterministic spacing and preserves
+junction cutback. White uses the existing `lane_separators` material; yellow
+uses a native-only yellow material route. Workbench separates lane separators
+from turn arrows so their styles remain selectable and visible.
+
+## Compatibility
+
+No override means current visual default. Road edges, curbs and centre lines
+are untouched. Existing `native-road-overrides/v1` files remain valid.

.trellis/tasks/archive/2026-08/08-17-native-lane-separator-styles/implement.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/archive/2026-08/08-17-native-lane-separator-styles/implement.md

@@ -0,0 +1,7 @@
+# Implementation Plan
+
+1. Validate and resolve per-lane-pair style overrides.
+2. Generate default/dashed/solid style geometry and effective properties.
+3. Add the native Blender yellow lane-separator material route.
+4. Add Workbench selection, Chinese editor and automatic staging.
+5. Test compiler, Workbench, Blender catalog and Nantaizi native build.

.trellis/tasks/archive/2026-08/08-17-native-lane-separator-styles/prd.md

@@ -0,0 +1,47 @@
+# Native lane separator style overrides
+
+## Goal
+
+Make native same-direction lane separators selectable and persistently editable
+in Road Workbench, using the style override pattern proven for centre lines.
+
+## Confirmed Facts
+
+- `compileLaneMarkings()` writes one continuous `0.12m` Polygon separator
+  between each adjacent lane pair, identified by `road_id`, `left_lane_index`
+  and `right_lane_index`.
+- Lane separators currently have fixed light marking material and are displayed
+  together with turn arrows in Workbench.
+- `native-road-overrides.json` already supports validated, persistent centre
+  line styles by logical native segment. The new type must not alter road-edge,
+  curb or sidewalk geometry.
+
+## Initial Requirements
+
+- Selecting a lane separator must show its lane-pair source and a Chinese
+  style editor.
+- The first style catalog should mirror centre lines: white/yellow and
+  dashed/solid.
+- The effective style must be generated into GeoJSON, visible in Workbench,
+  and consumed by native Blender/Cesium.
+- Default output must remain the current white dashed-style separator.
+
+## Out Of Scope
+
+- Road-edge lines, curbs, sidewalks, double lines, partial ranges, lane-specific
+  legal restrictions and osm2streets layers.
+
+## Key Decision
+
+Each override applies only to the selected adjacent lane pair. This preserves
+separate marking semantics on roads with three or more lanes.
+
+## Acceptance Criteria
+
+- [ ] Selecting a separator exposes a Chinese style editor for its adjacent
+  lane pair; choosing a style stages it automatically.
+- [ ] Save and regeneration preserve the per-pair style across reloads while
+  unedited separators retain the default.
+- [ ] GeoJSON, Workbench, Blender and Cesium show the same effective style.
+- [ ] Tests cover validation, defaults, per-pair isolation, automatic staging
+  and native scene consumption.

.trellis/tasks/archive/2026-08/08-17-native-lane-separator-styles/task.json

@@ -0,0 +1,26 @@
+{
+  "id": "native-lane-separator-styles",
+  "name": "native-lane-separator-styles",
+  "title": "Native lane separator style overrides",
+  "description": "",
+  "status": "completed",
+  "dev_type": null,
+  "scope": null,
+  "package": null,
+  "priority": "P2",
+  "creator": "dingkang",
+  "assignee": "dingkang",
+  "createdAt": "2026-08-17",
+  "completedAt": "2026-08-17",
+  "branch": null,
+  "base_branch": "feature/native-road-compiler",
+  "worktree_path": null,
+  "commit": null,
+  "pr_url": null,
+  "subtasks": [],
+  "children": [],
+  "parent": null,
+  "relatedFiles": [],
+  "notes": "",
+  "meta": {}
+}

.trellis/tasks/archive/2026-08/08-17-native-road-center-line-styles/check.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/archive/2026-08/08-17-native-road-center-line-styles/design.md

@@ -0,0 +1,64 @@
+# Native Road Centre-Line Style Overrides Design
+
+## Architecture
+
+```text
+Workbench selects a generated centre-line dash
+  -> segment_id identifies the logical road segment
+  -> staged center-line-style override
+  -> native-road-overrides.json
+  -> compileCenterLines resolves default or effective style
+  -> center_lines.geojson polygons with style fields
+  -> Workbench / Blender / Cesium
+```
+
+The authoritative edit is a new override kind, not a mutation of
+`center_lines.geojson`. It has a deterministic ID based on `segmentId`, so a
+later recompilation replaces the segment's style rather than accumulating
+records.
+
+## Override Contract
+
+```json
+{
+  "id": "道路中心线:segment:way/123/1",
+  "kind": "center-line-style",
+  "segmentId": "segment:way/123/1",
+  "color": "yellow",
+  "pattern": "dashed"
+}
+```
+
+`validateOverrides()` accepts only known model segment IDs and the finite
+string enums `yellow|white` and `dashed|solid`. A style override applies once
+to the paired forward/backward native roads for that segment. The existing
+schema version remains `native-road-overrides/v1` because this is an additive
+kind and old files remain valid.
+
+## Geometry and Material
+
+- Default remains yellow dashed: 2m dash, 2m gap, 0.25m width.
+- `solid` generates deterministic adjacent 2m pieces with no gap. Pieces still
+  undergo the same junction cutback and control-marking exclusion as dashed
+  lines; this avoids creating a solid polygon across an excluded crossing.
+- Style fields `color`, `pattern`, `dash_length_m`, `dash_gap_m`, and
+  `effective_style` are stored on every generated polygon.
+- Blender currently maps all `center_lines` to one yellow material, so the
+  native adapter must support a white centre-line material route without
+  changing legacy osm2streets layers. The route must preserve the existing
+  yellow material for default and yellow overrides.
+
+## Workbench UX
+
+Selecting a centre-line dash shows a compact Chinese style panel in the
+existing form area. A select control presents the four named choices. Choosing
+one stages an override; the existing 保存 / 保存并重新生成 actions remain the
+only persistence and generation actions. The panel also shows whether the
+style is default or overridden and identifies the native road segment.
+
+## Compatibility and Rollback
+
+Unedited segments generate byte-compatible geometry style defaults apart from
+the added style properties. Oneway/service filtering and control priority are
+unchanged. Selecting `--road-provider osm2streets` remains a full rollback.
+

.trellis/tasks/archive/2026-08/08-17-native-road-center-line-styles/implement.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/archive/2026-08/08-17-native-road-center-line-styles/implement.md

@@ -0,0 +1,31 @@
+# Implementation Plan
+
+1. Add validated `center-line-style` overrides and a helper which resolves the
+   effective default/override style by segment ID.
+2. Generate yellow/white and dashed/solid centre-line geometry while retaining
+   cutback and control-marking exclusion behaviour; publish effective style
+   properties.
+3. Extend the native Blender layer adapter/material handling to distinguish
+   white from yellow centre-line features without affecting legacy layers.
+4. Add Workbench style controls, staging, Chinese selection evidence, and
+   immediate regenerated-layer display.
+5. Add focused compiler, override, Workbench, Blender catalog, and build-stage
+   tests; compile/check Nantaizi and build Blender/Cesium/preview without the
+   package stage.
+
+## Validation
+
+```bash
+npm run test:native-road
+npm run test:road-workbench
+python3 -m unittest discover blender/tests
+npm run test:build-stages
+npm run road:compile -- --config config/areas/nantaizi-lake-innovation-valley.json
+npm run road:check -- --config config/areas/nantaizi-lake-innovation-valley.json
+npm run build:area -- --config config/areas/nantaizi-lake-innovation-valley.json --stages blender,cesium,preview --road-provider native
+```
+
+## Rollback
+
+Remove the override records or choose `--road-provider osm2streets`; no legacy
+output is modified.

.trellis/tasks/archive/2026-08/08-17-native-road-center-line-styles/prd.md

@@ -0,0 +1,62 @@
+# Native road center line style overrides
+
+## Goal
+
+Allow a Road Workbench user to select a generated native road centre line and
+persistently override its marking style, without turning the generated GeoJSON
+into the source of truth.
+
+## Confirmed Facts
+
+- Native `center_lines.geojson` currently contains automatic yellow dashed
+  polygons (`2m` dash, `2m` gap, `0.25m` width), each tied to a `segment_id`.
+- A displayed dash can already be selected and exposes its segment provenance,
+  but has no editing controls.
+- `native-road-overrides.json` is the persistent authority for existing road
+  and connection edits. The Workbench already stages, validates, saves, then
+  recompiles those overrides.
+- The generated layer is consumed by both Workbench and native Blender/Cesium;
+  styling must therefore be compiled geometry and use the existing
+  `center_lines` material path, not a Workbench-only display tint.
+
+## Requirements
+
+- R1: Selecting a centre-line dash must expose a Chinese style editor for its
+  logical target and show the current effective style.
+- R2: Supported styles must include at least solid/dashed and white/yellow
+  marking colours.
+- R3: Style choices must be stored in `native-road-overrides.json`, validated,
+  reapplied during compilation, and survive a future Workbench launch.
+- R4: The regenerated GeoJSON must carry source traceability and effective
+  style fields so Workbench, Blender and Cesium show the same marking.
+- R5: Default automatic centre lines remain unchanged for segments without an
+  override; one-way/service exclusions and control-marking avoidance remain
+  authoritative.
+
+## Initial Scope Boundary
+
+- Editing individual dash polygons is out of scope: they are derived pieces,
+  not user-owned objects.
+- Per-segment control is recommended for the first version because current
+  native segments already stop at junctions and have stable IDs.
+- Double-line semantics, legal `overtaking` inference, hand-drawn partial
+  ranges, and changes to osm2streets output are out of scope unless explicitly
+  accepted during planning.
+
+## Acceptance Criteria
+
+- [ ] A user can select a centre line, choose a supported style in Chinese,
+  save it, regenerate, and see the result immediately in the Workbench.
+- [ ] After reload and recompilation, the selected segment retains its style
+  while unedited segments retain the automatic yellow dashed default.
+- [ ] Native Blender/Cesium uses the same effective style and does not require
+  osm2streets geometry.
+- [ ] Tests cover schema validation, style geometry, default fallback,
+  persistence/API wiring, and Workbench selection/edit controls.
+
+## Key Decisions
+
+- The first version applies one override to the complete native segment between
+  junctions. Individual dash and partial-range editing are deferred.
+- The initial style catalog is four explicit choices: yellow dashed, white
+  dashed, yellow solid, and white solid. Double-line semantics are deferred.

.trellis/tasks/archive/2026-08/08-17-native-road-center-line-styles/task.json

@@ -0,0 +1,26 @@
+{
+  "id": "native-road-center-line-styles",
+  "name": "native-road-center-line-styles",
+  "title": "Native road center line style overrides",
+  "description": "",
+  "status": "completed",
+  "dev_type": null,
+  "scope": null,
+  "package": null,
+  "priority": "P2",
+  "creator": "dingkang",
+  "assignee": "dingkang",
+  "createdAt": "2026-08-17",
+  "completedAt": "2026-08-17",
+  "branch": null,
+  "base_branch": "feature/native-road-compiler",
+  "worktree_path": null,
+  "commit": null,
+  "pr_url": null,
+  "subtasks": [],
+  "children": [],
+  "parent": null,
+  "relatedFiles": [],
+  "notes": "",
+  "meta": {}
+}

.trellis/tasks/archive/2026-08/08-17-native-road-center-lines/check.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/archive/2026-08/08-17-native-road-center-lines/design.md

@@ -0,0 +1,50 @@
+# Native Road Centre Lines Design
+
+## Architecture
+
+The native compiler adds one independent polygon layer:
+
+```text
+canonical bidirectional segment + trimmed OSM centreline
+  -> repeated 2m x 0.25m dash polygons
+  -> native-road/layers/center_lines.geojson
+  -> Workbench / native Blender adapter / Cesium
+```
+
+It does not read osm2streets `center_lines.geojson`. The legacy layer is a
+visual baseline only.
+
+## Placement
+
+- A candidate must have exactly forward and backward native roads for the same
+  `segmentId`, neither be `highway=service`, and have a valid trimmed OSM
+  centreline.
+- Dashes use the legacy observed dimensions: 2m length, 0.25m width, with a
+  deterministic 2m gap. The first dash starts at a fixed segment-local offset
+  so rebuilds do not drift.
+- The line is trimmed with the same `junctionPlans` cutback used by native lane
+  centreline generation. Any dash intersecting a crosswalk or stop line is
+  omitted, preserving the control-marking priority already established.
+- One-way and service segments have no generated feature. A degenerate source
+  line produces a diagnostic rather than malformed geometry.
+
+## Contracts
+
+`layers/center_lines.geojson` is a Polygon FeatureCollection. Every feature
+has `native_id`, `segment_id`, `directional_road_ids`, `osm_way_ids`,
+`dash_index`, `dash_length_m`, `dash_gap_m`, `placement_rule`, and
+`provenance="native-road-center-line/v1"`.
+
+`compiled.json.layers.centerLines`, comparison count
+`nativeCenterLineFeatures`, and `build-area.js` required native records use the
+same filename. `catalog.NATIVE_ROAD_LAYERS` maps source `center_lines` to the
+existing `center_lines` material layer.
+
+The Workbench loads this source into the marking overlay, exposes a Chinese
+toggle, and identifies it as `道路中心虚线` on selection.
+
+## Compatibility
+
+The change is additive within `native-road/`; `--road-provider osm2streets`
+remains unaffected and is rollback. A native Blender build treats a missing
+layer as an input error rather than silently omitting it.

.trellis/tasks/archive/2026-08/08-17-native-road-center-lines/implement.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/archive/2026-08/08-17-native-road-center-lines/implement.md

@@ -0,0 +1,19 @@
+# Implementation Plan
+
+1. Add centre-dash constants and a pure native compiler routine based on the
+   shared bidirectional segment model and junction-trimmed centreline.
+2. Filter invalid, one-way, service, and control-marking-conflicting dashes;
+   record actionable diagnostics for invalid geometry only.
+3. Write `center_lines.geojson`, compilation/comparison counts, native build
+   records, required-layer checks, and Blender material adapter mapping.
+4. Add Workbench API state, Chinese toggle, summary count, rendering, and
+   source evidence for a selected centre dash.
+5. Add focused native and Workbench tests for generation, skips, control
+   avoidance, provenance, and file/API contracts.
+6. Run native/unit/workbench/build-stage tests, compile/check Nantaizi, then
+   validate `blender,cesium,preview --road-provider native` without `package`.
+
+## Rollback
+
+Choose `--road-provider osm2streets`; no legacy layer or published package is
+modified.

.trellis/tasks/archive/2026-08/08-17-native-road-center-lines/prd.md

@@ -0,0 +1,58 @@
+# Native road center lines
+
+## Goal
+
+Restore the existing osm2streets-style road-centre dashed markings in the
+native-road provider before treating native output as ready for broader quality
+gates or new-area validation.
+
+## Confirmed Facts
+
+- Nantaizi's existing `osm2streets_web_out/center_lines.geojson` has 885
+  `type="center line"` polygons. Its sampled dash geometry is approximately
+  2.00m long by 0.25m wide.
+- The legacy extraction excludes centre lines that overlap crosswalk zones and
+  that fall on service driving polygons (`build-osm2streets-qgis.js:474-480`).
+- Native output currently has only same-direction `lane_separators`; it has no
+  `center_lines.geojson`, so a bidirectional road's directional carriageways
+  lack their visual and semantic divider.
+- Existing Blender already owns a `center_lines` / `Center Line` material
+  layer. Native must adapt to it rather than creating a second scene registry.
+
+## Requirements
+
+- R1: For supported non-service, bidirectional native road segments, emit a
+  `center_lines.geojson` dashed centre divider derived from the canonical OSM
+  centreline and the segment's two directional carriageways.
+- R2: Match the established visual baseline: yellow 0.25m-wide, 2m-long
+  dashes, clipped away from ordinary junction cutbacks and control markings.
+- R3: Preserve source traceability: each dash records its native segment,
+  source OSM way, involved directional roads, placement interval/rule, and a
+  dedicated provenance value.
+- R4: Add the layer to compilation records, Road Workbench display/selection
+  in Chinese, and the existing Blender/Cesium `center_lines` material path.
+- R5: Do not render a centre divider on one-way or `highway=service` segments;
+  report invalid geometry instead of fabricating a divider.
+
+## Acceptance Criteria
+
+- [ ] Native Nantaizi output contains a valid `layers/center_lines.geojson`
+  with source-traceable 2m x 0.25m dashed polygons.
+- [ ] No native centre dash intersects a generated crosswalk or vehicle stop
+  line, and no dash reaches into the supported junction surface cutback.
+- [ ] The Workbench can toggle and select centre lines, presenting their
+  source and rule in Chinese rather than calling them lane separators.
+- [ ] Native `blender,cesium,preview` consumes the layer using the existing
+  `center_lines` material and does not run `package`.
+- [ ] Tests cover two-way generation, one-way/service skips, control-marking
+  avoidance, provenance, output contract, and Workbench wiring.
+
+## Out Of Scope
+
+- Centre-line editing overrides, solid/double-centre-line semantics, arbitrary
+  OSM `overtaking` interpretation, lane colouring changes, and other areas.
+
+## Key Decision
+
+This task deliberately matches the existing stable visual layer first. It does
+not claim to infer a country-wide legal marking taxonomy from sparse OSM tags.

.trellis/tasks/archive/2026-08/08-17-native-road-center-lines/task.json

@@ -0,0 +1,26 @@
+{
+  "id": "native-road-center-lines",
+  "name": "native-road-center-lines",
+  "title": "Native road center lines",
+  "description": "Align native-road output with the existing center_lines layer before broader quality work.",
+  "status": "completed",
+  "dev_type": null,
+  "scope": null,
+  "package": null,
+  "priority": "P2",
+  "creator": "dingkang",
+  "assignee": "dingkang",
+  "createdAt": "2026-08-17",
+  "completedAt": "2026-08-17",
+  "branch": null,
+  "base_branch": "feature/native-road-compiler",
+  "worktree_path": null,
+  "commit": null,
+  "pr_url": null,
+  "subtasks": [],
+  "children": [],
+  "parent": "08-13-native-road-compiler",
+  "relatedFiles": [],
+  "notes": "",
+  "meta": {}
+}

.trellis/tasks/archive/2026-08/08-17-native-road-control-markings/check.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/archive/2026-08/08-17-native-road-control-markings/design.md

@@ -0,0 +1,66 @@
+# Native Road Control Markings Design
+
+## Architecture
+
+The native compiler remains the source of truth. It extends its canonical OSM
+parse with marked crossing nodes, then derives two additive polygon layers from
+the crossing evidence, native directed lanes, and native junction plans:
+
+```text
+OSM crossing node + native directed lane centerlines + junction plans
+    |
+    +-- crosswalks.geojson: six zebra stripe polygons per safe crossing
+    |
+    +-- vehicle_stop_lines.geojson: one safe approach stop-line polygon
+```
+
+No osm2streets GeoJSON is read. Existing crossing geometry helpers may be
+extracted or adapted only when they operate on native lane data and retain
+native provenance.
+
+## Source And Placement
+
+- A source node is eligible only when `highway=crossing` and
+  `crossing:markings` is not `no`, `none`, or `unmarked`.
+- The compiler finds native roads containing the crossing's OSM node and uses
+  the nearest compatible directed lane centerline to obtain the road tangent.
+- Crosswalk stripes are perpendicular to that tangent and constrained to the
+  native road width. Existing fixed zebra dimensions are retained initially:
+  six 0.45m stripes with 0.45m gaps, 0.45m stripe width, and a highway-based
+  stripe length.
+- A stop line is generated only when the crossing can be associated with a
+  supported junction approach and a safe outside-of-junction side. Otherwise
+  the crosswalk may remain valid but the missing stop line is diagnostic.
+- Duplicate nearby crossing nodes use a stable cluster representative so one
+  physical crosswalk does not produce duplicate stripes.
+
+## Contracts
+
+`layers/crosswalks.geojson` and `layers/vehicle_stop_lines.geojson` are Polygon
+FeatureCollections. Each feature records its crossing OSM node, source OSM way,
+native directed road/lane when available, direction, placement method, and
+`native-road-crosswalk/v1` or `native-road-stop-line/v1` provenance.
+
+The Workbench API returns both layers as `state.layers.crosswalks` and
+`state.layers.vehicleStopLines`. Its browser map uses separate toggleable
+layers and selection evidence; the scene-preview toggle leaves real control
+markings visible.
+
+`catalog.NATIVE_ROAD_LAYERS` maps the sources to existing `crosswalks` and
+`vehicle_stop_lines` material layers. This native adapter must not add them to
+the osm2streets `ROAD_LAYERS` / `SCENE_LAYERS` registry.
+
+## Compatibility And Rollback
+
+The new files are additive under `native-road/layers/`. Existing osm2streets
+output and QGIS input are unchanged. Selecting `--road-provider osm2streets`
+remains rollback. A native Blender build treats a missing new layer as an error
+rather than silently omitting a visible marking.
+
+## Risks
+
+- Crossing nodes can be detached from a routable road or lie on an ambiguous
+  multi-road segment. These become diagnostics rather than guessed geometry.
+- A physical crossing split into several OSM nodes must deduplicate stably.
+- A crosswalk near a non-supported junction may get stripes but no valid stop
+  line; this difference must be exposed in workbench provenance.

.trellis/tasks/archive/2026-08/08-17-native-road-control-markings/implement.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/archive/2026-08/08-17-native-road-control-markings/implement.md

@@ -0,0 +1,31 @@
+# Implementation Plan
+
+1. Extend the native OSM parse/model with marked crossing-node evidence while
+   preserving existing road IDs and parser behavior.
+2. Add native crossing clustering, tangent resolution from directed lane
+   centerlines, stripe geometry, safe stop-line placement, and source
+   diagnostics.
+3. Persist the two new layers in `compile-native-roads.js`, comparison counts,
+   native build records, required native layer checks, and existing Blender
+   material mappings.
+4. Add Workbench API/state fields, Chinese layer toggles, selection evidence,
+   and summary counts while retaining scene-preview behavior.
+5. Add focused fixtures for marked and unmarked crossings, duplicate cluster
+   handling, a missing native-lane diagnostic, and output layer contracts.
+6. Run native/unit/workbench/build-stage tests, compile/check Nantaizi, then
+   build `blender,cesium,preview --road-provider native` without `package/`.
+
+## Validation
+
+```bash
+npm run test:native-road
+npm run test:road-workbench
+npm run test:build-stages
+npm run road:compile -- --config config/areas/nantaizi-lake-innovation-valley.json
+npm run road:check -- --config config/areas/nantaizi-lake-innovation-valley.json
+npm run build:area -- --config config/areas/nantaizi-lake-innovation-valley.json \
+  --stages blender,cesium,preview --road-provider native
+```
+
+Rollback is selecting `--road-provider osm2streets`; no legacy output path is
+changed.

.trellis/tasks/archive/2026-08/08-17-native-road-control-markings/prd.md

@@ -0,0 +1,61 @@
+# Native road control markings
+
+## Goal
+
+Give Nantaizi's native-road provider inspectable, source-traceable crosswalk
+and vehicle stop-line geometry, so intersection control markings do not depend
+on the osm2streets render output.
+
+## Confirmed Facts
+
+- Native road output already owns road surfaces, sidewalks, lane separators,
+  repeated direction arrows, and explicit junction-turn arrows.
+- Nantaizi's OSM input contains explicit marked crossings, including zebra and
+  traffic-signal crossings. The existing osm2streets output currently has 48
+  crosswalk-stripe polygons and 8 stop-line polygons.
+- `build-osm2streets-qgis.js:1067` derives these markings from crossing nodes
+  plus osm2streets driving lanes. Native must not read that rendered geometry;
+  it can reuse only the tested geometry rules after adapting them to native
+  directed lanes and junction plans.
+- Existing Blender materials already provide `crosswalks` and
+  `vehicle_stop_lines`; native may map into them without changing the legacy
+  osm2streets layer registry.
+
+## Requirements
+
+- R1: Native compilation uses explicit marked OSM crossing nodes only, and
+  emits crosswalk-stripe polygons plus approach stop lines only where safe
+  native directed-road placement exists.
+- R2: Each generated feature preserves crossing node, OSM road, native road or
+  lane, direction, placement method, and relevant junction provenance.
+- R3: The Road Workbench independently toggles, selects, and describes native
+  crosswalks and stop lines in Chinese.
+- R4: Native Blender and Cesium builds consume both layers with the existing
+  control-marking materials; no `package/` publication is part of validation.
+- R5: Missing compatible road context, ambiguous geometry, and unsupported
+  crossing inputs are diagnostics; the compiler must not invent a crossing.
+
+## Acceptance Criteria
+
+- [ ] Nantaizi native output contains valid `crosswalks.geojson` and
+  `vehicle_stop_lines.geojson` features with source-traceable properties,
+  without reading osm2streets rendered layers.
+- [ ] A Workbench user can toggle and select either marking type and see the
+  crossing node, associated road/direction, and placement evidence.
+- [ ] Native Blender/Cesium output contains both marking types using existing
+  materials, after `blender,cesium,preview --road-provider native` and without
+  publishing `package/`.
+- [ ] Tests cover a marked crossing, an unmarked crossing skip, a missing or
+  ambiguous native-road placement skip, and output-layer contract checks.
+
+## Out Of Scope
+
+- Hand-placed control-marking overrides, traffic-signal state-machine changes,
+  freehand polygon editing, processing another region, and importing
+  osm2streets-rendered crosswalk geometry.
+
+## Key Decision
+
+The first version is explicit-OSM-only. This is feasible for Nantaizi and
+keeps control markings evidence-backed; missing data remains a diagnostic for
+OSM improvement rather than a silent geometric guess.

.trellis/tasks/archive/2026-08/08-17-native-road-control-markings/task.json

@@ -0,0 +1,26 @@
+{
+  "id": "native-road-control-markings",
+  "name": "native-road-control-markings",
+  "title": "Native road control markings",
+  "description": "",
+  "status": "completed",
+  "dev_type": null,
+  "scope": null,
+  "package": null,
+  "priority": "P2",
+  "creator": "dingkang",
+  "assignee": "dingkang",
+  "createdAt": "2026-08-17",
+  "completedAt": "2026-08-17",
+  "branch": null,
+  "base_branch": "feature/native-road-compiler",
+  "worktree_path": null,
+  "commit": null,
+  "pr_url": null,
+  "subtasks": [],
+  "children": [],
+  "parent": "08-13-native-road-compiler",
+  "relatedFiles": [],
+  "notes": "",
+  "meta": {}
+}

.trellis/tasks/archive/2026-08/08-17-native-road-edge-markings/check.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/archive/2026-08/08-17-native-road-edge-markings/implement.jsonl

@@ -0,0 +1 @@
+{"_example": "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. Put spec/research files only — no code paths. Run `python3 .trellis/scripts/get_context.py --mode packages` to list available specs. Delete this line once real entries are added."}

.trellis/tasks/archive/2026-08/08-17-native-road-edge-markings/prd.md

@@ -0,0 +1,19 @@
+# Native road edge markings
+
+## Goal
+
+TBD.
+
+## Requirements
+
+- TBD
+
+## Acceptance Criteria
+
+- [ ] TBD
+
+## Notes
+
+- Keep `prd.md` focused on requirements, constraints, and acceptance criteria.
+- Lightweight tasks can remain PRD-only.
+- For complex tasks, add `design.md` for technical design and `implement.md` for execution planning before `task.py start`.

.trellis/tasks/archive/2026-08/08-17-native-road-edge-markings/task.json

@@ -0,0 +1,26 @@
+{
+  "id": "native-road-edge-markings",
+  "name": "native-road-edge-markings",
+  "title": "Native road edge markings",
+  "description": "",
+  "status": "completed",
+  "dev_type": null,
+  "scope": null,
+  "package": null,
+  "priority": "P2",
+  "creator": "dingkang",
+  "assignee": "dingkang",
+  "createdAt": "2026-08-17",
+  "completedAt": "2026-08-17",
+  "branch": null,
+  "base_branch": "feature/native-road-compiler",
+  "worktree_path": null,
+  "commit": null,
+  "pr_url": null,
+  "subtasks": [],
+  "children": [],
+  "parent": null,
+  "relatedFiles": [],
+  "notes": "",
+  "meta": {}
+}

.trellis/tasks/archive/2026-08/08-17-native-road-marking-semantics/check.jsonl

@@ -0,0 +1,3 @@
+{"file":".trellis/spec/pipeline/cli-and-stages.md","reason":"Check compiler and workbench marking contracts."}
+{"file":".trellis/spec/blender/testing.md","reason":"Run required Blender test suite."}
+{"file":".trellis/spec/guides/cross-layer-thinking-guide.md","reason":"Verify browser, compiler, and Blender consume the same output."}

.trellis/tasks/archive/2026-08/08-17-native-road-marking-semantics/design.md

@@ -0,0 +1,22 @@
+# Design
+
+The compiler owns marking semantics. `center-line-style` remains segment
+scoped because a bidirectional road segment shares one centre-line decision.
+`edge-line-style` is scoped to `{ roadId, side }`, since a directional
+carriageway has independently editable left and right outside edges.
+
+`double: true` is valid only with yellow solid centre lines. Generation emits
+two 0.32m-separated parallel polygons for each normal solid mark, preserving
+junction cutback and crosswalk/stop-line clearance. This keeps the existing
+solid line implementation and avoids a separate geometry pipeline.
+
+Road edge lines use the existing road-edge offset geometry. A solid style is
+one continuous buffered offset line; a dashed style uses deterministic 2m
+marks at 4m spacing. Both carry `effective_style`, source IDs, side, and
+native provenance.
+
+The Workbench uses one marking form with an explicit selected target type.
+Only a centre-line target exposes the double-yellow option; lane separators
+and edge lines retain the ordinary colour/pattern choices. Staged changes pass
+through the existing save and regenerate flow, so browser, compiler and
+Blender read the same persisted override.

.trellis/tasks/archive/2026-08/08-17-native-road-marking-semantics/implement.jsonl

@@ -0,0 +1,3 @@
+{"file":".trellis/spec/pipeline/cli-and-stages.md","reason":"Native-road output, override, and stage contracts."}
+{"file":".trellis/spec/blender/asset-generation.md","reason":"Native provider adapter and Blender output requirements."}
+{"file":".trellis/spec/guides/artifact-parity-guide.md","reason":"Intentional render-output change validation."}

.trellis/tasks/archive/2026-08/08-17-native-road-marking-semantics/implement.md

@@ -0,0 +1,10 @@
+# Implementation
+
+1. Extend override validation and native marking generation for explicit
+   double-yellow centre lines and per-side edge-line styles.
+2. Extend the Chinese Workbench selection/form flow without adding another
+   editor or output format.
+3. Add compiler and Workbench regression coverage for valid and invalid
+   payloads, generated geometry, and layer adapter completeness.
+4. Compile/check Nantaizi, run native/Workbench/build-stage/Blender tests,
+   then run the native Blender/Cesium/preview chain.

.trellis/tasks/archive/2026-08/08-17-native-road-marking-semantics/prd.md

@@ -0,0 +1,36 @@
+# Native road marking semantics
+
+## Goal
+
+Finish the native road marking model so the Nantaizi Road Workbench can
+persist meaningful centre-line and road-edge-line styles, regenerate native
+geometry deterministically, and deliver the same result to Blender/Cesium.
+
+## Requirements
+
+- Add an explicit double-yellow-solid centre-line semantic. It must not be a
+  generic double-line switch that permits invalid colour/pattern combinations.
+- Keep all marking edits area-local in `native-road-overrides.json`; generated
+  GeoJSON remains derived output.
+- Make road edge lines selectable and style-editable in the Chinese Road
+  Workbench, alongside existing centre lines and lane separators.
+- Preserve the default Nantaizi output unless a user supplies an override.
+- Native geometry must remain independent of osm2streets render geometry.
+
+## Acceptance Criteria
+
+- [ ] A `center-line-style` override with `double: true`, `yellow`, and
+  `solid` emits two offset centre-line polygons with an explicit effective
+  style, while invalid double combinations are rejected.
+- [ ] An `edge-line-style` override targets one directional road side and
+  supports white/yellow plus solid/dashed styles.
+- [ ] The Workbench exposes Chinese selection feedback, stages the correct
+  override payload, and only shows the double-yellow choice for centre lines.
+- [ ] Nantaizi native compile/check, Workbench/native tests, Blender pure
+  tests, and native Blender/Cesium/preview build pass.
+
+## Notes
+
+- Keep `prd.md` focused on requirements, constraints, and acceptance criteria.
+- Lightweight tasks can remain PRD-only.
+- For complex tasks, add `design.md` for technical design and `implement.md` for execution planning before `task.py start`.

.trellis/tasks/archive/2026-08/08-17-native-road-marking-semantics/task.json

@@ -0,0 +1,26 @@
+{
+  "id": "native-road-marking-semantics",
+  "name": "native-road-marking-semantics",
+  "title": "Native road marking semantics",
+  "description": "",
+  "status": "completed",
+  "dev_type": null,
+  "scope": null,
+  "package": null,
+  "priority": "P2",
+  "creator": "dingkang",
+  "assignee": "dingkang",
+  "createdAt": "2026-08-17",
+  "completedAt": "2026-08-17",
+  "branch": null,
+  "base_branch": "feature/native-road-compiler",
+  "worktree_path": null,
+  "commit": null,
+  "pr_url": null,
+  "subtasks": [],
+  "children": [],
+  "parent": null,
+  "relatedFiles": [],
+  "notes": "",
+  "meta": {}
+}

.trellis/tasks/archive/2026-08/08-17-native-rounded-junctions/check.jsonl

@@ -0,0 +1,2 @@
+{"file":".trellis/spec/pipeline/cli-and-stages.md","reason":"Native geometry correctness and output contracts."}
+{"file":".trellis/spec/blender/testing.md","reason":"Blender validation requirements."}

.trellis/tasks/archive/2026-08/08-17-native-rounded-junctions/design.md

@@ -0,0 +1,18 @@
+# Design
+
+Each approach contributes its two carriageway-edge points at the common
+cutback distance. Points are ordered around the junction node. For each pair
+from adjacent approaches, the compiler samples a deterministic quadratic
+Bezier whose control point follows the pedestrian-side curb arc toward the
+junction. Rounded plans use a larger cutback than the legacy straight envelope
+so this visible curb shape still contains all turning connectors. Approach road
+surfaces terminate at the same cutback, so they cannot cover the junction
+outline in 3D output.
+
+The curve is accepted only when the support intersection is finite, the pair
+belongs to different approaches, and the resulting ring remains valid and
+contains all published connector coordinates. Otherwise the original straight
+chord remains for that corner and the plan reports a mixed/fallback boundary.
+
+Lane connectors remain a separate vehicle-path layer. This task changes only
+the road/intersection outline and sidewalk-corner shape.

.trellis/tasks/archive/2026-08/08-17-native-rounded-junctions/implement.jsonl

@@ -0,0 +1,2 @@
+{"file":".trellis/spec/pipeline/cli-and-stages.md","reason":"Native geometry and build-stage contracts."}
+{"file":".trellis/spec/guides/artifact-parity-guide.md","reason":"Intentional geometry output change validation."}

.trellis/tasks/archive/2026-08/08-17-native-rounded-junctions/implement.md

@@ -0,0 +1,7 @@
+# Implementation
+
+1. Build a rounded junction boundary from ordered approach-edge records with
+   tangent support-line intersections and deterministic curve samples.
+2. Expose boundary mode/provenance and preserve containment fallback.
+3. Extend focused native-road tests for curved ordinary intersections.
+4. Validate Nantaizi compile/check, workbench tests, and native 3D build.

.trellis/tasks/archive/2026-08/08-17-native-rounded-junctions/prd.md

@@ -0,0 +1,38 @@
+# Rounded native road junctions
+
+## Goal
+
+Replace the octagonal native junction outline with smooth, tangentially joined
+road-edge corners for ordinary Nantaizi T and cross junctions.
+
+## Requirements
+
+- Junction surface boundaries must connect adjacent approach carriageway edges
+  with a smooth outward curve rather than a straight octagonal chord.
+- Sidewalk corner surfaces must use the same rounded boundary concept so road
+  and pedestrian geometry do not disagree visually.
+- Preserve a deterministic straight-edge fallback and an explicit diagnostic
+  when a corner cannot be safely constructed.
+- Do not change lane connector semantics or derive geometry from osm2streets.
+
+## Acceptance Criteria
+
+- [x] Ordinary cross/T fixtures generate rounded junction polygons with more
+  than the prior eight straight boundary vertices and `boundary_mode` records
+  the chosen style.
+- [x] Connector containment remains valid and degenerate geometry falls back
+  without publishing self-intersecting polygons.
+- [x] Nantaizi compile/check and native Blender/Cesium/preview succeed.
+
+## Verification Record
+
+- Native geometry and Workbench tests passed.
+- Nantaizi native compile/check passed with `ok=true`.
+- Native Blender/Cesium/preview verification was completed manually in a
+  working Blender environment.
+
+## Notes
+
+- Keep `prd.md` focused on requirements, constraints, and acceptance criteria.
+- Lightweight tasks can remain PRD-only.
+- For complex tasks, add `design.md` for technical design and `implement.md` for execution planning before `task.py start`.

.trellis/tasks/archive/2026-08/08-17-native-rounded-junctions/task.json

@@ -0,0 +1,26 @@
+{
+  "id": "native-rounded-junctions",
+  "name": "native-rounded-junctions",
+  "title": "Rounded native road junctions",
+  "description": "",
+  "status": "completed",
+  "dev_type": null,
+  "scope": null,
+  "package": null,
+  "priority": "P2",
+  "creator": "dingkang",
+  "assignee": "dingkang",
+  "createdAt": "2026-08-17",
+  "completedAt": "2026-08-18",
+  "branch": null,
+  "base_branch": "feature/native-road-compiler",
+  "worktree_path": null,
+  "commit": null,
+  "pr_url": null,
+  "subtasks": [],
+  "children": [],
+  "parent": "08-13-native-road-compiler",
+  "relatedFiles": [],
+  "notes": "",
+  "meta": {}
+}

.trellis/workspace/dingkang/index.md

@@ -8,8 +8,8 @@
 
 <!-- @@@auto:current-status -->
 - **Active File**: `journal-1.md`
-- **Total Sessions**: 31
-- **Last Active**: 2026-08-14
+- **Total Sessions**: 37
+- **Last Active**: 2026-08-18
 <!-- @@@/auto:current-status -->
 
 ---
@@ -19,7 +19,7 @@
 <!-- @@@auto:active-documents -->
 | File | Lines | Status |
 |------|-------|--------|
-| `journal-1.md` | ~663 | Active |
+| `journal-1.md` | ~803 | Active |
 <!-- @@@/auto:active-documents -->
 
 ---
@@ -29,6 +29,12 @@
 <!-- @@@auto:session-history -->
 | # | Date | Title | Commits | Branch |
 |---|------|-------|---------|--------|
+| 37 | 2026-08-18 | Complete rounded native junction verification | `e41bfd1`, `f7e71cf` | `feature/native-road-compiler` |
+| 36 | 2026-08-17 | Complete native road marking semantics | `9bb97d4` | `feature/native-road-compiler` |
+| 35 | 2026-08-17 | Complete native lane separator styles | `bc04517` | `feature/native-road-compiler` |
+| 34 | 2026-08-17 | Add center line style overrides | `47efb78` | `feature/native-road-compiler` |
+| 33 | 2026-08-17 | Add native road center lines | `fb863da` | `feature/native-road-compiler` |
+| 32 | 2026-08-17 | Native road control markings | `4c4f453` | `feature/native-road-compiler` |
 | 31 | 2026-08-14 | Native road lane markings | `1b9829d` | `feature/native-road-compiler` |
 | 30 | 2026-08-12 | Add vehicle incident preview cards | `761a526` | `main` |
 | 29 | 2026-08-12 | Publish reusable area asset packages | `f385009`, `c925890`, `db0fba5`, `f2b8d79`, `0102ffb` | `main` |

.trellis/workspace/dingkang/journal-1.md

@@ -661,3 +661,143 @@ Implemented native lane separators, repeated road direction arrows, explicit jun
 ### Status
 
 [OK] **Completed**
+
+
+## Session 32: Native road control markings
+
+**Date**: 2026-08-17
+**Task**: Native road control markings
+**Branch**: `feature/native-road-compiler`
+
+### Summary
+
+Added native-source crosswalk and stop-line layers with workbench inspection, Blender/Cesium delivery, and control-marking arrow avoidance.
+
+### Main Changes
+
+- Compiled explicit marked OSM crossings into source-traceable native GeoJSON.
+- Added Chinese workbench control-layer toggle, selection evidence, and summary counts.
+
+### Git Commits
+
+| Hash | Message |
+|------|---------|
+| `4c4f453` | (see git log) |
+
+### Testing
+
+- [OK] Passed native-road, road-workbench, turn-lane-arrows, build-stages, native compile/check, and Blender/Cesium/preview build.
+
+### Status
+
+[OK] **Completed**
+
+### Next Steps
+
+- Continue native road compiler workbench with the next user-approved priority.
+
+
+## Session 33: Add native road center lines
+
+**Date**: 2026-08-17
+**Task**: Add native road center lines
+**Branch**: `feature/native-road-compiler`
+
+### Summary
+
+Implemented Nantaizi native-road center_lines output, workbench selection/toggle, Blender adapter, control-marking avoidance, and cross-layer verification.
+
+### Git Commits
+
+| Hash | Message |
+|------|---------|
+| `fb863da` | (see git log) |
+
+### Status
+
+[OK] **Completed**
+
+
+## Session 34: Add center line style overrides
+
+**Date**: 2026-08-17
+**Task**: Add center line style overrides
+**Branch**: `feature/native-road-compiler`
+
+### Summary
+
+Added persistent native road centre-line colour and pattern overrides, automatic Workbench staging, continuous solid-line rendering, and Blender white material support.
+
+### Git Commits
+
+| Hash | Message |
+|------|---------|
+| `47efb78` | (see git log) |
+
+### Status
+
+[OK] **Completed**
+
+
+## Session 35: Complete native lane separator styles
+
+**Date**: 2026-08-17
+**Task**: Complete native lane separator styles
+**Branch**: `feature/native-road-compiler`
+
+### Summary
+
+Completed per lane-pair separator colour/pattern overrides, Workbench staging, Blender yellow material routing, and centre-line control clearance.
+
+### Git Commits
+
+| Hash | Message |
+|------|---------|
+| `bc04517` | (see git log) |
+
+### Status
+
+[OK] **Completed**
+
+
+## Session 36: Complete native road marking semantics
+
+**Date**: 2026-08-17
+**Task**: Complete native road marking semantics
+**Branch**: `feature/native-road-compiler`
+
+### Summary
+
+Added explicit double-yellow centre lines and per-side edge-line overrides; made all three marking classes selectable in the Chinese Road Workbench; synchronized Blender adapter coverage and verified Nantaizi native compile, quality gate, Blender/Cesium/preview manifests, and automated tests.
+
+### Git Commits
+
+| Hash | Message |
+|------|---------|
+| `9bb97d4` | (see git log) |
+
+### Status
+
+[OK] **Completed**
+
+
+## Session 37: Complete rounded native junction verification
+
+**Date**: 2026-08-18
+**Task**: Complete rounded native junction verification
+**Branch**: `feature/native-road-compiler`
+
+### Summary
+
+Recorded user-confirmed native Blender/Cesium/preview verification for rounded native junctions, checked off all acceptance criteria, and archived the completed 08-17-native-rounded-junctions task.
+
+### Git Commits
+
+| Hash | Message |
+|------|---------|
+| `e41bfd1` | (see git log) |
+| `f7e71cf` | (see git log) |
+
+### Status
+
+[OK] **Completed**

blender/generate_scene.py

@@ -663,6 +663,10 @@ def build(args):
         layer["id"]: material_from_spec(spec)
         for layer, spec in zip(catalog.ROAD_LAYERS, catalog.road_material_specs())
     }
+    road_mats["native_center_line_white"] = material_from_spec(
+        catalog.MATERIALS["native_center_line_white"])
+    road_mats["native_lane_separator_yellow"] = material_from_spec(
+        catalog.MATERIALS["native_lane_separator_yellow"])
     traffic_signal_mats = {
         "metal": material_from_spec(catalog.MATERIALS["traffic_signal_metal"]),
         "housing": material_from_spec(catalog.MATERIALS["traffic_signal_housing"]),
@@ -799,11 +803,24 @@ def build(args):
             target = source["material_layer"]
             layer = material_layers[target]
             source_path = os.path.join(native_road_dir, "layers", source["source"] + ".geojson")
-            count = _roads.assemble_geojson_layer(
-                source_path, source["source"], projector, roads_c,
-                road_mats[target], layer["z"])
-            if count == 0:
-                raise RuntimeError("Native road layer has no usable geometry: " + source_path)
+            if not os.path.isfile(source_path):
+                raise RuntimeError("Native road layer is missing: " + source_path)
+            if source["source"] == "center_lines":
+                count = _roads.assemble_geojson_layer(
+                    source_path, source["source"], projector, roads_c,
+                    road_mats[target], layer["z"],
+                    lambda props: props.get("color") != "white")
+                count += _roads.assemble_geojson_layer(
+                    source_path, source["source"] + "_white", projector, roads_c,
+                    road_mats["native_center_line_white"], layer["z"],
+                    lambda props: props.get("color") == "white")
+            elif source["source"] == "lane_separators":
+                count = _roads.assemble_geojson_layer(source_path, source["source"], projector, roads_c, road_mats[target], layer["z"], lambda props: props.get("color") != "yellow")
+                count += _roads.assemble_geojson_layer(source_path, source["source"] + "_yellow", projector, roads_c, road_mats["native_lane_separator_yellow"], layer["z"], lambda props: props.get("color") == "yellow")
+            else:
+                count = _roads.assemble_geojson_layer(
+                    source_path, source["source"], projector, roads_c,
+                    road_mats[target], layer["z"])
             road_counts[source["source"]] = count
     elif geojson_dir and os.path.isdir(geojson_dir):
         for problem in catalog.check_layers(geojson_dir):
@@ -818,7 +835,7 @@ def build(args):
         _roads.assemble_osm_fallback(
             ways, projector, roads_c, road_mats["road_surface"])
 
-    traffic_signal_path = os.path.join(geojson_dir or "", "traffic_signals.json")
+    traffic_signal_path = args.get("traffic_signals") or os.path.join(geojson_dir or "", "traffic_signals.json")
     dynamic_signal_objects = 0
     if os.path.exists(traffic_signal_path):
         try:

blender/osmassets/catalog.py

@@ -52,11 +52,15 @@ SCENE_STYLE_FILE = "osm2streets_scene_style.json"
 # It is a provider adapter, not a second scene-layer registry.
 NATIVE_ROAD_LAYERS = (
     {"source": "road_surface", "material_layer": "road_surface"},
+    {"source": "edge_lines", "material_layer": "lane_separators"},
     {"source": "intersection_surface", "material_layer": "intersection_surface"},
     {"source": "sidewalk_surface", "material_layer": "sidewalks"},
     {"source": "lane_separators", "material_layer": "lane_separators"},
+    {"source": "center_lines", "material_layer": "center_lines"},
     {"source": "direction_arrows", "material_layer": "lane_arrows_webscale"},
     {"source": "turn_arrows", "material_layer": "lane_arrows_webscale"},
+    {"source": "crosswalks", "material_layer": "crosswalks"},
+    {"source": "vehicle_stop_lines", "material_layer": "vehicle_stop_lines"},
 )
 
 
@@ -197,7 +201,13 @@ MATERIALS = {
     "traffic_signal_active_green": {"kind": "solid", "name": "Traffic Signal Active Green",
                                      "color": (0.04, 0.82, 0.22), "roughness": 0.25,
                                      "cesium": {"base_color": (0.04, 0.82, 0.22),
-                                                "emission": ((0.04, 0.82, 0.22), 1.0)}},
+                                                 "emission": ((0.04, 0.82, 0.22), 1.0)}},
+    "native_center_line_white": {"kind": "solid", "name": "Native Center Line White",
+                                   "color": (0.95, 0.94, 0.82), "roughness": 0.52,
+                                   "cesium": {"base_color": (0.95, 0.94, 0.82)}},
+    "native_lane_separator_yellow": {"kind": "solid", "name": "Native Lane Separator Yellow",
+                                       "color": (0.94, 0.58, 0.06), "roughness": 0.52,
+                                       "cesium": {"base_color": (0.94, 0.58, 0.06)}},
 }
 
 

blender/osmassets/roads.py

@@ -7,7 +7,8 @@ from osmassets.geom import clip_polygon, feature_in_bounds, geometry_rings
 from osmassets.mesh import MeshBatch, add_polyline
 
 
-def assemble_geojson_layer(path, layer_id, projector, collection, material, z):
+def assemble_geojson_layer(path, layer_id, projector, collection, material, z,
+                           property_filter=None):
     if not os.path.exists(path):
         return 0
     with open(path, "r", encoding="utf-8") as handle:
@@ -18,6 +19,8 @@ def assemble_geojson_layer(path, layer_id, projector, collection, material, z):
     xmax, ymax = projector.xy((b["max_lon"], b["max_lat"]))
     count = 0
     for feature in data.get("features", []):
+        if property_filter and not property_filter(feature.get("properties", {})):
+            continue
         if not feature_in_bounds(feature, projector):
             continue
         for ring in geometry_rings(feature.get("geometry")):

blender/tests/test_pure.py

@@ -52,8 +52,15 @@ class RoadLayerCatalogTest(unittest.TestCase):
             [(entry["source"], entry["material_layer"])
              for entry in NATIVE_ROAD_LAYERS],
             [("road_surface", "road_surface"),
+             ("edge_lines", "lane_separators"),
              ("intersection_surface", "intersection_surface"),
-             ("sidewalk_surface", "sidewalks")])
+             ("sidewalk_surface", "sidewalks"),
+             ("lane_separators", "lane_separators"),
+             ("center_lines", "center_lines"),
+             ("direction_arrows", "lane_arrows_webscale"),
+             ("turn_arrows", "lane_arrows_webscale"),
+             ("crosswalks", "crosswalks"),
+             ("vehicle_stop_lines", "vehicle_stop_lines")])
         self.assertTrue(all(entry["material_layer"] in layers
                             for entry in NATIVE_ROAD_LAYERS))
 

config/areas/nantaizi-lake-innovation-valley.json

@@ -24,6 +24,9 @@
   "turnLaneArrows": {
     "enabled": true
   },
+  "nativeRoad": {
+    "edgeLines": false
+  },
   "osm2streets": {
     "debug_each_step": false,
     "dual_carriageway_experiment": false,

config/examples/template.json

@@ -24,6 +24,9 @@
   "turnLaneArrows": {
     "enabled": false
   },
+  "nativeRoad": {
+    "edgeLines": false
+  },
   "osm2streets": {
     "debug_each_step": false,
     "dual_carriageway_experiment": false,

scripts/build-area.js

@@ -247,6 +247,7 @@ function buildBlenderScene(area, roadProvider) {
   ];
   if (roadProvider === "native") {
     blenderArgs.push("--native-road", area.outputs.nativeRoadDir);
+    blenderArgs.push("--traffic-signals", path.join(area.outputs.nativeRoadDir, "traffic-signals.json"));
   } else {
     blenderArgs.push("--geojson", area.outputs.geojsonDir);
   }
@@ -292,7 +293,7 @@ function buildBlenderScene(area, roadProvider) {
 
 function ensureNativeRoadLayers(area) {
   ensureFile(path.join(area.outputs.nativeRoadDir, "compiled.json"), "Native road compilation");
-  for (const file of ["road_surface.geojson", "intersection_surface.geojson", "sidewalk_surface.geojson", "lane_separators.geojson", "direction_arrows.geojson", "turn_arrows.geojson"]) {
+  for (const file of ["road_surface.geojson", "edge_lines.geojson", "intersection_surface.geojson", "sidewalk_surface.geojson", "lane_separators.geojson", "center_lines.geojson", "direction_arrows.geojson", "turn_arrows.geojson", "crosswalks.geojson", "vehicle_stop_lines.geojson"]) {
     ensureFile(path.join(area.outputs.nativeRoadDir, "layers", file), `Native road layer ${file}`);
   }
 }
@@ -302,11 +303,15 @@ function nativeRoadRecords(area) {
   return {
     nativeRoadCompiled: fileRecord(path.join(area.outputs.nativeRoadDir, "compiled.json")),
     nativeRoadSurface: fileRecord(path.join(root, "road_surface.geojson")),
+    nativeEdgeLines: fileRecord(path.join(root, "edge_lines.geojson")),
     nativeIntersectionSurface: fileRecord(path.join(root, "intersection_surface.geojson")),
     nativeSidewalkSurface: fileRecord(path.join(root, "sidewalk_surface.geojson")),
     nativeLaneSeparators: fileRecord(path.join(root, "lane_separators.geojson")),
+    nativeCenterLines: fileRecord(path.join(root, "center_lines.geojson")),
     nativeDirectionArrows: fileRecord(path.join(root, "direction_arrows.geojson")),
     nativeTurnArrows: fileRecord(path.join(root, "turn_arrows.geojson")),
+    nativeCrosswalks: fileRecord(path.join(root, "crosswalks.geojson")),
+    nativeVehicleStopLines: fileRecord(path.join(root, "vehicle_stop_lines.geojson")),
   };
 }
 
@@ -314,11 +319,15 @@ function nativeRoadFeatureCounts(area) {
   const root = path.join(area.outputs.nativeRoadDir, "layers");
   return {
     roadSurface: featureCount(path.join(root, "road_surface.geojson")),
+    edgeLines: featureCount(path.join(root, "edge_lines.geojson")),
     intersectionSurface: featureCount(path.join(root, "intersection_surface.geojson")),
     sidewalkSurface: featureCount(path.join(root, "sidewalk_surface.geojson")),
     laneSeparators: featureCount(path.join(root, "lane_separators.geojson")),
+    centerLines: featureCount(path.join(root, "center_lines.geojson")),
     directionArrows: featureCount(path.join(root, "direction_arrows.geojson")),
     turnArrows: featureCount(path.join(root, "turn_arrows.geojson")),
+    crosswalks: featureCount(path.join(root, "crosswalks.geojson")),
+    vehicleStopLines: featureCount(path.join(root, "vehicle_stop_lines.geojson")),
   };
 }
 

scripts/compile-native-roads.js

@@ -5,6 +5,7 @@ const fs = require("fs");
 const path = require("path");
 const { readAreaConfig } = require("./lib/area-config");
 const { compileRoadModel, compileGeometry, loadOverrides, validateOverrides, writeJsonAtomic } = require("./lib/native-road");
+const { loadOrGenerate, runtime } = require("./lib/native-traffic-signals");
 
 const repoRoot = path.resolve(__dirname, "..");
 
@@ -24,29 +25,40 @@ function compileArea(configPath) {
   const model = compileRoadModel(fs.readFileSync(area.input, "utf8"), overrides);
   validateOverrides(overrides, model);
   fs.mkdirSync(area.outputs.pipelineDir, { recursive: true });
-  const compiled = compileGeometry(model, overrides);
+  const compiled = compileGeometry(model, overrides, { edgeLines: area.nativeRoad.edgeLines });
+  const signalDocument = loadOrGenerate(area.outputs.nativeTrafficSignals, fs.readFileSync(area.input, "utf8"), compiled.vehicleStopLines, compiled.intersectionSurface);
+  const signalRuntime = runtime(signalDocument);
+  // Persist validation normalization, including one-time legacy heading migration.
+  writeJsonAtomic(area.outputs.nativeTrafficSignals, signalDocument);
   const staging = fs.mkdtempSync(path.join(area.outputs.pipelineDir, "native-road-"));
   try {
     const result = {
       schema: "native-road-compiled/v1",
       areaId: area.id,
-      source: { osm: area.input, overrides: area.outputs.nativeRoadOverrides },
+      source: { osm: area.input, overrides: area.outputs.nativeRoadOverrides, trafficSignals: area.outputs.nativeTrafficSignals },
       model: { roads: model.roads, endpoints: model.endpoints, connections: model.connections },
       movements: compiled.movements,
+      trafficSignals: { assemblies: "traffic-signal-assemblies.json", runtime: "traffic-signals.json", count: signalRuntime.signals.length },
       diagnostics: compiled.diagnostics,
-      layers: { roadSurface: "layers/road_surface.geojson", sidewalkSurface: "layers/sidewalk_surface.geojson", intersectionSurface: "layers/intersection_surface.geojson", laneCenterlines: "layers/lane_centerlines.geojson", laneSeparators: "layers/lane_separators.geojson", directionArrows: "layers/direction_arrows.geojson", turnArrows: "layers/turn_arrows.geojson", connectors: "layers/connectors.geojson" },
+      layers: { roadSurface: "layers/road_surface.geojson", edgeLines: "layers/edge_lines.geojson", sidewalkSurface: "layers/sidewalk_surface.geojson", intersectionSurface: "layers/intersection_surface.geojson", laneCenterlines: "layers/lane_centerlines.geojson", laneSeparators: "layers/lane_separators.geojson", centerLines: "layers/center_lines.geojson", directionArrows: "layers/direction_arrows.geojson", turnArrows: "layers/turn_arrows.geojson", crosswalks: "layers/crosswalks.geojson", vehicleStopLines: "layers/vehicle_stop_lines.geojson", connectors: "layers/connectors.geojson" },
     };
     const comparison = compareOsm2Streets(area, result.model, compiled);
     writeJsonAtomic(path.join(staging, "compiled.json"), result);
     writeJsonAtomic(path.join(staging, "diagnostics.json"), { schema: "native-road-diagnostics/v1", diagnostics: compiled.diagnostics });
     writeJsonAtomic(path.join(staging, "comparison.json"), comparison);
+    writeJsonAtomic(path.join(staging, "traffic-signal-assemblies.json"), signalDocument.assemblies);
+    writeJsonAtomic(path.join(staging, "traffic-signals.json"), signalRuntime);
     writeJsonAtomic(path.join(staging, "layers", "road_surface.geojson"), compiled.roadSurface);
+    writeJsonAtomic(path.join(staging, "layers", "edge_lines.geojson"), compiled.edgeLines);
     writeJsonAtomic(path.join(staging, "layers", "sidewalk_surface.geojson"), compiled.sidewalkSurface);
     writeJsonAtomic(path.join(staging, "layers", "intersection_surface.geojson"), compiled.intersectionSurface);
     writeJsonAtomic(path.join(staging, "layers", "lane_centerlines.geojson"), compiled.laneCenterlines);
     writeJsonAtomic(path.join(staging, "layers", "lane_separators.geojson"), compiled.laneSeparators);
+    writeJsonAtomic(path.join(staging, "layers", "center_lines.geojson"), compiled.centerLines);
     writeJsonAtomic(path.join(staging, "layers", "direction_arrows.geojson"), compiled.directionArrows);
     writeJsonAtomic(path.join(staging, "layers", "turn_arrows.geojson"), compiled.turnArrows);
+    writeJsonAtomic(path.join(staging, "layers", "crosswalks.geojson"), compiled.crosswalks);
+    writeJsonAtomic(path.join(staging, "layers", "vehicle_stop_lines.geojson"), compiled.vehicleStopLines);
     writeJsonAtomic(path.join(staging, "layers", "connectors.geojson"), compiled.connectors);
     fs.rmSync(area.outputs.nativeRoadDir, { recursive: true, force: true });
     fs.renameSync(staging, area.outputs.nativeRoadDir);
@@ -84,8 +96,11 @@ function compareOsm2Streets(area, model, compiled) {
     nativeMaxJunctionExpansionRatio: junctions.reduce((maximum, feature) => Math.max(maximum, Number(feature.properties.expansion_ratio) || 0), 0),
     nativeLaneCenterlineFeatures: compiled.laneCenterlines.features.length,
     nativeLaneSeparatorFeatures: compiled.laneSeparators.features.length,
+    nativeCenterLineFeatures: compiled.centerLines.features.length,
     nativeDirectionArrowFeatures: compiled.directionArrows.features.length,
     nativeTurnArrowFeatures: compiled.turnArrows.features.length,
+    nativeCrosswalkFeatures: compiled.crosswalks.features.length,
+    nativeVehicleStopLineFeatures: compiled.vehicleStopLines.features.length,
     nativeConnectorFeatures: compiled.connectors.features.length,
     nativeMovementCount: compiled.movements.length,
     nativePublishedMovementCount: compiled.movements.filter((movement) => movement.geometryPublished).length,

scripts/lib/area-config.js

@@ -38,6 +38,7 @@ function normalizeAreaConfig(raw, options = {}) {
     geojsonDir,
     nativeRoadDir,
     nativeRoadOverrides: path.resolve(outputOverrides.nativeRoadOverrides || path.join(areaDir, "native-road-overrides.json")),
+    nativeTrafficSignals: path.resolve(outputOverrides.nativeTrafficSignals || path.join(areaDir, "native-traffic-signals.json")),
     gpkg: path.resolve(outputOverrides.gpkg || path.join(areaDir, `${fileStem}.gpkg`)),
     qgisProject: path.resolve(outputOverrides.qgisProject || path.join(areaDir, `${fileStem}.qgz`)),
     qgisPreview: path.resolve(outputOverrides.qgisPreview || path.join(areaDir, `${fileStem}-preview.png`)),
@@ -107,6 +108,9 @@ function normalizeAreaConfig(raw, options = {}) {
     turnLaneArrows: {
       enabled: booleanOption(raw.turnLaneArrows?.enabled, false, "turnLaneArrows.enabled"),
     },
+    nativeRoad: {
+      edgeLines: booleanOption(raw.nativeRoad?.edgeLines, false, "nativeRoad.edgeLines"),
+    },
     osm2streets: raw.osm2streets || {
       debug_each_step: false,
       dual_carriageway_experiment: false,

scripts/lib/native-road.js

@@ -10,14 +10,31 @@ const DEFAULT_WIDTHS = { motorway: 12, trunk: 10, primary: 10, secondary: 8, ter
 const DEFAULT_SIDEWALK_WIDTH_METERS = 2;
 const DIRECTION_ARROW_INTERVAL_METERS = 32;
 const DIRECTION_ARROW_ENDPOINT_BUFFER_METERS = 14;
+const STOP_LINE_OFFSET_METERS = 2.7;
+const STOP_LINE_MAX_APPROACH_DISTANCE_METERS = 25;
+const CROSSWALK_JUNCTION_INSET_METERS = 1.5;
+const CROSSWALK_MAX_JUNCTION_INSET_METERS = 4;
+const CENTER_LINE_DASH_LENGTH_METERS = 2;
+const CENTER_LINE_DASH_GAP_METERS = 2;
+const CENTER_LINE_WIDTH_METERS = .25;
+const CENTER_LINE_SOLID_OVERLAP_METERS = .04;
+const CENTER_LINE_CONTROL_CLEARANCE_METERS = 1;
+const CENTER_LINE_COLORS = new Set(["yellow", "white"]);
+const CENTER_LINE_PATTERNS = new Set(["dashed", "solid"]);
+const CONNECTOR_BOUNDARY_TOLERANCE_METERS = .05;
+const JUNCTION_CURVE_SEGMENTS = 8;
 
 function parseOsmRoads(xml) {
   const nodes = new Map();
+  const crossingNodes = [];
   for (const match of xml.matchAll(/<node\b([^>]*?)(?:\/>|>([\s\S]*?)<\/node>)/g)) {
     const attrs = xmlAttrs(match[1]);
     if (attrs.action === "delete" || !attrs.id || attrs.lon === undefined || attrs.lat === undefined) continue;
     const coordinate = [Number(attrs.lon), Number(attrs.lat)];
-    if (coordinate.every(Number.isFinite)) nodes.set(String(attrs.id), coordinate);
+    if (!coordinate.every(Number.isFinite)) continue;
+    const id = String(attrs.id); const tags = parseTags(match[2] || "");
+    nodes.set(id, coordinate);
+    if (tags.highway === "crossing" && !["no", "none", "unmarked"].includes(tags["crossing:markings"])) crossingNodes.push({ id, coordinate, tags });
   }
   const ways = [];
   for (const match of xml.matchAll(/<way\b([^>]*)>([\s\S]*?)<\/way>/g)) {
@@ -30,7 +47,7 @@ function parseOsmRoads(xml) {
     if (coords.length < 2 || coords.length !== refs.length) continue;
     ways.push({ id: String(attrs.id), refs: refs.map(String), coords, tags });
   }
-  return { nodes, ways };
+  return { nodes, ways, crossingNodes };
 }
 
 function compileRoadModel(xml, overrides) {
@@ -72,7 +89,8 @@ function compileRoadModel(xml, overrides) {
       diagnostics.push({ ...diagnostic("warning", endpoint.roadId, [nodeId], "unconnected-interior-road-end", "道路在区域内部结束，未连接到其他机动车道路。请确认这是实际断头，还是 OSM 节点尚未连接。", endpoint.coordinate), endpointId: endpoint.id, manualCandidates: nearbyManualCandidates(endpoints, endpoint) });
     }
   }
-  return { schema: "native-road-model/v1", roads, endpoints, connections, diagnostics };
+  const crossings = parsed.crossingNodes.map((crossing) => ({ ...crossing, osmWayIds: parsed.ways.filter((way) => way.refs.includes(crossing.id)).map((way) => way.id) }));
+  return { schema: "native-road-model/v1", roads, endpoints, connections, crossings, diagnostics };
 }
 
 function splitWayAtSharedNodes(way, sharedNodeWayIds) {
@@ -136,8 +154,10 @@ function validateOverrides(value, model) {
   if (!value || value.schema !== OVERRIDE_SCHEMA || !Array.isArray(value.overrides)) throw new Error(`Overrides must use ${OVERRIDE_SCHEMA}.`);
   const ids = new Set();
   const roadIds = model ? new Set(model.roads.flatMap((road) => [road.id, road.sourceRoadId])) : null;
+  const directionalRoadIds = model ? new Set(model.roads.map((road) => road.id)) : null;
   const endpointIds = model ? new Set(model.endpoints.map((endpoint) => endpoint.id)) : null;
   const laneIds = model ? new Set(model.roads.flatMap((road) => Array.from({ length: road.laneCount }, (_, index) => `lane:${road.id}:${index + 1}`))) : null;
+  const segmentIds = model ? new Set(model.roads.map((road) => road.segmentId)) : null;
   for (const item of value.overrides) {
     if (!item || typeof item.id !== "string" || !item.id || ids.has(item.id)) throw new Error("Each override needs a unique id.");
     ids.add(item.id);
@@ -150,6 +170,12 @@ function validateOverrides(value, model) {
       if (model && !connectionEndpointsCompatible(model, item.fromEndpointId, item.toEndpointId)) throw new Error("A manual junction connection must go from a road end to a nearby road start (within 35m).");
     } else if (item.kind === "lane-connection") {
       if (typeof item.fromLaneId !== "string" || typeof item.toLaneId !== "string" || typeof item.enabled !== "boolean" || (laneIds && (!laneIds.has(item.fromLaneId) || !laneIds.has(item.toLaneId)))) throw new Error("Invalid lane connection override.");
+    } else if (item.kind === "center-line-style") {
+      if (typeof item.segmentId !== "string" || !CENTER_LINE_COLORS.has(item.color) || !CENTER_LINE_PATTERNS.has(item.pattern) || (item.double !== undefined && typeof item.double !== "boolean") || (item.double && (item.color !== "yellow" || item.pattern !== "solid")) || (segmentIds && !segmentIds.has(item.segmentId))) throw new Error("Invalid center line style override.");
+    } else if (item.kind === "lane-separator-style") {
+      if (typeof item.roadId !== "string" || (roadIds && !roadIds.has(item.roadId)) || !Number.isInteger(item.leftLaneIndex) || item.rightLaneIndex !== item.leftLaneIndex + 1 || !CENTER_LINE_COLORS.has(item.color) || !CENTER_LINE_PATTERNS.has(item.pattern)) throw new Error("Invalid lane separator style override.");
+    } else if (item.kind === "edge-line-style") {
+      if (typeof item.roadId !== "string" || (directionalRoadIds && !directionalRoadIds.has(item.roadId)) || !["left", "right"].includes(item.side) || !CENTER_LINE_COLORS.has(item.color) || !CENTER_LINE_PATTERNS.has(item.pattern)) throw new Error("Invalid edge line style override.");
     } else throw new Error(`Unsupported override kind: ${item.kind}`);
   }
   return { schema: OVERRIDE_SCHEMA, overrides: value.overrides };
@@ -216,7 +242,7 @@ function nearbyManualCandidates(endpoints, from) {
   return endpoints.filter((to) => to.side === "start" && to.roadId !== from.roadId && !sameOsmWay(endpoints, from.roadId, to.roadId)).map((to) => ({ to, distanceMeters: distanceMeters(from.coordinate, to.coordinate) })).filter((item) => item.distanceMeters <= 35).sort((a, b) => a.distanceMeters - b.distanceMeters).slice(0, 3).map(({ to, distanceMeters: meters }) => ({ toEndpointId: to.id, roadId: to.roadId, distanceMeters: Math.round(meters * 10) / 10 }));
 }
 
-function compileGeometry(model, overrides = { overrides: [] }) {
+function compileGeometry(model, overrides = { overrides: [] }, options = {}) {
   const diagnostics = [...model.diagnostics];
   const junctionPlans = compileJunctionPlans(model);
   const features = [];
@@ -227,35 +253,149 @@ function compileGeometry(model, overrides = { overrides: [] }) {
     emittedSegments.add(segmentKey);
     const directions = model.roads.filter((item) => item.segmentId === segmentKey);
     const totalWidth = directions.reduce((sum, item) => sum + item.widthMeters, 0);
-    // Road and junction asphalt share one final material. Keep the carriageway
-    // continuous through the semantic junction overlay; cutting it back creates
-    // visible wedges/gaps without improving the rendered result.
-    const ring = roadRing(road.centerline, totalWidth);
+    // The approach surface stops at the junction cutback. The junction layer
+    // owns the intervening rounded corners; leaving approaches untrimmed
+    // would cover that outline with rectangular road ends in Blender/Cesium.
+    const ring = roadRing(trimLineAtJunctions(road.centerline, road.sourceNodeIds, junctionPlans), totalWidth);
     if (!ring) { diagnostics.push(diagnostic("error", road.id, road.osmWayIds, "unclosed-road-surface", "Could not construct a valid road polygon from this centerline.", road.centerline[0])); continue; }
     const surfaceId = road.segmentId.endsWith("/0") ? `surface:way/${road.osmWayIds.join(",")}` : `surface:${segmentKey}`;
     features.push({ type: "Feature", properties: { native_id: surfaceId, directional_road_ids: directions.map((item) => item.id).join(","), osm_way_ids: road.osmWayIds.join(","), source_road_id: road.sourceRoadId, width_m: totalWidth, lane_count: directions.reduce((sum, item) => item.laneCount + sum, 0), provenance: JSON.stringify(directions.map((item) => item.provenance)), override_ids: directions.flatMap((item) => item.appliedOverrideIds).join(",") }, geometry: { type: "Polygon", coordinates: [ring] } });
   }
   const lanes = compileLaneCenterlines(model, diagnostics, junctionPlans);
-  const markings = compileLaneMarkings(model, lanes, diagnostics, junctionPlans);
+  const edgeLines = options.edgeLines === false ? [] : compileEdgeLines(model, overrides, junctionPlans);
+  const controls = compileControlMarkings(model, lanes, diagnostics, junctionPlans);
+  const centerLines = compileCenterLines(model, overrides, junctionPlans, controls, diagnostics);
+  const markings = compileLaneMarkings(model, overrides, lanes, diagnostics, junctionPlans, controls);
   const sidewalks = compileSidewalkSurfaces(model, diagnostics, junctionPlans);
   const connectorResult = compileConnectors(model, lanes, diagnostics, overrides);
   const junctionFeatures = compileJunctionSurfaces(model, junctionPlans, connectorResult.features, connectorResult.movements, diagnostics);
   validateConnectorContainment(connectorResult.features, junctionFeatures, diagnostics);
-  return { roadSurface: { type: "FeatureCollection", features }, sidewalkSurface: { type: "FeatureCollection", features: sidewalks }, intersectionSurface: { type: "FeatureCollection", features: junctionFeatures }, laneCenterlines: { type: "FeatureCollection", features: lanes.features }, laneSeparators: { type: "FeatureCollection", features: markings.separators }, directionArrows: { type: "FeatureCollection", features: markings.directionArrows }, turnArrows: { type: "FeatureCollection", features: markings.turnArrows }, connectors: { type: "FeatureCollection", features: connectorResult.features }, movements: connectorResult.movements, diagnostics };
+  return { roadSurface: { type: "FeatureCollection", features }, edgeLines: { type: "FeatureCollection", features: edgeLines }, sidewalkSurface: { type: "FeatureCollection", features: sidewalks }, intersectionSurface: { type: "FeatureCollection", features: junctionFeatures }, laneCenterlines: { type: "FeatureCollection", features: lanes.features }, laneSeparators: { type: "FeatureCollection", features: markings.separators }, centerLines: { type: "FeatureCollection", features: centerLines }, directionArrows: { type: "FeatureCollection", features: markings.directionArrows }, turnArrows: { type: "FeatureCollection", features: markings.turnArrows }, crosswalks: { type: "FeatureCollection", features: controls.crosswalks }, vehicleStopLines: { type: "FeatureCollection", features: controls.stopLines }, connectors: { type: "FeatureCollection", features: connectorResult.features }, movements: connectorResult.movements, diagnostics };
 }
 
-function compileLaneMarkings(model, lanes, diagnostics, junctionPlans) {
+function compileEdgeLines(model, overrides, junctionPlans) {
+  const features = [];
+  for (const road of model.roads) {
+    const line = trimLineAtJunctions(road.centerline, road.sourceNodeIds, junctionPlans);
+    const bidirectional = model.roads.some((item) => item.segmentId === road.segmentId && item.id !== road.id);
+    // On a two-way segment, the inner edge is the road centre boundary and is
+    // owned by center_lines. Emit only each directional carriageway's outer
+    // edge; emitting both sides makes the layer look like a second centreline.
+    const offsets = bidirectional ? [-1] : [-1, 1];
+    for (const offset of offsets) {
+      const side = offset < 0 ? "right" : "left";
+      const style = edgeLineStyle(overrides, road.id, side);
+      const centerline = offsetLine(line, offset * road.widthMeters / 2);
+      if (style.pattern === "solid") {
+        const ring = roadRing(centerline, .12);
+        if (ring) features.push(edgeLineFeature(road, side, style, ring));
+        continue;
+      }
+      for (let distance = 1, part = 1; distance + 1 <= lineLengthMeters(centerline); distance += 4, part += 1) {
+        const placement = pointAndAxisAlongLine(centerline, distance);
+        if (!placement) continue;
+        features.push(edgeLineFeature(road, side, style, rectangleAt(placement.point, placement.axis, [-placement.axis[1], placement.axis[0]], 2, .12, 0), part));
+      }
+    }
+  }
+  return features;
+}
+
+function edgeLineFeature(road, side, style, ring, part = null) {
+  return { type: "Feature", properties: { native_id: `edge-line:${road.id}:${side}${part ? `:${part}` : ""}`, road_id: road.id, side, osm_way_ids: road.osmWayIds.join(","), color: style.color, pattern: style.pattern, effective_style: `${style.color}-${style.pattern}`, provenance: "native-road-edge-line/v1" }, geometry: { type: "Polygon", coordinates: [ring] } };
+}
+
+function compileCenterLines(model, overrides, junctionPlans, controls, diagnostics) {
+  const features = [];
+  const controlFeatures = [...controls.crosswalks, ...controls.stopLines];
+  const segments = new Map();
+  for (const road of model.roads) {
+    if (!segments.has(road.segmentId)) segments.set(road.segmentId, []);
+    segments.get(road.segmentId).push(road);
+  }
+  for (const [segmentId, roads] of segments) {
+    const forward = roads.find((road) => road.direction === "forward");
+    const backward = roads.find((road) => road.direction === "backward");
+    if (roads.length !== 2 || !forward || !backward || forward.highway === "service" || backward.highway === "service") continue;
+    const line = trimLineAtJunctions(forward.centerline, forward.sourceNodeIds, junctionPlans);
+    const length = lineLengthMeters(line);
+    if (line.length < 2 || !Number.isFinite(length)) { diagnostics.push(diagnostic("warning", segmentId, forward.osmWayIds, "invalid-center-line", "双向道路无法生成有效道路中心虚线。", forward.centerline[0])); continue; }
+    const style = centerLineStyle(overrides, segmentId);
+    const gap = style.pattern === "solid" ? 0 : CENTER_LINE_DASH_GAP_METERS;
+    const markLength = CENTER_LINE_DASH_LENGTH_METERS + (style.pattern === "solid" ? CENTER_LINE_SOLID_OVERLAP_METERS : 0);
+    for (let start = 0, dashIndex = 1; start + markLength <= length; start += CENTER_LINE_DASH_LENGTH_METERS + gap, dashIndex += 1) {
+      const placement = pointAndAxisAlongLine(line, start + markLength / 2);
+      if (!placement) continue;
+      const clearanceRing = rectangleAt(placement.point, placement.axis, [-placement.axis[1], placement.axis[0]], markLength + CENTER_LINE_CONTROL_CLEARANCE_METERS * 2, CENTER_LINE_WIDTH_METERS + CENTER_LINE_CONTROL_CLEARANCE_METERS * 2, 0);
+      if (ringsOverlapControl([clearanceRing], controlFeatures)) continue;
+      for (const offset of style.double ? [-.16, .16] : [0]) { const ring = rectangleAt(placement.point, placement.axis, [-placement.axis[1], placement.axis[0]], markLength, CENTER_LINE_WIDTH_METERS, offset); features.push({ type: "Feature", properties: { native_id: `center-line:${segmentId}:${dashIndex}:${offset}`, segment_id: segmentId, road_id: forward.id, directional_road_ids: roads.map((road) => road.id).join(","), osm_way_ids: forward.osmWayIds.join(","), dash_index: dashIndex, dash_length_m: markLength, dash_gap_m: gap, color: style.color, pattern: style.pattern, double: Boolean(style.double), effective_style: `${style.double ? "double-" : ""}${style.color}-${style.pattern}`, placement_rule: "native-bidirectional-centerline/v1", provenance: "native-road-center-line/v1" }, geometry: { type: "Polygon", coordinates: [ring] } }); }
+    }
+  }
+  return features;
+}
+
+function centerLineStyle(overrides, segmentId) {
+  const override = overrides.overrides.find((item) => item.kind === "center-line-style" && item.segmentId === segmentId);
+  return override ? { color: override.color, pattern: override.pattern, double: Boolean(override.double) } : { color: "yellow", pattern: "dashed", double: false };
+}
+
+function edgeLineStyle(overrides, roadId, side) {
+  const value = overrides.overrides.find((item) => item.kind === "edge-line-style" && item.roadId === roadId && item.side === side);
+  return value ? { color: value.color, pattern: value.pattern } : { color: "white", pattern: "solid" };
+}
+
+function compileControlMarkings(model, lanes, diagnostics, junctionPlans = new Map()) {
+  const crosswalks = []; const stopLines = [];
+  const arrivalEndpointIds = new Set(model.connections.filter((connection) => connection.enabled).map((connection) => connection.fromEndpointId));
+  for (const crossing of model.crossings || []) {
+    const candidates = model.roads.filter((road) => crossing.osmWayIds.includes(road.osmWayIds[0])).flatMap((road) => (lanes.byRoadId.get(road.id) || []).map((lane) => ({ road, lane, placement: nearestLanePlacement(lane.coordinates, crossing.coordinate), junctionDistanceMeters: distanceMeters(crossing.coordinate, road.centerline.at(-1)) })).filter((item) => item.placement));
+    const candidate = candidates.sort((a, b) => a.placement.distance - b.placement.distance)[0];
+    if (!candidate || candidate.placement.distance > 12) { diagnostics.push(diagnostic("warning", `crossing:node/${crossing.id}`, [crossing.id], "crossing-no-native-lane", "人行横道无法匹配到安全的原生车道，未生成标线。", crossing.coordinate)); continue; }
+    const approach = candidates.filter((item) => arrivalEndpointIds.has(`endpoint:${item.road.id}:end`) && item.junctionDistanceMeters > STOP_LINE_OFFSET_METERS && item.junctionDistanceMeters <= STOP_LINE_MAX_APPROACH_DISTANCE_METERS).sort((a, b) => a.junctionDistanceMeters - b.junctionDistanceMeters || a.placement.distance - b.placement.distance)[0];
+    const crosswalkCandidate = approach || candidate;
+    const junctionInsetMeters = approach ? crossingJunctionInset(approach, junctionPlans) : 0;
+    const controlCenter = offsetByMeters(crossing.coordinate, crosswalkCandidate.placement.axis, junctionInsetMeters);
+    const { axis } = crosswalkCandidate.placement; const across = [-axis[1], axis[0]];
+    for (let index = 0; index < 6; index += 1) crosswalks.push(controlFeature("crosswalk", crossing, crosswalkCandidate, index + 1, rectangleAt(controlCenter, axis, across, 3, .45, -2.25 + index * .9), { junctionInsetMeters }));
+    if (!approach) { diagnostics.push(diagnostic("info", `crossing:node/${crossing.id}`, [crossing.id], "crossing-no-safe-stop-line", "人行横道没有可确认的路口进口车道，保留斑马线但未生成停止线。", crossing.coordinate)); continue; }
+    const rawRoadPlacement = nearestLanePlacement(approach.road.centerline, controlCenter);
+    const laneOffset = rawRoadPlacement ? project(approach.placement.point, rawRoadPlacement.point) : [0, 0];
+    const lateralOffset = laneOffset[0] * across[0] + laneOffset[1] * across[1];
+    const laneCenterAtCrossing = offsetByMeters(controlCenter, across, lateralOffset);
+    const stopCenter = offsetByMeters(laneCenterAtCrossing, approach.placement.axis, -STOP_LINE_OFFSET_METERS);
+    stopLines.push(controlFeature("stop-line", crossing, approach, 1, rectangleAt(stopCenter, across, approach.placement.axis, approach.road.widthMeters, .45, 0), { junctionInsetMeters }));
+  }
+  return { crosswalks, stopLines };
+}
+
+function crossingJunctionInset(candidate, junctionPlans) {
+  const junctionNodeId = candidate.road.sourceNodeIds.at(-1);
+  const plan = junctionPlans.get(junctionNodeId);
+  if (!plan) return 0;
+  const targetDistance = Math.max(0, plan.cutbackMeters - CROSSWALK_JUNCTION_INSET_METERS);
+  return Math.min(CROSSWALK_MAX_JUNCTION_INSET_METERS, Math.max(0, candidate.junctionDistanceMeters - targetDistance));
+}
+
+function nearestLanePlacement(line, target) { let best = null; let traversedMeters = 0; for (let index = 1; index < line.length; index += 1) { const a = line[index - 1]; const b = line[index]; const vector = project(b, a); const length = Math.hypot(...vector); if (!length) continue; const relative = project(target, a); const ratio = Math.max(0, Math.min(1, (relative[0] * vector[0] + relative[1] * vector[1]) / (length * length))); const point = interpolate(a, b, ratio); const distance = distanceMeters(point, target); if (!best || distance < best.distance) best = { point, axis: [vector[0] / length, vector[1] / length], distance, distanceToEndMeters: lineLengthMeters(line) - traversedMeters - length * ratio }; traversedMeters += length; } return best; }
+function offsetByMeters(point, axis, meters) { return unproject([axis[0] * meters, axis[1] * meters], point); }
+function rectangleAt(center, axis, across, length, width, offset) { const shifted = offsetByMeters(center, across, offset); const corners = [[-length / 2, -width / 2], [length / 2, -width / 2], [length / 2, width / 2], [-length / 2, width / 2]].map(([forward, side]) => unproject([axis[0] * forward + across[0] * side, axis[1] * forward + across[1] * side], shifted)); return [...corners, corners[0]]; }
+function controlFeature(kind, crossing, candidate, part, ring, placement = {}) { const stop = kind === "stop-line"; return { type: "Feature", properties: { native_id: `${kind}:node/${crossing.id}:${part}`, crossing_node_id: crossing.id, road_id: candidate.road.id, lane_id: candidate.lane.id, osm_way_ids: candidate.road.osmWayIds.join(","), direction: candidate.road.direction, placement_method: "native-lane-nearest-point/v1", junction_inset_m: Math.round((placement.junctionInsetMeters || 0) * 100) / 100, provenance: stop ? "native-road-stop-line/v1" : "native-road-crosswalk/v1" }, geometry: { type: "Polygon", coordinates: [ring] } }; }
+
+function compileLaneMarkings(model, overrides, lanes, diagnostics, junctionPlans, controls) {
   const separators = []; const directionArrows = []; const turnArrows = [];
+  const controlFeatures = [...controls.crosswalks, ...controls.stopLines];
   for (const road of model.roads) {
     const roadLanes = lanes.byRoadId.get(road.id) || [];
     for (let index = 1; index < roadLanes.length; index += 1) {
       const left = roadLanes[index - 1].coordinates; const right = roadLanes[index].coordinates;
       if (left.length !== right.length) continue;
       const centerline = left.map((point, pointIndex) => [(point[0] + right[pointIndex][0]) / 2, (point[1] + right[pointIndex][1]) / 2]);
-      const ring = roadRing(centerline, 0.12);
-      if (ring) separators.push({ type: "Feature", properties: { native_id: `lane-separator:${road.id}:${index}-${index + 1}`, road_id: road.id, left_lane_index: index, right_lane_index: index + 1, osm_way_ids: road.osmWayIds.join(","), provenance: "native-road-lane-separator/v1" }, geometry: { type: "Polygon", coordinates: [ring] } });
+      const style = laneSeparatorStyle(overrides, road.id, index, index + 1);
+      const properties = { road_id: road.id, left_lane_index: index, right_lane_index: index + 1, osm_way_ids: road.osmWayIds.join(","), color: style.color, pattern: style.pattern, effective_style: `${style.color}-${style.pattern}`, provenance: "native-road-lane-separator/v1" };
+      if (style.pattern === "solid") { const ring = roadRing(centerline, 0.12); if (ring) separators.push({ type: "Feature", properties: { native_id: `lane-separator:${road.id}:${index}-${index + 1}`, ...properties }, geometry: { type: "Polygon", coordinates: [ring] } }); }
+      else for (let distance = 1, part = 1; distance + 1 <= lineLengthMeters(centerline); distance += 4, part += 1) { const placement = pointAndAxisAlongLine(centerline, distance); if (!placement) continue; const ring = rectangleAt(placement.point, placement.axis, [-placement.axis[1], placement.axis[0]], 2, .12, 0); separators.push({ type: "Feature", properties: { native_id: `lane-separator:${road.id}:${index}-${index + 1}:${part}`, ...properties }, geometry: { type: "Polygon", coordinates: [ring] } }); }
     }
-    for (const lane of roadLanes) directionArrows.push(...directionArrowFeatures(road, lane));
+    for (const lane of roadLanes) directionArrows.push(...directionArrowFeatures(road, lane, controlFeatures, diagnostics));
     const turns = road.tags[`turn:lanes:${road.direction}`] ?? road.tags["turn:lanes"];
     const maneuvers = turns ? String(turns).split("|") : [];
     for (let index = 0; index < roadLanes.length; index += 1) {
@@ -265,30 +405,46 @@ function compileLaneMarkings(model, lanes, diagnostics, junctionPlans) {
       if (!lane) { diagnostics.push(diagnostic("warning", road.id, road.osmWayIds, "turn-arrow-lane-missing", "转向标签引用了不存在的车道，未生成箭头。", road.centerline.at(-1))); continue; }
       if (!arrowRingsAt(maneuver, lane.coordinates.at(-1), [0, 1]).length) { diagnostics.push(diagnostic("info", lane.id, road.osmWayIds, "turn-arrow-unsupported", "转向标签不在当前已测试的箭头集合中，未生成箭头。", lane.coordinates.at(-1))); continue; }
       if (lineLengthMeters(lane.coordinates) < 8) { diagnostics.push(diagnostic("warning", lane.id, road.osmWayIds, "turn-arrow-no-safe-placement", "驶入路口前的车道过短，未生成转向箭头。", lane.coordinates.at(-1))); continue; }
-      const center = pointAlongLine([...lane.coordinates].reverse(), 6);
       const previous = lane.coordinates.at(-2); const end = lane.coordinates.at(-1);
       const meters = project(end, end); const vector = project(previous, end); const length = Math.hypot(-vector[0], -vector[1]);
       const axis = length ? [-vector[0] / length, -vector[1] / length] : null;
-      const rings = axis ? arrowRingsAt(maneuver, center, axis) : [];
+      const placement = axis ? [6, 10, 14, 18, 22].find((distance) => distance < lineLengthMeters(lane.coordinates) - 2 && !ringsOverlapControl(arrowRingsAt(maneuver, pointAlongLine([...lane.coordinates].reverse(), distance), axis), controlFeatures)) : null;
+      if (!placement) { diagnostics.push(diagnostic("info", lane.id, road.osmWayIds, "turn-arrow-control-conflict", "转向箭头会压住斑马线或停止线，未生成该箭头。", lane.coordinates.at(-1))); continue; }
+      const center = pointAlongLine([...lane.coordinates].reverse(), placement);
+      const rings = arrowRingsAt(maneuver, center, axis);
       if (!rings.length) continue;
-      for (let part = 0; part < rings.length; part += 1) turnArrows.push({ type: "Feature", properties: { native_id: `turn-arrow:${lane.id}:${maneuver}:${part}`, road_id: road.id, lane_id: lane.id, osm_way_ids: road.osmWayIds.join(","), direction: road.direction, lane_index: lane.index, maneuver, arrow_part: part, placement_distance_meters: 6, provenance: "native-road-turn-arrow/v1" }, geometry: { type: "Polygon", coordinates: [rings[part]] } });
+      for (let part = 0; part < rings.length; part += 1) turnArrows.push({ type: "Feature", properties: { native_id: `turn-arrow:${lane.id}:${maneuver}:${part}`, road_id: road.id, lane_id: lane.id, osm_way_ids: road.osmWayIds.join(","), direction: road.direction, lane_index: lane.index, maneuver, arrow_part: part, placement_distance_meters: placement, provenance: "native-road-turn-arrow/v1" }, geometry: { type: "Polygon", coordinates: [rings[part]] } });
     }
   }
   return { separators, directionArrows, turnArrows };
 }
 
-function directionArrowFeatures(road, lane) {
+function laneSeparatorStyle(overrides, roadId, leftLaneIndex, rightLaneIndex) { const value = overrides.overrides.find((item) => item.kind === "lane-separator-style" && item.roadId === roadId && item.leftLaneIndex === leftLaneIndex && item.rightLaneIndex === rightLaneIndex); return value ? { color: value.color, pattern: value.pattern } : { color: "white", pattern: "dashed" }; }
+
+function directionArrowFeatures(road, lane, controlFeatures, diagnostics) {
   const length = lineLengthMeters(lane.coordinates);
   const features = [];
   for (let distance = DIRECTION_ARROW_ENDPOINT_BUFFER_METERS, sequence = 1; distance <= length - DIRECTION_ARROW_ENDPOINT_BUFFER_METERS; distance += DIRECTION_ARROW_INTERVAL_METERS, sequence += 1) {
     const placement = pointAndAxisAlongLine(lane.coordinates, distance);
     if (!placement) continue;
     const rings = arrowRingsAt("through", placement.point, placement.axis);
+    if (ringsOverlapControl(rings, controlFeatures)) { diagnostics.push(diagnostic("info", lane.id, road.osmWayIds, "direction-arrow-control-conflict", "默认直行箭头会压住斑马线或停止线，已跳过该位置。", placement.point)); continue; }
     for (let part = 0; part < rings.length; part += 1) features.push({ type: "Feature", properties: { native_id: `direction-arrow:${lane.id}:${sequence}:${part}`, road_id: road.id, lane_id: lane.id, osm_way_ids: road.osmWayIds.join(","), direction: road.direction, lane_index: lane.index, maneuver: "through", sequence, distance_along_lane_meters: Math.round(distance * 10) / 10, placement_interval_meters: DIRECTION_ARROW_INTERVAL_METERS, provenance: "native-road-direction-arrow/v1" }, geometry: { type: "Polygon", coordinates: [rings[part]] } });
   }
   return features;
 }
 
+function ringsOverlapControl(rings, controls) {
+  return rings.some((ring) => controls.some((feature) => ringsOverlap(ring, feature.geometry.coordinates[0])));
+}
+function ringsOverlap(first, second) {
+  const bounds = (ring) => [Math.min(...ring.map((point) => point[0])), Math.min(...ring.map((point) => point[1])), Math.max(...ring.map((point) => point[0])), Math.max(...ring.map((point) => point[1]))];
+  const a = bounds(first); const b = bounds(second);
+  if (a[0] > b[2] || a[2] < b[0] || a[1] > b[3] || a[3] < b[1]) return false;
+  if (first.some((point) => pointInPolygon(point, second)) || second.some((point) => pointInPolygon(point, first))) return true;
+  return first.slice(1).some((point, index) => second.slice(1).some((other, otherIndex) => segmentsIntersect(first[index], point, second[otherIndex], other)));
+}
+
 function compileSidewalkSurfaces(model, diagnostics, junctionPlans) {
   const features = [];
   const byWay = new Map();
@@ -343,6 +499,7 @@ function compileSidewalkCorners(model, junctionPlans) {
           wayKey: approach.segmentId,
           sourceWayKey: forward.osmWayIds.join(","),
           side,
+          outwardHeading: heading,
           normalDegrees: sideHeading,
           curb: offsetCoordinate(cutback, sideHeading, halfWidth),
           outer: offsetCoordinate(cutback, sideHeading, halfWidth + DEFAULT_SIDEWALK_WIDTH_METERS),
@@ -354,17 +511,24 @@ function compileSidewalkCorners(model, junctionPlans) {
       const first = candidates[index];
       const second = candidates[(index + 1) % candidates.length];
       if (first.wayKey === second.wayKey) continue;
-      const ring = [first.curb, first.outer, second.outer, second.curb, first.curb];
+      const continuation = isStraightSidewalkContinuation(first, second);
+      if (first.sourceWayKey === second.sourceWayKey && !continuation) continue;
+      // A split-through road has two approaches at this node. Its pedestrian
+      // strip is a direct continuation, not a curb corner. Treating it as a
+      // curve creates the oversized outer lobe seen at T junctions.
+      const ring = continuation
+        ? [first.curb, first.outer, second.outer, second.curb, first.curb]
+        : roundedSidewalkCorner(plan.node, first, second);
       if (hasSelfIntersection(ring)) continue;
-      if (first.sourceWayKey === second.sourceWayKey && (!samePhysicalSide(first, second) || cornerFallsIntoOtherApproach(ring, first.sourceWayKey, plan.approaches))) continue;
+      if (continuation && cornerFallsIntoOtherApproach(ring, first.sourceWayKey, plan.approaches)) continue;
       result.push({
         type: "Feature",
         properties: {
           native_id: `sidewalk-corner:node/${nodeId}:${first.wayKey}:${first.side}->${second.wayKey}:${second.side}`,
           osm_node_id: nodeId,
-          kind: "corner",
+          kind: continuation ? "continuation" : "corner",
           width_m: DEFAULT_SIDEWALK_WIDTH_METERS,
-          provenance: "native-road-sidewalk-corner/v1",
+          provenance: continuation ? "native-road-sidewalk-continuation/v1" : "native-road-sidewalk-corner/v1",
         },
         geometry: { type: "Polygon", coordinates: [ring] },
       });
@@ -373,13 +537,51 @@ function compileSidewalkCorners(model, junctionPlans) {
   return result;
 }
 
+function roundedSidewalkCorner(node, first, second) {
+  // Keep the established vehicle curb geometry, then derive the outer edge
+  // from it. Independent Bezier curves drift apart and leave asphalt exposed
+  // between the junction and pedestrian layers.
+  const curbForward = roundedCorner(node, first.curb, second.curb, first.outwardHeading, second.outwardHeading) || [first.curb, second.curb];
+  // Construct the outside edge from the same tangent-support rule. A linear
+  // point-by-point offset changes the curvature and makes the two boundaries
+  // visibly disagree at the middle of the corner.
+  const outerForward = roundedCorner(node, first.outer, second.outer, first.outwardHeading, second.outwardHeading)
+    || offsetCornerArc(curbForward, first.curb, first.outer, second.curb, second.outer);
+  const curbArc = [...curbForward].reverse();
+  return [
+    first.curb,
+    first.outer,
+    ...outerForward.slice(1, -1),
+    second.outer,
+    second.curb,
+    ...curbArc.slice(1, -1),
+    first.curb,
+  ];
+}
+
+function offsetCornerArc(curbArc, firstCurb, firstOuter, secondCurb, secondOuter) {
+  return curbArc.map((point, index) => {
+    const ratio = curbArc.length === 1 ? 0 : index / (curbArc.length - 1);
+    const firstOffset = [firstOuter[0] - firstCurb[0], firstOuter[1] - firstCurb[1]];
+    const secondOffset = [secondOuter[0] - secondCurb[0], secondOuter[1] - secondCurb[1]];
+    return [point[0] + firstOffset[0] + (secondOffset[0] - firstOffset[0]) * ratio, point[1] + firstOffset[1] + (secondOffset[1] - firstOffset[1]) * ratio];
+  });
+}
+
 function samePhysicalSide(first, second) {
   const radians = (first.normalDegrees - second.normalDegrees) * Math.PI / 180;
   return Math.cos(radians) >= 0.98;
 }
 
+function isStraightSidewalkContinuation(first, second) {
+  if (first.sourceWayKey !== second.sourceWayKey || !samePhysicalSide(first, second)) return false;
+  const radians = (first.outwardHeading - second.outwardHeading) * Math.PI / 180;
+  return Math.cos(radians) <= -0.98;
+}
+
 function cornerFallsIntoOtherApproach(ring, sourceWayKey, approaches) {
-  const center = ring.slice(0, -1).reduce((sum, point) => [sum[0] + point[0] / 4, sum[1] + point[1] / 4], [0, 0]);
+  const vertices = ring.slice(0, -1);
+  const center = vertices.reduce((sum, point) => [sum[0] + point[0] / vertices.length, sum[1] + point[1] / vertices.length], [0, 0]);
   return approaches.filter((approach) => approach.sourceWayKey !== sourceWayKey).some((approach) => {
     const carriageway = roadRing(approach.line, approach.widthMeters);
     return carriageway && pointInPolygon(center, carriageway);
@@ -392,7 +594,7 @@ function validateConnectorContainment(connectors, junctionFeatures, diagnostics)
     const junction = junctionByNode.get(connector.properties.node_id);
     if (!junction) continue;
     const ring = junction.geometry.coordinates[0];
-    if (!connector.geometry.coordinates.every((point) => pointInPolygon(point, ring))) {
+    if (!connector.geometry.coordinates.every((point) => pointInOrNearPolygon(point, ring, CONNECTOR_BOUNDARY_TOLERANCE_METERS))) {
       diagnostics.push(diagnostic("warning", connector.properties.connection_id, [connector.properties.node_id], "connector-outside-junction", "转向路径有部分落在路口面外，请检查道路截面或转向连接。", connector.geometry.coordinates[0]));
     }
   }
@@ -408,6 +610,17 @@ function pointInPolygon(point, ring) {
   }
   return inside;
 }
+function pointInOrNearPolygon(point, ring, toleranceMeters) {
+  return pointInPolygon(point, ring) || ring.slice(1).some((end, index) => distancePointToSegmentMeters(point, ring[index], end) <= toleranceMeters);
+}
+function distancePointToSegmentMeters(point, start, end) {
+  const localPoint = project(point, start);
+  const localEnd = project(end, start);
+  const lengthSquared = localEnd[0] ** 2 + localEnd[1] ** 2;
+  if (lengthSquared < .0001) return Math.hypot(...localPoint);
+  const ratio = Math.max(0, Math.min(1, (localPoint[0] * localEnd[0] + localPoint[1] * localEnd[1]) / lengthSquared));
+  return Math.hypot(localPoint[0] - localEnd[0] * ratio, localPoint[1] - localEnd[1] * ratio);
+}
 function pointOnSegment(point, a, b) {
   const cross = (point[0] - a[0]) * (b[1] - a[1]) - (point[1] - a[1]) * (b[0] - a[0]);
   if (Math.abs(cross) > 1e-12) return false;
@@ -553,8 +766,8 @@ function compileJunctionSurfaces(model, junctionPlans, connectors, movements, di
     }
     const approachAreaMeters = polygonAreaMeters(boundary);
     let ring = [...boundary, boundary[0]];
-    let boundaryMode = "approach-envelope";
-    if (hasSelfIntersection(ring) || !junctionConnectors.every((feature) => feature.geometry.coordinates.every((point) => pointInPolygon(point, ring)))) {
+    let boundaryMode = plan.boundaryMode || "approach-envelope";
+    if (hasSelfIntersection(ring) || !junctionConnectors.every((feature) => feature.geometry.coordinates.every((point) => pointInOrNearPolygon(point, ring, CONNECTOR_BOUNDARY_TOLERANCE_METERS)))) {
       const envelope = convexHull([...boundary, ...junctionConnectors.flatMap((feature) => feature.geometry.coordinates)]);
       ring = [...envelope, envelope[0]];
       boundaryMode = "connector-convex-fallback";
@@ -567,6 +780,7 @@ function compileJunctionSurfaces(model, junctionPlans, connectors, movements, di
     const expansionRatio = approachAreaMeters > 0 ? surfaceAreaMeters / approachAreaMeters : null;
     result.push({ type: "Feature", properties: { native_id: `junction:node/${nodeId}`, osm_node_id: nodeId, kind: segmentIds.size === 3 ? "t" : "cross", source_road_ids: approaches.flatMap((approach) => approach.roadIds).join(","), cutback_m: cutbackMeters, movement_count: junctionMovements.length, connector_count: junctionConnectors.length, boundary_mode: boundaryMode, approach_area_m2: Math.round(approachAreaMeters * 10) / 10, surface_area_m2: Math.round(surfaceAreaMeters * 10) / 10, expansion_ratio: expansionRatio === null ? null : Math.round(expansionRatio * 100) / 100, rule: "junction-shared-cutback/v4-shared-node-split" }, geometry: { type: "Polygon", coordinates: [ring] } });
     if (boundaryMode === "connector-convex-fallback") diagnostics.push(diagnostic("warning", `junction:node/${nodeId}`, [nodeId], "junction-connector-envelope-fallback", "路口面需要按转向路径的凸包兜底生成；请检查外缘和路缘与步行带是否符合实际。", node));
+    if (plan.boundaryFallbacks) diagnostics.push(diagnostic("warning", `junction:node/${nodeId}`, [nodeId], "junction-rounded-corner-fallback", "部分路口圆角无法按道路边缘切线安全构造，已对该角使用确定性的直线回退。", node));
     diagnostics.push(diagnostic("info", `junction:node/${nodeId}`, [nodeId], "ordinary-junction-surface", "已按道路截面与转向路径生成普通路口面。", node));
   }
   return result;
@@ -584,11 +798,13 @@ function compileJunctionPlans(model) {
     if (segmentIds.size < 3 || segmentIds.size > 4) continue;
     const approaches = junctionApproaches(model, endpoints);
     if (approaches.length !== segmentIds.size) continue;
+    // Rounded curb corners need enough approach length to retain the full
+    // turning envelope after the corner is cut toward the junction.
     const cutbackMeters = Math.max(...approaches.map((approach) => approach.widthMeters)) * 1.4;
     const node = endpoints[0].coordinate;
     const boundary = junctionBoundary(approaches, node, cutbackMeters);
-    if (boundary.length < 3) continue;
-    plans.set(nodeId, { node, segmentIds, approaches, cutbackMeters, boundary });
+    if (boundary.points.length < 3) continue;
+    plans.set(nodeId, { node, segmentIds, approaches, cutbackMeters, boundary: boundary.points, boundaryMode: boundary.mode, boundaryFallbacks: boundary.fallbacks });
   }
   return plans;
 }
@@ -615,10 +831,66 @@ function junctionBoundary(approaches, node, cutbackMeters) {
     if (!cutback) continue;
     const heading = headingAtEndpoint(approach.line);
     const half = approach.widthMeters / 2;
-    points.push(offsetCoordinate(cutback, heading + 90, half));
-    points.push(offsetCoordinate(cutback, heading - 90, half));
+    points.push({ point: offsetCoordinate(cutback, heading + 90, half), segmentId: approach.segmentId, sourceWayKey: approach.sourceWayKey, outwardHeading: heading });
+    points.push({ point: offsetCoordinate(cutback, heading - 90, half), segmentId: approach.segmentId, sourceWayKey: approach.sourceWayKey, outwardHeading: heading });
   }
-  return sortAround(node, points);
+  const ordered = points.sort((a, b) => angleAround(node, a.point) - angleAround(node, b.point));
+  if (ordered.length < 3) return { points: [], mode: "approach-envelope" };
+  const boundary = [];
+  let rounded = 0;
+  let fallbacks = 0;
+  for (let index = 0; index < ordered.length; index += 1) {
+    const first = ordered[index]; const second = ordered[(index + 1) % ordered.length];
+    boundary.push(first.point);
+    // One physical OSM way is often split at an intersection node. Its two
+    // opposite approaches share a continuous road edge; rounding that edge
+    // bends the far side of a T junction and exposes junction asphalt beyond
+    // the pedestrian strip.
+    if (first.segmentId === second.segmentId || isStraightJunctionEdge(first, second)) continue;
+    const curve = roundedCorner(node, first.point, second.point, first.outwardHeading, second.outwardHeading);
+    if (!curve) { fallbacks += 1; continue; }
+    boundary.push(...curve.slice(1, -1));
+    rounded += 1;
+  }
+  return { points: boundary, mode: rounded ? "rounded-approach-envelope" : "approach-envelope", fallbacks };
+}
+
+function isStraightJunctionEdge(first, second) {
+  if (first.sourceWayKey !== second.sourceWayKey) return false;
+  const radians = (first.outwardHeading - second.outwardHeading) * Math.PI / 180;
+  return Math.cos(radians) <= -0.98;
+}
+
+function roundedCorner(node, first, second, firstHeading, secondHeading) {
+  const origin = node;
+  const a = project(first, origin); const b = project(second, origin);
+  const chord = Math.hypot(a[0] - b[0], a[1] - b[1]);
+  if (chord < .5 || !Number.isFinite(firstHeading) || !Number.isFinite(secondHeading)) return null;
+  const firstDirection = headingVector(firstHeading);
+  const secondDirection = headingVector(secondHeading);
+  const intersection = lineIntersection(a, firstDirection, b, secondDirection);
+  if (!intersection) return null;
+  const controlDistance = Math.hypot(...intersection);
+  const endpointDistance = Math.max(Math.hypot(...a), Math.hypot(...b));
+  // Adjacent approach edge tangents should meet in the corner between the
+  // node and the cutback. Reject near-parallel or remote intersections rather
+  // than publishing a huge/self-crossing curve.
+  if (controlDistance < .01 || controlDistance > endpointDistance * 1.5 || controlDistance > 80) return null;
+  const control = unproject(intersection, origin);
+  return quadraticCurve(first, control, second, JUNCTION_CURVE_SEGMENTS);
+}
+
+function headingVector(degrees) {
+  const radians = degrees * Math.PI / 180;
+  return [Math.sin(radians), Math.cos(radians)];
+}
+
+function lineIntersection(firstPoint, firstDirection, secondPoint, secondDirection) {
+  const cross = firstDirection[0] * secondDirection[1] - firstDirection[1] * secondDirection[0];
+  if (Math.abs(cross) < 1e-4) return null;
+  const delta = [secondPoint[0] - firstPoint[0], secondPoint[1] - firstPoint[1]];
+  const firstDistance = (delta[0] * secondDirection[1] - delta[1] * secondDirection[0]) / cross;
+  return [firstPoint[0] + firstDirection[0] * firstDistance, firstPoint[1] + firstDirection[1] * firstDistance];
 }
 
 function pointAlongLine(line, meters) {

scripts/lib/native-traffic-signals.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const fs = require("fs");
+const { parseOsm } = require("./osm");
+const {
+  buildTrafficSignalFeatures,
+  buildTrafficSignalsFromFeatures,
+  validateTrafficSignalFeatures,
+  validateTrafficSignalSourceReferences,
+} = require("./traffic-signals");
+
+const SCHEMA = "native-traffic-signals/v1";
+
+function loadOrGenerate(file, osmText, stopLines, intersections) {
+  if (fs.existsSync(file)) return validateDocument(JSON.parse(fs.readFileSync(file, "utf8")), osmText);
+  return generate(osmText, stopLines, intersections);
+}
+
+function generate(osmText, stopLines, intersections) {
+  const controls = parseOsm(osmText).trafficSignalControls;
+  return { schema: SCHEMA, provenance: "generated:osm-controls", assemblies: buildTrafficSignalFeatures(stopLines, intersections, controls) };
+}
+
+function validateDocument(value, osmText) {
+  if (value?.schema !== SCHEMA) throw new Error(`Expected ${SCHEMA} signal document`);
+  const assemblies = validateTrafficSignalFeatures(value.assemblies);
+  if (osmText) validateTrafficSignalSourceReferences(assemblies, parseOsm(osmText).trafficSignalControls);
+  return { schema: SCHEMA, provenance: value.provenance || "native", assemblies };
+}
+
+function runtime(document) { return buildTrafficSignalsFromFeatures(document.assemblies); }
+
+module.exports = { SCHEMA, generate, loadOrGenerate, validateDocument, runtime };

scripts/lib/traffic-signals.js

@@ -59,7 +59,11 @@ function buildTrafficSignalFeatures(stopLines, intersections, controls = []) {
         properties: {
           signal_uid: signalUid, display_id: signalUid, control_id: String(control.id),
           approach_id: approachId, source_way_id: sourceWayId,
-          heading_deg: candidate.headingDegrees, phase_group: groups[index],
+          // These are independent assembly controls.  heading_deg remains a
+          // migration hint for older native documents only.
+          mast_heading_deg: normalizeDegrees(candidate.headingDegrees - 90),
+          face_heading_deg: normalizeDegrees(candidate.headingDegrees + 180),
+          phase_group: groups[index],
           mast_reach_m: MAST_REACH_METERS,
           stop_lon: candidate.center[0], stop_lat: candidate.center[1],
           enabled: true, z_offset_m: 0,
@@ -114,13 +118,30 @@ function validateTrafficSignalFeatures(collection) {
     if (!approachId.startsWith(`${sourceWayId}:`)) throw new Error(`${label}: approach_id does not match source_way_id`);
     const expectedUid = `osm-${controlId}-${approachId.replace(":", "-")}`;
     if (signalUid !== expectedUid) throw new Error(`${label}: signal_uid does not match source identity (expected '${expectedUid}')`);
+    const legacyHeading = input.heading_deg == null || input.heading_deg === "" ? null : normalizeDegrees(number("heading_deg"));
+    if (legacyHeading == null && (input.mast_heading_deg == null || input.mast_heading_deg === "")) {
+      throw new Error(`${label}: missing mast_heading_deg`);
+    }
+    if (legacyHeading == null && (input.face_heading_deg == null || input.face_heading_deg === "")) {
+      throw new Error(`${label}: missing face_heading_deg`);
+    }
+    const mastHeading = input.mast_heading_deg == null || input.mast_heading_deg === ""
+      ? normalizeDegrees((legacyHeading == null ? 0 : legacyHeading) - 90)
+      : normalizeDegrees(number("mast_heading_deg"));
+    const faceHeading = input.face_heading_deg == null || input.face_heading_deg === ""
+      ? normalizeDegrees((legacyHeading == null ? 0 : legacyHeading) + 180)
+      : normalizeDegrees(number("face_heading_deg"));
     return {
       type: "Feature",
       geometry: { type: "Point", coordinates: feature.geometry.coordinates.slice(0, 2).map(Number) },
       properties: {
         ...input, signal_uid: signalUid, display_id: displayId,
         control_id: controlId, approach_id: approachId,
-        source_way_id: sourceWayId, heading_deg: normalizeDegrees(number("heading_deg")),
+        source_way_id: sourceWayId,
+        // Retain the legacy value only for migration compatibility.  Runtime
+        // geometry is entirely defined by mast_heading_deg and face_heading_deg.
+        heading_deg: legacyHeading,
+        mast_heading_deg: mastHeading, face_heading_deg: faceHeading,
         phase_group: phaseGroup, mast_reach_m: number("mast_reach_m", { min: 0.1, max: 30 }),
         stop_lon: number("stop_lon", { min: -180, max: 180 }),
         stop_lat: number("stop_lat", { min: -90, max: 90 }),
@@ -136,16 +157,20 @@ function buildTrafficSignalsFromFeatures(collection) {
   const signals = normalized.features.filter((feature) => feature.properties.enabled).map((feature) => {
     const p = feature.properties;
     const point = feature.geometry.coordinates;
-    const axis = headingVector(p.heading_deg);
+    const mastAxis = headingVector(p.mast_heading_deg);
     return {
       id: p.signal_uid, signalUid: p.signal_uid, displayId: p.display_id,
       nodeKey: signalNodeKey(p.signal_uid),
       controlId: p.control_id, approachId: p.approach_id, sourceWayId: p.source_way_id,
       phaseGroup: p.phase_group, longitude: point[0], latitude: point[1],
       stopLongitude: p.stop_lon, stopLatitude: p.stop_lat,
-      headingDegrees: p.heading_deg, mastReachMeters: p.mast_reach_m,
+      // Existing Blender readers require headingDegrees.  It is a compatibility
+      // alias only; the independent mast/face fields below define all geometry.
+      headingDegrees: p.heading_deg == null ? p.mast_heading_deg : p.heading_deg,
+      mastHeadingDegrees: p.mast_heading_deg,
+      faceHeadingDegrees: p.face_heading_deg, mastReachMeters: p.mast_reach_m,
       zOffsetMeters: p.z_offset_m,
-      pose: buildSignalPose(point, axis, p.mast_reach_m, p.z_offset_m),
+      pose: buildSignalPose(point, mastAxis, p.face_heading_deg, p.mast_reach_m, p.z_offset_m),
     };
   });
   return { version: 3, layout: SIGNAL_LAYOUT, signals };
@@ -235,12 +260,13 @@ function phaseGroups(arms) {
   groups[main[0]] = 0; groups[main[1]] = 0; return groups;
 }
 
-function buildSignalPose(pole, axis, mastReach, zOffset = 0) {
-  const lateral = [axis[1], -axis[0]]; const face = [-axis[0], -axis[1]];
-  const head = moveMeters(pole, lateral, -mastReach); const faceHeadingDegrees = Math.atan2(face[0], face[1]) * 180 / Math.PI;
+function buildSignalPose(pole, mastAxis, faceHeadingDegrees, mastReach, zOffset = 0) {
+  const face = headingVector(faceHeadingDegrees);
+  const head = moveMeters(pole, mastAxis, mastReach);
   const position = (point, height) => ({ longitude: point[0], latitude: point[1], height: height + zOffset });
   const lensPoint = moveMeters(head, face, SIGNAL_LAYOUT.lensFaceOffsetMeters);
-  const board = moveMeters(moveMeters(head, lateral, SIGNAL_LAYOUT.countdownLateralMeters), face, SIGNAL_LAYOUT.countdownFaceOffsetMeters);
+  const faceRight = [-face[1], face[0]];
+  const board = moveMeters(moveMeters(head, faceRight, SIGNAL_LAYOUT.countdownLateralMeters), face, SIGNAL_LAYOUT.countdownFaceOffsetMeters);
   return { pole: position(pole, 0), arm: { from: position(pole, SIGNAL_LAYOUT.mastHeightMeters), to: position(head, SIGNAL_LAYOUT.mastHeightMeters) }, head: { ...position(head, SIGNAL_LAYOUT.headCenterHeightMeters), faceHeadingDegrees }, lenses: ["red", "yellow", "green"].map((state, index) => ({ state, ...position(lensPoint, SIGNAL_LAYOUT.headCenterHeightMeters + SIGNAL_LAYOUT.lensVerticalOffsetsMeters[index]) })), countdown: { ...position(board, SIGNAL_LAYOUT.mastHeightMeters), faceHeadingDegrees } };
 }
 

scripts/road-workbench.js

@@ -6,6 +6,7 @@ const http = require("http");
 const path = require("path");
 const { readAreaConfig } = require("./lib/area-config");
 const { loadOverrides, validateOverrides, writeJsonAtomic } = require("./lib/native-road");
+const { generate, validateDocument, runtime } = require("./lib/native-traffic-signals");
 const { compileArea, parseArgs } = require("./compile-native-roads");
 
 const repoRoot = path.resolve(__dirname, "..");
@@ -32,6 +33,20 @@ function handle(request, response, area, configPath) {
   if (request.method === "GET" && url.pathname === "/app.css") return sendFile(response, path.join(repoRoot, "scripts", "workbench", "app.css"), "text/css; charset=utf-8");
   if (request.method === "GET" && url.pathname.startsWith("/vendor/")) return sendVendorFile(response, url.pathname);
   if (request.method === "GET" && url.pathname === "/api/state") return sendJson(response, 200, state(area));
+  if (request.method === "POST" && url.pathname === "/api/traffic-signals") return readBody(request).then((body) => {
+    const document = validateDocument(body, fs.readFileSync(area.input, "utf8"));
+    writeJsonAtomic(area.outputs.nativeTrafficSignals, document);
+    sendJson(response, 200, { ok: true, trafficSignals: document, runtime: runtime(document) });
+  }).catch((error) => sendJson(response, 400, { ok: false, error: error.message }));
+  if (request.method === "POST" && url.pathname === "/api/traffic-signals/generate") return Promise.resolve().then(() => {
+    const compiled = readCompiled(area);
+    const generated = generate(fs.readFileSync(area.input, "utf8"), readLayer(path.join(area.outputs.nativeRoadDir, "layers", "vehicle_stop_lines.geojson")), readLayer(path.join(area.outputs.nativeRoadDir, "layers", "intersection_surface.geojson")));
+    const current = validateDocument(readJson(area.outputs.nativeTrafficSignals), fs.readFileSync(area.input, "utf8"));
+    const present = new Set(current.assemblies.features.map((feature) => feature.properties.signal_uid));
+    current.assemblies.features.push(...generated.assemblies.features.filter((feature) => !present.has(feature.properties.signal_uid)));
+    writeJsonAtomic(area.outputs.nativeTrafficSignals, current);
+    sendJson(response, 200, { ok: true, trafficSignals: current, runtime: runtime(current), generated: generated.assemblies.features.length, compiled: Boolean(compiled) });
+  }).catch((error) => sendJson(response, 400, { ok: false, error: error.message }));
   if (request.method === "POST" && url.pathname === "/api/overrides") return readBody(request).then((body) => {
     const compiled = readCompiled(area);
     const overrides = validateOverrides(body, { roads: compiled.model.roads, endpoints: compiled.model.endpoints });
@@ -48,7 +63,11 @@ function handle(request, response, area, configPath) {
 function state(area) {
   const nativeDir = area.outputs.nativeRoadDir;
   const osm2streetsRoadSurface = path.join(area.outputs.geojsonDir, "road_surface.geojson");
-  return { areaId: area.id, compiled: readCompiled(area), overrides: loadOverrides(area.outputs.nativeRoadOverrides), comparison: readJson(path.join(nativeDir, "comparison.json")), layers: { nativeRoadSurface: readLayer(path.join(nativeDir, "layers", "road_surface.geojson")), nativeSidewalkSurface: readLayer(path.join(nativeDir, "layers", "sidewalk_surface.geojson")), nativeIntersectionSurface: readLayer(path.join(nativeDir, "layers", "intersection_surface.geojson")), laneCenterlines: readLayer(path.join(nativeDir, "layers", "lane_centerlines.geojson")), laneSeparators: readLayer(path.join(nativeDir, "layers", "lane_separators.geojson")), directionArrows: readLayer(path.join(nativeDir, "layers", "direction_arrows.geojson")), turnArrows: readLayer(path.join(nativeDir, "layers", "turn_arrows.geojson")), connectors: readLayer(path.join(nativeDir, "layers", "connectors.geojson")), osm2streetsRoadSurface: fs.existsSync(osm2streetsRoadSurface) ? readLayer(osm2streetsRoadSurface) : null } };
+  const trafficSignals = fs.existsSync(area.outputs.nativeTrafficSignals)
+    ? validateDocument(readJson(area.outputs.nativeTrafficSignals), fs.readFileSync(area.input, "utf8"))
+    : { schema: "native-traffic-signals/v1", provenance: "empty", assemblies: { type: "FeatureCollection", features: [] } };
+  const trafficRuntime = runtime(trafficSignals);
+  return { areaId: area.id, compiled: readCompiled(area), overrides: loadOverrides(area.outputs.nativeRoadOverrides), trafficSignals, trafficRuntime, comparison: readJson(path.join(nativeDir, "comparison.json")), layers: { nativeRoadSurface: readLayer(path.join(nativeDir, "layers", "road_surface.geojson")), edgeLines: readLayer(path.join(nativeDir, "layers", "edge_lines.geojson")), nativeSidewalkSurface: readLayer(path.join(nativeDir, "layers", "sidewalk_surface.geojson")), nativeIntersectionSurface: readLayer(path.join(nativeDir, "layers", "intersection_surface.geojson")), laneCenterlines: readLayer(path.join(nativeDir, "layers", "lane_centerlines.geojson")), laneSeparators: readLayer(path.join(nativeDir, "layers", "lane_separators.geojson")), centerLines: readLayer(path.join(nativeDir, "layers", "center_lines.geojson")), directionArrows: readLayer(path.join(nativeDir, "layers", "direction_arrows.geojson")), turnArrows: readLayer(path.join(nativeDir, "layers", "turn_arrows.geojson")), crosswalks: readLayer(path.join(nativeDir, "layers", "crosswalks.geojson")), vehicleStopLines: readLayer(path.join(nativeDir, "layers", "vehicle_stop_lines.geojson")), connectors: readLayer(path.join(nativeDir, "layers", "connectors.geojson")), osm2streetsRoadSurface: fs.existsSync(osm2streetsRoadSurface) ? readLayer(osm2streetsRoadSurface) : null } };
 }
 function readCompiled(area) { return readJson(path.join(area.outputs.nativeRoadDir, "compiled.json")); }
 function readJson(file) { return JSON.parse(fs.readFileSync(file, "utf8")); }

scripts/test-native-road.js

@@ -22,11 +22,49 @@ assert.equal(edited.provenance.widthMeters, "override:road-width");
 assert.equal(edited.sidewalkLeft, false);
 const geometry = compileGeometry(model);
 assert.equal(geometry.roadSurface.features.length, 2);
+assert.equal(compileGeometry(model, empty, { edgeLines: false }).edgeLines.features.length, 0);
 assert.ok(geometry.roadSurface.features.every((feature) => feature.geometry.coordinates[0].length >= 5));
 assert.equal(geometry.sidewalkSurface.features.length, 2);
 assert.ok(geometry.sidewalkSurface.features.every((feature) => feature.geometry.coordinates[0].length >= 5));
 assert.equal(geometry.laneCenterlines.features.length, model.roads.reduce((sum, road) => sum + road.laneCount, 0));
 assert.ok(geometry.laneSeparators.features.every((feature) => feature.geometry.type === "Polygon" && feature.properties.provenance === "native-road-lane-separator/v1"));
+const separator = geometry.laneSeparators.features[0];
+const separatorOverride = validateOverrides({ schema: "native-road-overrides/v1", overrides: [{ id: "separator-style", kind: "lane-separator-style", roadId: separator.properties.road_id, leftLaneIndex: separator.properties.left_lane_index, rightLaneIndex: separator.properties.right_lane_index, color: "yellow", pattern: "solid" }] }, model);
+const styledSeparators = compileGeometry(model, separatorOverride).laneSeparators.features.filter((feature) => feature.properties.road_id === separator.properties.road_id && feature.properties.left_lane_index === separator.properties.left_lane_index);
+assert.ok(styledSeparators.length > 0 && styledSeparators.every((feature) => feature.properties.effective_style === "yellow-solid"));
+assert.ok(geometry.centerLines.features.length > 0);
+assert.ok(geometry.centerLines.features.every((feature) => feature.geometry.type === "Polygon" && feature.properties.provenance === "native-road-center-line/v1" && feature.properties.dash_length_m === 2 && feature.properties.dash_gap_m === 2));
+for (const feature of geometry.centerLines.features) {
+  const ring = feature.geometry.coordinates[0];
+  const lengths = [distance(ring[0], ring[1]), distance(ring[1], ring[2])].sort((a, b) => a - b);
+  assert.ok(Math.abs(lengths[0] - .25) < .01 && Math.abs(lengths[1] - 2) < .01);
+  assert.ok(feature.properties.segment_id && feature.properties.directional_road_ids && feature.properties.osm_way_ids && feature.properties.placement_rule);
+}
+const centerLineOverride = validateOverrides({ schema: "native-road-overrides/v1", overrides: [{ id: "center-white-solid", kind: "center-line-style", segmentId: target.segmentId, color: "white", pattern: "solid" }] }, model);
+const styledCenterLines = compileGeometry(model, centerLineOverride).centerLines.features.filter((feature) => feature.properties.segment_id === target.segmentId);
+assert.ok(styledCenterLines.length > 0);
+assert.ok(styledCenterLines.every((feature) => feature.properties.color === "white" && feature.properties.pattern === "solid" && feature.properties.effective_style === "white-solid" && feature.properties.dash_gap_m === 0));
+const doubleCenterOverride = validateOverrides({ schema: "native-road-overrides/v1", overrides: [{ id: "center-double-yellow", kind: "center-line-style", segmentId: target.segmentId, color: "yellow", pattern: "solid", double: true }] }, model);
+const doubleCenterLines = compileGeometry(model, doubleCenterOverride).centerLines.features.filter((feature) => feature.properties.segment_id === target.segmentId);
+assert.equal(doubleCenterLines.length, styledCenterLines.length * 2);
+assert.ok(doubleCenterLines.every((feature) => feature.properties.double === true && feature.properties.effective_style === "double-yellow-solid"));
+assert.equal(new Set(doubleCenterLines.map((feature) => feature.properties.dash_index)).size, styledCenterLines.length);
+for (const dashIndex of new Set(doubleCenterLines.map((feature) => feature.properties.dash_index))) {
+  const pair = doubleCenterLines.filter((feature) => feature.properties.dash_index === dashIndex);
+  const centers = pair.map((feature) => feature.geometry.coordinates[0].slice(0, 4).reduce((sum, point) => [sum[0] + point[0] / 4, sum[1] + point[1] / 4], [0, 0]));
+  assert.ok(Math.hypot((centers[0][0] - centers[1][0]) * 96400, (centers[0][1] - centers[1][1]) * 111320) > .25);
+}
+assert.throws(() => validateOverrides({ schema: "native-road-overrides/v1", overrides: [{ id: "bad-double-center", kind: "center-line-style", segmentId: target.segmentId, color: "white", pattern: "solid", double: true }] }, model), /Invalid center line style override/);
+assert.throws(() => validateOverrides({ schema: "native-road-overrides/v1", overrides: [{ id: "bad-center", kind: "center-line-style", segmentId: target.segmentId, color: "blue", pattern: "solid" }] }, model), /Invalid center line style override/);
+const edgeLine = geometry.edgeLines.features[0];
+assert.ok(edgeLine && edgeLine.properties.effective_style === "white-solid");
+const twoWayEdgeLines = geometry.edgeLines.features.filter((feature) => feature.properties.road_id.includes("way/10"));
+assert.ok(twoWayEdgeLines.length > 0 && twoWayEdgeLines.every((feature) => feature.properties.side === "right"));
+const edgeOverride = validateOverrides({ schema: "native-road-overrides/v1", overrides: [{ id: "edge-yellow-dashed", kind: "edge-line-style", roadId: edgeLine.properties.road_id, side: edgeLine.properties.side, color: "yellow", pattern: "dashed" }] }, model);
+const styledEdgeLines = compileGeometry(model, edgeOverride).edgeLines.features.filter((feature) => feature.properties.road_id === edgeLine.properties.road_id && feature.properties.side === edgeLine.properties.side);
+assert.ok(styledEdgeLines.length > 1 && styledEdgeLines.every((feature) => feature.properties.effective_style === "yellow-dashed"));
+assert.throws(() => validateOverrides({ schema: "native-road-overrides/v1", overrides: [{ id: "bad-edge", kind: "edge-line-style", roadId: edgeLine.properties.road_id, side: "middle", color: "yellow", pattern: "solid" }] }, model), /Invalid edge line style override/);
+assert.throws(() => validateOverrides({ schema: "native-road-overrides/v1", overrides: [{ id: "missing-edge-road", kind: "edge-line-style", roadId: "road:way/missing:forward", side: "left", color: "yellow", pattern: "solid" }] }, model), /Invalid edge line style override/);
 assert.ok(geometry.directionArrows.features.every((feature) => feature.geometry.type === "Polygon" && feature.properties.provenance === "native-road-direction-arrow/v1" && feature.properties.placement_interval_meters === 32));
 assert.ok(geometry.turnArrows.features.every((feature) => feature.geometry.type === "Polygon" && feature.properties.provenance === "native-road-turn-arrow/v1"));
 assert.ok(geometry.connectors.features.length > 0);
@@ -36,20 +74,70 @@ assert.ok(geometry.movements.length >= geometry.connectors.features.length);
 assert.ok(geometry.movements.every((movement) => movement.id.startsWith("movement:") && movement.connectorId.startsWith("connector:")));
 assert.ok(geometry.movements.every((movement) => ["connector", "continuous", "deferred-too-long"].includes(movement.geometryStatus)));
 assert.ok(geometry.intersectionSurface.features.every((feature) => feature.properties.rule === "junction-shared-cutback/v3"));
-assert.ok(geometry.intersectionSurface.features.every((feature) => ["approach-envelope", "connector-convex-fallback"].includes(feature.properties.boundary_mode)));
+assert.ok(geometry.intersectionSurface.features.every((feature) => ["approach-envelope", "rounded-approach-envelope", "connector-convex-fallback"].includes(feature.properties.boundary_mode)));
 assert.ok(geometry.intersectionSurface.features.every((feature) => feature.properties.approach_area_m2 > 0 && feature.properties.surface_area_m2 > 0 && feature.properties.expansion_ratio >= 1));
 for (const feature of geometry.intersectionSurface.features.filter((item) => item.properties.boundary_mode === "connector-convex-fallback")) assert.ok(geometry.diagnostics.some((item) => item.subjectId === feature.properties.native_id && item.rule === "junction-connector-envelope-fallback"));
+const controlOsm = `<osm><node id="1" lon="114" lat="30"/><node id="2" lon="114.00080" lat="30"><tag k="highway" v="crossing"/><tag k="crossing:markings" v="zebra"/></node><node id="3" lon="114.001" lat="30"/><node id="4" lon="114.002" lat="30"><tag k="highway" v="crossing"/><tag k="crossing:markings" v="unmarked"/></node><node id="5" lon="114.0035" lat="30"><tag k="highway" v="crossing"/></node><node id="6" lon="114.004" lat="30"/><node id="7" lon="114.001" lat="30.001"/><way id="60"><nd ref="1"/><nd ref="2"/><nd ref="3"/><nd ref="4"/><tag k="highway" v="residential"/></way><way id="61"><nd ref="5"/><nd ref="6"/><tag k="highway" v="footway"/></way><way id="62"><nd ref="3"/><nd ref="7"/><tag k="highway" v="residential"/></way></osm>`;
+const controlGeometry = compileGeometry(compileRoadModel(controlOsm, empty));
+assert.equal(controlGeometry.crosswalks.features.length, 6);
+assert.equal(controlGeometry.vehicleStopLines.features.length, 1);
+assert.ok(controlGeometry.crosswalks.features.every((feature) => feature.properties.crossing_node_id === "2" && feature.properties.provenance === "native-road-crosswalk/v1"));
+assert.ok(controlGeometry.vehicleStopLines.features.every((feature) => feature.properties.crossing_node_id === "2" && feature.properties.provenance === "native-road-stop-line/v1"));
+assert.ok(controlGeometry.crosswalks.features.every((feature) => feature.properties.junction_inset_m > 0));
+assert.equal(controlGeometry.vehicleStopLines.features[0].properties.junction_inset_m, controlGeometry.crosswalks.features[0].properties.junction_inset_m);
+assert.ok(controlGeometry.diagnostics.some((item) => item.rule === "crossing-no-native-lane" && item.sourceIds.includes("5")));
+assert.ok(controlGeometry.centerLines.features.length > 0);
+assert.ok(controlGeometry.centerLines.features.every((dash) => ![...controlGeometry.crosswalks.features, ...controlGeometry.vehicleStopLines.features].some((control) => ringsOverlap(dash.geometry.coordinates[0], control.geometry.coordinates[0]))));
+const solidControlLines = compileGeometry(compileRoadModel(controlOsm, empty), { schema: "native-road-overrides/v1", overrides: [{ id: "solid-control", kind: "center-line-style", segmentId: controlGeometry.centerLines.features[0].properties.segment_id, color: "yellow", pattern: "solid" }] }).centerLines.features;
+assert.ok(solidControlLines.every((dash) => ![...controlGeometry.crosswalks.features, ...controlGeometry.vehicleStopLines.features].some((control) => ringsOverlap(dash.geometry.coordinates[0], control.geometry.coordinates[0]))));
+const arrowControlOsm = `<osm><node id="1" lon="114" lat="30"/><node id="2" lon="114.00095" lat="30"><tag k="highway" v="crossing"/><tag k="crossing:markings" v="zebra"/></node><node id="3" lon="114.001" lat="30"/><way id="63"><nd ref="1"/><nd ref="2"/><nd ref="3"/><tag k="highway" v="residential"/><tag k="oneway" v="yes"/><tag k="lanes" v="1"/><tag k="turn:lanes" v="through"/></way></osm>`;
+const arrowControlGeometry = compileGeometry(compileRoadModel(arrowControlOsm, empty));
+assert.ok(arrowControlGeometry.turnArrows.features.length > 0);
+assert.ok(arrowControlGeometry.turnArrows.features.every((feature) => feature.properties.placement_distance_meters > 6));
+assert.equal(arrowControlGeometry.centerLines.features.length, 0);
+const serviceCenterLineOsm = `<osm><node id="1" lon="114" lat="30"/><node id="2" lon="114.001" lat="30"/><way id="64"><nd ref="1"/><nd ref="2"/><tag k="highway" v="service"/></way></osm>`;
+assert.equal(compileGeometry(compileRoadModel(serviceCenterLineOsm, empty)).centerLines.features.length, 0);
 const crossOsm = `<osm><node id="1" lon="114" lat="30"/><node id="2" lon="114.001" lat="30"/><node id="3" lon="114.002" lat="30"/><node id="4" lon="114.001" lat="30.001"/><node id="5" lon="114.001" lat="29.999"/><way id="40"><nd ref="1"/><nd ref="2"/><tag k="highway" v="residential"/><tag k="sidewalk" v="both"/></way><way id="41"><nd ref="2"/><nd ref="3"/><tag k="highway" v="residential"/><tag k="sidewalk" v="both"/></way><way id="42"><nd ref="5"/><nd ref="2"/><tag k="highway" v="residential"/><tag k="sidewalk" v="both"/></way><way id="43"><nd ref="2"/><nd ref="4"/><tag k="highway" v="residential"/><tag k="sidewalk" v="both"/></way></osm>`;
 const crossCenter = [114.001, 30];
 const crossGeometry = compileGeometry(compileRoadModel(crossOsm, empty));
 assert.equal(crossGeometry.intersectionSurface.features.length, 1);
+assert.equal(crossGeometry.intersectionSurface.features[0].properties.boundary_mode, "rounded-approach-envelope");
+assert.ok(crossGeometry.intersectionSurface.features[0].geometry.coordinates[0].length > 9);
+const crossBoundary = crossGeometry.intersectionSurface.features[0].geometry.coordinates[0];
+const crossRadius = (point) => Math.hypot((point[0] - crossCenter[0]) * 96400, (point[1] - crossCenter[1]) * 111320);
+// The sampled tangent arc must cut inward from its old straight chord; an
+// outward-bowed control point leaks asphalt into the pedestrian corner.
+const firstCurveEnd = crossBoundary[8];
+assert.ok(crossRadius(crossBoundary[4]) < crossRadius([(crossBoundary[0][0] + firstCurveEnd[0]) / 2, (crossBoundary[0][1] + firstCurveEnd[1]) / 2]));
 assert.equal(crossGeometry.turnArrows.features.length, 0);
 assert.ok(crossGeometry.directionArrows.features.length > 0);
 assert.ok(crossGeometry.directionArrows.features.every((feature) => feature.properties.maneuver === "through" && feature.properties.provenance === "native-road-direction-arrow/v1"));
-assert.ok(crossGeometry.roadSurface.features.some((feature) => Math.min(...feature.geometry.coordinates[0].map((point) => Math.hypot((point[0] - crossCenter[0]) * 96400, (point[1] - crossCenter[1]) * 111320))) < 4));
+// Approach asphalt ends at the shared cutback; the rounded junction surface
+// exclusively owns the central road area so its boundary remains visible.
+assert.ok(crossGeometry.roadSurface.features.every((feature) => Math.min(...feature.geometry.coordinates[0].map((point) => Math.hypot((point[0] - crossCenter[0]) * 96400, (point[1] - crossCenter[1]) * 111320))) > 4));
 const exteriorRings = (geometry) => geometry.type === "Polygon" ? [geometry.coordinates[0]] : geometry.coordinates.map((polygon) => polygon[0]);
 assert.ok(crossGeometry.sidewalkSurface.features.every((feature) => Math.min(...exteriorRings(feature.geometry).flat().map((point) => Math.hypot((point[0] - crossCenter[0]) * 96400, (point[1] - crossCenter[1]) * 111320))) > 5));
-assert.equal(crossGeometry.sidewalkSurface.features.filter((feature) => feature.properties.kind === "corner").length, 4);
+const crossSidewalkCorners = crossGeometry.sidewalkSurface.features.filter((feature) => feature.properties.kind === "corner");
+assert.equal(crossSidewalkCorners.length, 4);
+// A rounded sidewalk corner must sample both the curb and outer boundaries.
+// The legacy wedge had five closing-ring points; two curved edges need more.
+assert.ok(crossSidewalkCorners.every((feature) => feature.geometry.coordinates[0].length > 9));
+assert.ok(crossSidewalkCorners.every((feature) => {
+  const ring = feature.geometry.coordinates[0];
+  const outerStart = ring[1];
+  const outerCurvePoint = ring[2];
+  const outerEnd = ring[(ring.length - 1) / 2];
+  const twiceArea = (outerEnd[0] - outerStart[0]) * (outerCurvePoint[1] - outerStart[1]) - (outerEnd[1] - outerStart[1]) * (outerCurvePoint[0] - outerStart[0]);
+  return Math.abs(twiceArea) > 1e-12;
+}));
+assert.ok(crossSidewalkCorners.every((feature) => {
+  const ring = feature.geometry.coordinates[0];
+  const curbStart = ring[10];
+  const curbCurvePoint = ring[11];
+  const curbEnd = ring[0];
+  const twiceArea = (curbEnd[0] - curbStart[0]) * (curbCurvePoint[1] - curbStart[1]) - (curbEnd[1] - curbStart[1]) * (curbCurvePoint[0] - curbStart[0]);
+  return Math.abs(twiceArea) > 1e-12;
+}));
 const sharedInteriorNodeOsm = `<osm><node id="1" lon="114" lat="30"/><node id="2" lon="114.001" lat="30"/><node id="3" lon="114.002" lat="30"/><node id="4" lon="114.001" lat="30.001"/><way id="50"><nd ref="1"/><nd ref="2"/><nd ref="3"/><tag k="highway" v="residential"/><tag k="sidewalk" v="both"/></way><way id="51"><nd ref="4"/><nd ref="2"/><tag k="highway" v="residential"/><tag k="sidewalk" v="both"/></way></osm>`;
 const sharedInteriorModel = compileRoadModel(sharedInteriorNodeOsm, empty);
 assert.equal(sharedInteriorModel.roads.length, 6);
@@ -60,7 +148,7 @@ assert.equal(sharedInteriorGeometry.intersectionSurface.features.length, 1);
 assert.equal(sharedInteriorGeometry.intersectionSurface.features[0].properties.osm_node_id, "2");
 assert.equal(sharedInteriorGeometry.intersectionSurface.features[0].properties.kind, "t");
 assert.ok(sharedInteriorGeometry.connectors.features.length >= 4);
-assert.ok(sharedInteriorGeometry.sidewalkSurface.features.some((feature) => feature.properties.kind === "corner" && /segment:way\/50\/1:.*->segment:way\/50\/2:/.test(feature.properties.native_id)));
+assert.ok(sharedInteriorGeometry.sidewalkSurface.features.some((feature) => feature.properties.kind === "continuation" && /segment:way\/50\/1:.*->segment:way\/50\/2:/.test(feature.properties.native_id)));
 const connection = initial.connections[0];
 assert.ok(initial.connections.every((item) => item.fromEndpointId.endsWith(":end") && item.toEndpointId.endsWith(":start")));
 assert.equal(initial.connections.length, new Set(initial.connections.map((item) => `${item.fromEndpointId}->${item.toEndpointId}`)).size);
@@ -101,13 +189,29 @@ try {
   const compiledArea = compileArea(config);
   assert.equal(compiledArea.result.areaId, "fresh");
   assert.ok(fs.existsSync(path.join(outputRoot, "fresh", "native-road", "compiled.json")));
+  const centerLineLayer = JSON.parse(fs.readFileSync(path.join(outputRoot, "fresh", "native-road", "layers", "center_lines.geojson"), "utf8"));
+  const edgeLineLayer = JSON.parse(fs.readFileSync(path.join(outputRoot, "fresh", "native-road", "layers", "edge_lines.geojson"), "utf8"));
+  assert.equal(centerLineLayer.type, "FeatureCollection");
+  assert.equal(centerLineLayer.features.length, compiledArea.comparison.nativeCenterLineFeatures);
+  assert.equal(edgeLineLayer.features.length, 0);
   assert.equal(compiledArea.comparison.schema, "native-road-comparison/v2");
   assert.equal(compiledArea.comparison.nativeRoadCount, compiledArea.result.model.roads.length);
   assert.equal(compiledArea.comparison.nativePublishedMovementCount, compiledArea.result.movements.filter((movement) => movement.geometryPublished).length);
+  assert.equal(compiledArea.comparison.nativeCrosswalkFeatures, 0);
+  assert.equal(compiledArea.comparison.nativeVehicleStopLineFeatures, 0);
   assert.equal(compiledArea.comparison.nativeApproachEnvelopeJunctions + compiledArea.comparison.nativeFallbackJunctions, compiledArea.comparison.nativeJunctionSurfaceFeatures);
   assert.ok(compiledArea.comparison.nativeMaxJunctionExpansionRatio >= 0);
   assert.equal(checkArea(config).ok, true);
 } finally {
   fs.rmSync(freshArea, { recursive: true, force: true });
 }
+
+function distance(a, b) {
+  return Math.hypot((b[0] - a[0]) * 111320 * Math.cos(a[1] * Math.PI / 180), (b[1] - a[1]) * 111320);
+}
+function ringsOverlap(first, second) {
+  const bounds = (ring) => [Math.min(...ring.map((point) => point[0])), Math.min(...ring.map((point) => point[1])), Math.max(...ring.map((point) => point[0])), Math.max(...ring.map((point) => point[1]))];
+  const a = bounds(first); const b = bounds(second);
+  return !(a[0] > b[2] || a[2] < b[0] || a[1] > b[3] || a[3] < b[1]);
+}
 console.log("native road tests passed");

scripts/test-road-workbench.js

@@ -27,5 +27,54 @@ assert.match(app, /外缘扩张倍率/);
 assert.match(app, /最大外缘扩张/);
 assert.match(app, /道路方向箭头/);
 assert.match(app, /native-road-direction-arrow\/v1/);
+assert.match(app, /data-layer="centerLines" type="checkbox" checked> 道路中心线/);
+assert.match(app, /centerLines: new VectorLayer/);
+assert.match(app, /state\.layers\.centerLines/);
+assert.match(app, /native-road-center-line\/v1/);
+assert.match(app, /lane-separator-style/);
+assert.match(app, /车道分隔线/);
+assert.match(app, /center-line-style/);
+assert.match(app, /centerLineStyleInput\.onchange = stageSelectedCenterLineStyle/);
+assert.match(html, /道路中心线样式/);
+assert.match(html, /white-solid/);
+assert.match(app, /double-yellow-solid/);
+assert.match(app, /const double = parts\[0\] === "double"/);
+assert.match(app, /function selectEdgeLine\(feature\)/);
+assert.match(app, /edge-line-style/);
+assert.match(app, /道路外缘线样式/);
+assert.match(app, /data-layer="edgeLines" type="checkbox"> 道路外缘线/);
+assert.match(app, /edgeLines: new VectorLayer\(\{ source: source\(\), visible: false/);
+assert.match(html, /id="marking-style-heading"/);
+assert.match(app, /data-layer="controls" type="checkbox" checked> 斑马线与停止线/);
+assert.match(app, /controls: new VectorLayer/);
+assert.match(app, /state\.layers\.crosswalks/);
+assert.match(app, /state\.layers\.vehicleStopLines/);
+assert.match(app, /native-road-crosswalk\/v1/);
+assert.match(app, /native-road-stop-line\/v1/);
 assert.match(app, /term\.textContent = label; detail\.textContent = value; summary\.append\(term, detail\)/);
+assert.match(app, /原生红绿灯/);
+assert.match(app, /function selectSignal\(feature\)/);
+assert.match(app, /\/api\/traffic-signals/);
+assert.match(app, /从 OSM 生成缺失信号灯/);
+assert.match(app, /data-layer="signals" type="checkbox" checked> 红绿灯设施/);
+assert.match(app, /红绿灯设施/);
+assert.match(app, /signalAssemblyStyle/);
+assert.match(app, /signal_component: "mast"/);
+assert.match(app, /signal_component: "face"/);
+assert.match(app, /signal_component: "head"/);
+assert.match(app, /faceHeadingDegrees/);
+assert.match(app, /横杆方向（度）/);
+assert.match(app, /横杆长度（米）/);
+assert.match(app, /灯面朝向（度）/);
+assert.match(app, /检查信号灯<select name="signal-picker">/);
+assert.match(app, /signalPicker\.onchange/);
+assert.match(app, /map\.getView\(\)\.fit\(\[x - 25, y - 25, x \+ 25, y \+ 25\]/);
+assert.match(app, /fromLonLat/);
+assert.match(app, /armFeatures\.push\(new Feature/);
+assert.match(app, /headFeatures\.push\(new Feature/);
+assert.match(app, /faceFeatures\.push\(new Feature/);
+const server = fs.readFileSync(path.join(__dirname, "road-workbench.js"), "utf8");
+assert.match(server, /\/api\/traffic-signals\/generate/);
+assert.doesNotMatch(app, /导入 QGIS|导出 QGIS/);
+assert.doesNotMatch(server, /traffic-signals\/(?:import|export)-qgis/);
 console.log("road workbench tests passed");

scripts/test-traffic-signals.js

@@ -47,6 +47,9 @@ const originalStop = [first.properties.stop_lon, first.properties.stop_lat];
 first.geometry.coordinates[0] += 0.0001;
 first.properties.display_id = "A-01";
 first.properties.heading_deg = 42;
+first.properties.mast_heading_deg = 17;
+first.properties.mast_reach_m = 8.5;
+first.properties.face_heading_deg = 203;
 first.properties.z_offset_m = 1.25;
 const runtime = buildTrafficSignalsFromFeatures(edited);
 assert.equal(new Set(runtime.signals.map((signal) => signal.nodeKey)).size, runtime.signals.length);
@@ -61,9 +64,22 @@ const changed = runtime.signals.find((signal) => signal.id === first.properties.
 assert.equal(changed.displayId, "A-01");
 assert.equal(changed.longitude, first.geometry.coordinates[0]);
 assert.equal(changed.headingDegrees, 42);
+assert.equal(changed.mastHeadingDegrees, 17);
+assert.equal(changed.faceHeadingDegrees, 203);
+assert.equal(changed.mastReachMeters, 8.5);
 assert.deepEqual([changed.stopLongitude, changed.stopLatitude], originalStop, "moving a pole preserves the stop point");
 assert.equal(changed.pose.pole.height, 1.25);
 assert.equal(changed.pose.arm.from.height, 7.5);
+assert.ok(changed.pose.arm.to.latitude > changed.pose.arm.from.latitude, "mast direction controls the arm independently");
+assert.equal(changed.pose.head.faceHeadingDegrees, 203, "face direction is independent from mast direction");
+
+const legacy = structuredClone(cross);
+legacy.features[0].properties.heading_deg = 42;
+delete legacy.features[0].properties.mast_heading_deg;
+delete legacy.features[0].properties.face_heading_deg;
+const migrated = validateTrafficSignalFeatures(legacy).features[0].properties;
+assert.equal(migrated.mast_heading_deg, 312, "legacy heading preserves the historic mast direction");
+assert.equal(migrated.face_heading_deg, 222, "legacy heading preserves the historic face direction");
 
 edited.features[1].properties.enabled = "0";
 assert.equal(buildTrafficSignalsFromFeatures(edited).signals.length, 3, "disabled assemblies are omitted");
@@ -100,7 +116,7 @@ for (const disabledValue of [false, 0, "0", "false", "no"]) {
   disabled.features[0].properties.enabled = disabledValue;
   assert.equal(buildTrafficSignalsFromFeatures(disabled).signals.length, 3);
 }
-for (const key of ["heading_deg", "phase_group", "stop_lon", "stop_lat", "z_offset_m"]) {
+for (const key of ["phase_group", "stop_lon", "stop_lat", "z_offset_m"]) {
   const missingNumber = structuredClone(cross);
   missingNumber.features[0].properties[key] = null;
   assert.throws(
@@ -109,5 +125,8 @@ for (const key of ["heading_deg", "phase_group", "stop_lon", "stop_lat", "z_offs
     `${key} must not silently coerce null to zero`,
   );
 }
+const missingDirections = structuredClone(cross);
+for (const key of ["heading_deg", "mast_heading_deg", "face_heading_deg"]) missingDirections.features[0].properties[key] = null;
+assert.throws(() => validateTrafficSignalFeatures(missingDirections), /missing mast_heading_deg/);
 
 console.log("Traffic signal tests passed.");

scripts/workbench/app.js

@@ -13,6 +13,7 @@ import CircleStyle from "/vendor/ol/style/Circle.js";
 import RegularShape from "/vendor/ol/style/RegularShape.js";
 import Select from "/vendor/ol/interaction/Select.js";
 import { click } from "/vendor/ol/events/condition.js";
+import { fromLonLat } from "/vendor/ol/proj.js";
 
 const geojson = new GeoJSON();
 const areaLabel = document.querySelector("#area");
@@ -29,6 +30,12 @@ const widthInput = document.querySelector("#width");
 const lanesInput = document.querySelector("#lanes");
 const leftInput = document.querySelector("#left");
 const rightInput = document.querySelector("#right");
+const centerLineForm = document.querySelector("#center-line-form");
+const centerLineSegment = document.querySelector("#center-line-segment");
+const markingStyleHeading = document.querySelector("#marking-style-heading");
+const centerLineStyleInput = document.querySelector("#center-line-style");
+const doubleYellowOption = document.createElement("option");
+doubleYellowOption.value = "double-yellow-solid"; doubleYellowOption.textContent = "双黄实线"; centerLineStyleInput.append(doubleYellowOption);
 const evidence = document.querySelector("#evidence");
 const diagnostics = document.querySelector("#diagnostics");
 const diagnosticFilters = document.querySelector("#diagnostic-filters");
@@ -45,7 +52,15 @@ const directionArrowsToggle = document.createElement("label");
 directionArrowsToggle.innerHTML = '<input data-layer="directionArrows" type="checkbox" checked> 道路方向箭头';
 const markingsToggle = document.createElement("label");
 markingsToggle.innerHTML = '<input data-layer="markings" type="checkbox" checked> 车道分隔线与路口转向箭头';
-document.querySelector('[data-layer="lanes"]').closest("label").after(directionArrowsToggle, markingsToggle);
+const centerLinesToggle = document.createElement("label");
+centerLinesToggle.innerHTML = '<input data-layer="centerLines" type="checkbox" checked> 道路中心线';
+const edgeLinesToggle = document.createElement("label");
+edgeLinesToggle.innerHTML = '<input data-layer="edgeLines" type="checkbox"> 道路外缘线';
+const controlsToggle = document.createElement("label");
+controlsToggle.innerHTML = '<input data-layer="controls" type="checkbox" checked> 斑马线与停止线';
+const signalsToggle = document.createElement("label");
+signalsToggle.innerHTML = '<input data-layer="signals" type="checkbox" checked> 红绿灯设施';
+document.querySelector('[data-layer="lanes"]').closest("label").after(directionArrowsToggle, markingsToggle, centerLinesToggle, edgeLinesToggle, controlsToggle, signalsToggle);
 
 let state;
 let selectedRoad = null;
@@ -55,25 +70,77 @@ let staged = [];
 let manualFromEndpoint = null;
 let diagnosticFilter = "all";
 let scenePreview = false;
+let selectedCenterLineSegment = null;
+let selectedLaneSeparator = null;
+let selectedEdgeLine = null;
+let selectedSignal = null;
+const signalPanel = document.createElement("section");
+signalPanel.innerHTML = '<hr><h2>原生红绿灯</h2><button type="button" data-signal="generate">从 OSM 生成缺失信号灯</button><label>检查信号灯<select name="signal-picker"><option value="">选择设施</option></select></label><form hidden><output></output><label>灯杆经度<input name="lon" type="number" min="-180" max="180" step="0.000001"></label><label>灯杆纬度<input name="lat" type="number" min="-90" max="90" step="0.000001"></label><label>横杆方向（度）<input name="mastHeading" type="number" min="0" max="360" step="1"></label><label>横杆长度（米）<input name="mastReach" type="number" min="0.1" max="30" step="0.1"></label><label>灯面朝向（度）<input name="faceHeading" type="number" min="0" max="360" step="1"></label><label>相位组<input name="phase" type="number" min="0" max="1" step="1"></label><label><input name="enabled" type="checkbox"> 启用</label><button type="submit">保存信号灯</button><button type="button" data-signal="delete">删除信号灯</button></form>';
+document.querySelector(".inspector").insertBefore(signalPanel, document.querySelector(".inspector details"));
+const signalForm = signalPanel.querySelector("form");
+const signalOutput = signalForm.querySelector("output");
+const signalPicker = signalPanel.querySelector('[name="signal-picker"]');
 const source = () => new VectorSource();
 const layers = {
   reference: new VectorLayer({ source: source(), visible: false, style: new Style({ fill: new Fill({ color: "rgba(123, 140, 148, .28)" }), stroke: new Stroke({ color: "#8999a0", width: 1 }) }) }),
   native: new VectorLayer({ source: source(), style: nativeSurfaceStyle }),
+  edgeLines: new VectorLayer({ source: source(), visible: false, style: markingStyle }),
   sidewalks: new VectorLayer({ source: source(), style: sidewalkSurfaceStyle }),
   osm: new VectorLayer({ source: source(), style: (feature) => new Style({ stroke: new Stroke({ color: feature.get("road_id") === selectedRoad?.id ? "#006e91" : "#263630", width: feature.get("road_id") === selectedRoad?.id ? 5 : 2 }) }) }),
   lanes: new VectorLayer({ source: source(), style: laneStyle }),
   directionArrows: new VectorLayer({ source: source(), style: markingStyle }),
   markings: new VectorLayer({ source: source(), style: markingStyle }),
+  centerLines: new VectorLayer({ source: source(), style: centerLineStyle }),
+  controls: new VectorLayer({ source: source(), style: markingStyle }),
+  signals: new VectorLayer({ source: source(), style: signalAssemblyStyle, zIndex: 30 }),
   osmDirection: new VectorLayer({ source: source(), style: (feature) => new Style({ image: new RegularShape({ points: 3, radius: 9, rotation: feature.get("rotation"), fill: new Fill({ color: "#006e91" }), stroke: new Stroke({ color: "#fff", width: 1.5 }) }) }), zIndex: 11 }),
   connectors: new VectorLayer({ source: source(), style: (feature) => effectiveConnectorEnabled(feature.getProperties()) ? new Style({ stroke: new Stroke({ color: roadIdFromLane(feature.get("from_lane_id")) === selectedRoad?.id ? "#d1226f" : "#ad3a76", width: roadIdFromLane(feature.get("from_lane_id")) === selectedRoad?.id ? 4 : 2, lineDash: [7, 5] }) }) : null }),
   diagnostics: new VectorLayer({ source: source(), style: (feature) => new Style({ image: new CircleStyle({ radius: 6, fill: new Fill({ color: feature.get("severity") === "error" ? "#bf3b2e" : "#d49318" }), stroke: new Stroke({ color: "#fff", width: 1 }) }) }) }),
   selectedRoad: new VectorLayer({ source: source(), style: new Style({ stroke: new Stroke({ color: "#00a5cf", width: 8 }) }), zIndex: 10 }),
   selectedMovement: new VectorLayer({ source: source(), style: new Style({ stroke: new Stroke({ color: "#f0b323", width: 6 }) }), zIndex: 12 }),
 };
-const map = new Map({ target: "map", layers: [layers.reference, layers.native, layers.sidewalks, layers.osm, layers.lanes, layers.directionArrows, layers.markings, layers.connectors, layers.diagnostics, layers.selectedRoad, layers.osmDirection, layers.selectedMovement], view: new View({ center: [0, 0], zoom: 2 }) });
-const select = new Select({ condition: click, layers: (layer) => manualFromEndpoint ? layer === layers.osm : [layers.osm, layers.lanes, layers.directionArrows, layers.markings, layers.connectors, layers.native, layers.diagnostics].includes(layer), hitTolerance: 8, style: new Style({ stroke: new Stroke({ color: "#005e89", width: 5 }), fill: new Fill({ color: "rgba(0, 94, 137, .18)" }) }) });
+const map = new Map({ target: "map", layers: [layers.reference, layers.native, layers.edgeLines, layers.sidewalks, layers.osm, layers.lanes, layers.directionArrows, layers.markings, layers.centerLines, layers.controls, layers.signals, layers.connectors, layers.diagnostics, layers.selectedRoad, layers.osmDirection, layers.selectedMovement], view: new View({ center: [0, 0], zoom: 2 }) });
+const select = new Select({ condition: click, layers: (layer) => manualFromEndpoint ? layer === layers.osm : [layers.osm, layers.lanes, layers.directionArrows, layers.markings, layers.centerLines, layers.edgeLines, layers.controls, layers.signals, layers.connectors, layers.native, layers.diagnostics].includes(layer), hitTolerance: 12, style: null });
 map.addInteraction(select);
-select.on("select", ({ selected }) => { const feature = selected[0]; if (!feature) return; if (manualFromEndpoint) return chooseManualTarget(roadForFeature(feature)); const junction = junctionForFeature(feature); if (junction) return selectJunction(junction); const marking = feature.get("provenance")?.startsWith("native-road-"); if (marking) { const road = roadForFeature(feature); const directionArrow = feature.get("provenance") === "native-road-direction-arrow/v1"; const turnArrow = feature.get("provenance") === "native-road-turn-arrow/v1"; const markingType = directionArrow ? "道路方向箭头" : turnArrow ? "路口转向箭头" : "车道分隔线"; selectRoad(road); evidence.textContent = JSON.stringify({ 标线类型: markingType, OSM道路: feature.get("osm_way_ids"), 方向: feature.get("direction"), 车道: feature.get("lane_index") || `${feature.get("left_lane_index")} 与 ${feature.get("right_lane_index")} 之间`, 转向: turnArrow ? feature.get("maneuver") : null, 道路内距离米: feature.get("distance_along_lane_meters") || null, 路口前距离米: feature.get("placement_distance_meters") || null, 来源: feature.get("provenance") }, null, 2); return message(`已选中${markingType}`); } const movement = state.compiled.movements?.find((item) => item.id === feature.get("movement_id")) || null; selectRoad(roadForFeature(feature), undefined, movement); });
+select.on("select", ({ selected }) => {
+  const feature = selected[0];
+  if (!feature) return;
+  if (feature.get("signal_uid")) return selectSignal(poleFeatureForSignal(feature.get("signal_uid")) || feature);
+  if (manualFromEndpoint) return chooseManualTarget(roadForFeature(feature));
+  const junction = junctionForFeature(feature);
+  if (junction) return selectJunction(junction);
+  const provenance = feature.get("provenance");
+  if (provenance?.startsWith("native-road-")) {
+    const road = roadForFeature(feature);
+    const directionArrow = provenance === "native-road-direction-arrow/v1";
+    const turnArrow = provenance === "native-road-turn-arrow/v1";
+    const centerLine = provenance === "native-road-center-line/v1";
+    const edgeLine = provenance === "native-road-edge-line/v1";
+    const crosswalk = provenance === "native-road-crosswalk/v1";
+    const stopLine = provenance === "native-road-stop-line/v1";
+    const markingType = centerLine ? "道路中心线" : edgeLine ? "道路外缘线" : crosswalk ? "斑马线" : stopLine ? "停止线" : directionArrow ? "道路方向箭头" : turnArrow ? "路口转向箭头" : "车道分隔线";
+    selectRoad(road);
+    if (centerLine) selectCenterLine(feature); else if (edgeLine) selectEdgeLine(feature); else if (provenance === "native-road-lane-separator/v1") selectLaneSeparator(feature); else clearCenterLineSelection();
+    evidence.textContent = JSON.stringify({
+      标线类型: markingType,
+      人行横道节点: crosswalk || stopLine ? feature.get("crossing_node_id") : null,
+      OSM道路: feature.get("osm_way_ids"),
+      原生道路: feature.get("road_id"),
+      道路段: centerLine ? feature.get("segment_id") : null,
+      方向: feature.get("direction"),
+      车道: feature.get("lane_id") || feature.get("lane_index") || `${feature.get("left_lane_index")} 与 ${feature.get("right_lane_index")} 之间`,
+      转向: turnArrow ? feature.get("maneuver") : null,
+      样式: centerLine || edgeLine || provenance === "native-road-lane-separator/v1" ? feature.get("effective_style") : null,
+      放置方法: feature.get("placement_method") || null,
+      道路内距离米: feature.get("distance_along_lane_meters") || null,
+      路口前距离米: feature.get("placement_distance_meters") || null,
+      来源: provenance,
+    }, null, 2);
+    return message(`已选中${markingType}`);
+  }
+  const movement = state.compiled.movements?.find((item) => item.id === feature.get("movement_id")) || null;
+  selectRoad(roadForFeature(feature), undefined, movement);
+});
 map.on("pointermove", (event) => { map.getTargetElement().style.cursor = map.hasFeatureAtPixel(event.pixel, { hitTolerance: 8 }) ? "pointer" : ""; });
 
 function message(text) { status.textContent = text; }
@@ -89,7 +156,9 @@ function roadIdFromLane(laneId) { return typeof laneId === "string" ? laneId.sli
 function laneIndex(laneId) { return Number(String(laneId).split(":").at(-1)); }
 function lanePositionLabel(road, index) { return road?.laneCount === 1 ? "唯一车道" : `左起第 ${index} 车道`; }
 function laneStyle(feature) { const selected = feature.get("road_id") === selectedRoad?.id; return new Style({ stroke: new Stroke({ color: selected ? "#006e91" : "#f5f6ee", width: selected ? 3 : 1.3, lineDash: [5, 4] }) }); }
-function markingStyle() { return new Style({ fill: new Fill({ color: "#f5f6ee" }), stroke: new Stroke({ color: "#d9dacf", width: 1 }) }); }
+function markingStyle(feature) { const yellow = feature?.get("color") === "yellow"; return new Style({ fill: new Fill({ color: yellow ? "#f5be2a" : "#f5f6ee" }), stroke: new Stroke({ color: yellow ? "#d29d16" : "#d9dacf", width: 1 }) }); }
+function signalAssemblyStyle(feature) { const component = feature.get("signal_component"); if (component === "mast") return [new Style({ stroke: new Stroke({ color: "#fff", width: 9 }) }), new Style({ stroke: new Stroke({ color: "#007f99", width: 5 }) })]; if (component === "face") return [new Style({ stroke: new Stroke({ color: "#fff", width: 7 }) }), new Style({ stroke: new Stroke({ color: "#df2435", width: 3 }) })]; if (component === "head") { const heading = Number(feature.get("face_heading_deg")) || 0; return new Style({ image: new RegularShape({ points: 3, radius: 8, rotation: heading * Math.PI / 180, fill: new Fill({ color: "#df2435" }), stroke: new Stroke({ color: "#fff", width: 2 }) }) }); } return new Style({ image: new RegularShape({ points: 4, radius: 6, angle: Math.PI / 4, fill: new Fill({ color: "#263630" }), stroke: new Stroke({ color: "#fff", width: 2 }) }) }); }
+function centerLineStyle(feature) { const white = feature.get("color") === "white"; const color = white ? "#faf9ee" : "#f5be2a"; return new Style({ fill: new Fill({ color }), stroke: new Stroke({ color: feature.get("pattern") === "solid" ? color : white ? "#aeb0aa" : "#d29d16", width: feature.get("pattern") === "solid" ? .25 : .8 }) }); }
 function nativeSurfaceStyle(feature) {
   // Split road features meet at OSM junction nodes. Their per-feature outlines
   // are editing aids, not physical seams, so scene mode must render fills only.
@@ -122,8 +191,12 @@ function updateSources() {
   layers.sidewalks.getSource().clear(); layers.sidewalks.getSource().addFeatures(readFeatures(state.layers.nativeSidewalkSurface));
   layers.osm.getSource().clear(); layers.osm.getSource().addFeatures(rawRoadFeatures());
   layers.lanes.getSource().clear(); layers.lanes.getSource().addFeatures(readFeatures(state.layers.laneCenterlines));
+  layers.edgeLines.getSource().clear(); layers.edgeLines.getSource().addFeatures(readFeatures(state.layers.edgeLines));
   layers.directionArrows.getSource().clear(); layers.directionArrows.getSource().addFeatures(readFeatures(state.layers.directionArrows));
   layers.markings.getSource().clear(); layers.markings.getSource().addFeatures([...readFeatures(state.layers.laneSeparators), ...readFeatures(state.layers.turnArrows)]);
+  layers.centerLines.getSource().clear(); layers.centerLines.getSource().addFeatures(readFeatures(state.layers.centerLines));
+  layers.controls.getSource().clear(); layers.controls.getSource().addFeatures([...readFeatures(state.layers.crosswalks), ...readFeatures(state.layers.vehicleStopLines)]);
+  const signalFeatures = readFeatures(state.trafficSignals?.assemblies || { type: "FeatureCollection", features: [] }); const armFeatures = []; const faceFeatures = []; const headFeatures = []; for (const signal of state.trafficRuntime?.signals || []) { const arm = signal.pose?.arm; const head = signal.pose?.head; if (!arm || !head) continue; const properties = { signal_uid: signal.id }; const headPoint = fromLonLat([head.longitude, head.latitude]); const radians = Number(head.faceHeadingDegrees) * Math.PI / 180; const faceEnd = [headPoint[0] + Math.sin(radians) * 2.5, headPoint[1] + Math.cos(radians) * 2.5]; armFeatures.push(new Feature({ geometry: new LineString([fromLonLat([arm.from.longitude, arm.from.latitude]), fromLonLat([arm.to.longitude, arm.to.latitude])]), signal_component: "mast", ...properties })); faceFeatures.push(new Feature({ geometry: new LineString([headPoint, faceEnd]), signal_component: "face", ...properties })); headFeatures.push(new Feature({ geometry: new Point(faceEnd), signal_component: "head", face_heading_deg: head.faceHeadingDegrees, ...properties })); } layers.signals.getSource().clear(); layers.signals.getSource().addFeatures([...armFeatures, ...faceFeatures, ...signalFeatures, ...headFeatures]); const pickerValue = signalPicker.value; signalPicker.replaceChildren(new Option("选择设施", "")); signalFeatures.forEach((feature) => signalPicker.add(new Option(feature.get("display_id") || feature.get("signal_uid"), feature.get("signal_uid")))); signalPicker.value = pickerValue;
   layers.connectors.getSource().clear(); layers.connectors.getSource().addFeatures(readFeatures(state.layers.connectors));
   layers.diagnostics.getSource().clear(); layers.diagnostics.getSource().addFeatures(readFeatures({ type: "FeatureCollection", features: state.compiled.diagnostics.filter((item) => item.geometry).map(({ geometry, ...properties }) => ({ type: "Feature", properties, geometry })) }));
   const extent = layers.osm.getSource().getExtent(); if (Number.isFinite(extent[0])) map.getView().fit(extent, { padding: [48, 48, 48, 48], maxZoom: 19 });
@@ -150,6 +223,23 @@ function selectJunction(feature) {
   junctionDetail.textContent = JSON.stringify({ OSM节点: properties.osm_node_id, 类型: properties.kind === "t" ? "T字路口" : "十字路口", 参与方向道路: roads.map((road) => ({ 道路: roadLabel(road), OSM道路: road.osmWayIds, 节点顺序: road.sourceNodeIds })), 构面规则: properties.rule, 边界策略: properties.boundary_mode, 基础截面面积平方米: properties.approach_area_m2, 最终路口面积平方米: properties.surface_area_m2, 外缘扩张倍率: properties.expansion_ratio, 路口退让距离米: properties.cutback_m, 行驶动作数: properties.movement_count, 已绘制连接数: properties.connector_count }, null, 2);
   message(`已选中路口：OSM 节点 ${properties.osm_node_id}`);
 }
+function selectSignal(feature) {
+  selectedSignal = feature.get("signal_uid"); const p = feature.getProperties(); signalPicker.value = selectedSignal;
+  const [x, y] = feature.getGeometry().getCoordinates();
+  map.getView().fit([x - 25, y - 25, x + 25, y + 25], { padding: [80, 80, 80, 360], maxZoom: 22, duration: 250 });
+  signalForm.hidden = false; signalOutput.textContent = `${p.display_id || p.signal_uid}（${p.signal_uid}）`;
+  signalForm.lon.value = feature.getGeometry().clone().transform("EPSG:3857", "EPSG:4326").getCoordinates()[0];
+  signalForm.lat.value = feature.getGeometry().clone().transform("EPSG:3857", "EPSG:4326").getCoordinates()[1];
+  signalForm.mastHeading.value = p.mast_heading_deg; signalForm.mastReach.value = p.mast_reach_m; signalForm.faceHeading.value = p.face_heading_deg; signalForm.phase.value = p.phase_group; signalForm.enabled.checked = p.enabled;
+  evidence.textContent = JSON.stringify({ 信号灯: p.signal_uid, 控制节点: p.control_id, 路口方向: p.approach_id, 来源: state.trafficSignals.provenance }, null, 2); message("已选中原生红绿灯");
+}
+function poleFeatureForSignal(signalUid) { return layers.signals.getSource().getFeatures().find((item) => item.get("signal_uid") === signalUid && !item.get("signal_component")); }
+async function saveSignals(document) { const response = await fetch("/api/traffic-signals", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(document) }); const result = await response.json(); if (!result.ok) throw new Error(result.error); state.trafficSignals = result.trafficSignals; state.trafficRuntime = result.runtime; updateSources(); renderSummary(); }
+function signalDocumentWithChange(change) { const document = structuredClone(state.trafficSignals); document.assemblies.features = change(document.assemblies.features); return document; }
+signalForm.onsubmit = async (event) => { event.preventDefault(); try { await saveSignals(signalDocumentWithChange((features) => features.map((feature) => feature.properties.signal_uid !== selectedSignal ? feature : { ...feature, geometry: { type: "Point", coordinates: [Number(signalForm.lon.value), Number(signalForm.lat.value)] }, properties: { ...feature.properties, mast_heading_deg: Number(signalForm.mastHeading.value), mast_reach_m: Number(signalForm.mastReach.value), face_heading_deg: Number(signalForm.faceHeading.value), phase_group: Number(signalForm.phase.value), enabled: signalForm.enabled.checked } }))); message("红绿灯已保存"); } catch (error) { message(error.message); } };
+signalPanel.querySelector('[data-signal="delete"]').onclick = async () => { try { await saveSignals(signalDocumentWithChange((features) => features.filter((feature) => feature.properties.signal_uid !== selectedSignal))); signalForm.hidden = true; selectedSignal = null; message("红绿灯已删除"); } catch (error) { message(error.message); } };
+signalPanel.querySelector('[data-signal="generate"]').onclick = async () => { try { const response = await fetch("/api/traffic-signals/generate", { method: "POST" }); const result = await response.json(); if (!result.ok) throw new Error(result.error); state.trafficSignals = result.trafficSignals; state.trafficRuntime = result.runtime; updateSources(); message("已补充 OSM 信号灯"); } catch (error) { message(error.message); } };
+signalPicker.onchange = () => { const feature = poleFeatureForSignal(signalPicker.value); if (feature) selectSignal(feature); };
 function turnLabel(turn) { return { left: "左转", through: "直行", right: "右转", uturn: "掉头" }[turn] || turn; }
 function renderSelectedMovement() { selectedMovementPanel.hidden = !selectedMovement; if (!selectedMovement) return; const targetRoad = state.compiled.model.roads.find((road) => road.id === selectedMovement.toRoadId); const geometry = selectedMovement.geometryStatus === "connector" ? "已绘制路径" : selectedMovement.geometryStatus === "continuous" ? "节点连续" : "路径过长未绘制"; movementDetail.textContent = `${turnLabel(selectedMovement.turn)}：${lanePositionLabel(selectedRoad, laneIndex(selectedMovement.fromLaneId))} → ${lanePositionLabel(targetRoad, laneIndex(selectedMovement.toLaneId))}\n目标：${roadLabel(targetRoad)}（${osmDirectionLabel(targetRoad)}）\n来源端点：${selectedRoad.sourceNodeIds.at(-1)}；目标端点：${targetRoad.sourceNodeIds[0]}\n路口节点：${selectedMovement.nodeId}\n状态：${geometry}\n来源：${selectedMovement.provenance}`; }
 function renderDirectionSwitch(road) {
@@ -174,13 +264,48 @@ addConnectionButton.onclick = () => { const endpoint = endpointFor(selectedRoad,
 function focusDiagnostic(item) { const feature = layers.diagnostics.getSource().getFeatures().find((candidate) => candidate.get("id") === item.id); if (feature) map.getView().fit(feature.getGeometry().getExtent(), { padding: [80, 80, 80, 360], maxZoom: 18, duration: 250 }); const junction = layers.native.getSource().getFeatures().find((candidate) => candidate.get("native_id") === item.subjectId); if (junction) return selectJunction(junction); selectRoad(state.compiled.model.roads.find((road) => road.id === item.subjectId), `已定位：${item.message}`); }
 function diagnosticLabel(item) { const road = state.compiled.model.roads.find((candidate) => candidate.id === item.subjectId); if (item.rule !== "unconnected-interior-road-end" || !road) return item.message; const candidateCount = item.manualCandidates?.length || 0; return `${roadLabel(road)}（${osmDirectionLabel(road)}，节点 ${item.sourceIds[0]}）：内部端点未连接${candidateCount ? `，附近有 ${candidateCount} 个可手工连接候选` : ""}`; }
 function renderDiagnostics() { const all = state.compiled.diagnostics.filter((diagnostic) => diagnostic.rule !== "ordinary-junction-surface"); const counts = { all: all.length, candidates: all.filter((item) => item.manualCandidates?.length).length, other: all.filter((item) => !item.manualCandidates?.length).length }; for (const button of diagnosticFilters.querySelectorAll("button")) { const filter = button.dataset.diagnosticFilter; button.classList.toggle("active", filter === diagnosticFilter); button.textContent = `${filter === "all" ? "全部" : filter === "candidates" ? "可连接" : "其他"}（${counts[filter]}）`; } const visible = all.filter((item) => diagnosticFilter === "all" || diagnosticFilter === "candidates" ? Boolean(item.manualCandidates?.length) : !item.manualCandidates?.length).sort((a, b) => (b.manualCandidates?.length || 0) - (a.manualCandidates?.length || 0)); diagnostics.innerHTML = ""; for (const item of visible) { const button = document.createElement("button"); button.textContent = diagnosticLabel(item); button.onclick = () => focusDiagnostic(item); diagnostics.append(button); } }
-function renderSummary() { const comparison = state.comparison; const rows = [["方向道路", comparison.nativeRoadCount], ["路缘与步行带", comparison.nativeSidewalkSurfaceFeatures], ["路口面", comparison.nativeJunctionSurfaceFeatures], ["普通构面路口", comparison.nativeApproachEnvelopeJunctions], ["兜底构面路口", comparison.nativeFallbackJunctions], ["最大外缘扩张", comparison.nativeMaxJunctionExpansionRatio], ["道路方向箭头", comparison.nativeDirectionArrowFeatures], ["路口转向箭头", comparison.nativeTurnArrowFeatures], ["行驶动作", comparison.nativeMovementCount], ["已绘制路径", comparison.nativePublishedMovementCount], ["内部断头", comparison.unconnectedInteriorRoadEnds], ["可手工复核", comparison.unconnectedEndsWithManualCandidates], ["osm2streets 参考", comparison.osm2streetsAvailable ? comparison.osm2streetsRoadSurfaceFeatures : "无"]]; summary.innerHTML = ""; for (const [label, value] of rows) { const term = document.createElement("dt"); const detail = document.createElement("dd"); term.textContent = label; detail.textContent = value; summary.append(term, detail); } }
+function renderSummary() {
+  const comparison = state.comparison;
+  const rows = [
+    ["方向道路", comparison.nativeRoadCount],
+    ["路缘与步行带", comparison.nativeSidewalkSurfaceFeatures],
+    ["路口面", comparison.nativeJunctionSurfaceFeatures],
+    ["普通构面路口", comparison.nativeApproachEnvelopeJunctions],
+    ["兜底构面路口", comparison.nativeFallbackJunctions],
+    ["最大外缘扩张", comparison.nativeMaxJunctionExpansionRatio],
+    ["道路中心虚线", comparison.nativeCenterLineFeatures],
+    ["道路方向箭头", comparison.nativeDirectionArrowFeatures],
+    ["路口转向箭头", comparison.nativeTurnArrowFeatures],
+    ["斑马线条带", comparison.nativeCrosswalkFeatures],
+    ["停止线", comparison.nativeVehicleStopLineFeatures],
+    ["红绿灯设施", state.trafficSignals?.assemblies?.features?.length || 0],
+    ["行驶动作", comparison.nativeMovementCount],
+    ["已绘制路径", comparison.nativePublishedMovementCount],
+    ["可手工复核", comparison.unconnectedEndsWithManualCandidates],
+    ["内部断头", comparison.unconnectedInteriorRoadEnds],
+    ["osm2streets 参考", comparison.osm2streetsAvailable ? comparison.osm2streetsRoadSurfaceFeatures : "无"],
+  ];
+  summary.innerHTML = "";
+  for (const [label, value] of rows) {
+    const term = document.createElement("dt"); const detail = document.createElement("dd");
+    term.textContent = label; detail.textContent = value; summary.append(term, detail);
+  }
+}
 function stageRoadOverride(road, changes) { const id = `道路:${road.id}`; const existing = staged.find((item) => item.id === id) || state.overrides.overrides.find((item) => item.id === id); staged = staged.filter((item) => item.id !== id); staged.push({ ...existing, id, kind: "road", roadId: road.id, ...changes }); }
+function setMarkingStyleForm(title, target, style, allowsDouble) { centerLineForm.hidden = false; markingStyleHeading.textContent = title; centerLineSegment.textContent = target; doubleYellowOption.hidden = !allowsDouble; centerLineStyleInput.value = style || "yellow-dashed"; }
+function selectCenterLine(feature) { selectedCenterLineSegment = feature.get("segment_id"); selectedLaneSeparator = null; setMarkingStyleForm("道路中心线样式", `道路段：${selectedCenterLineSegment}`, feature.get("effective_style"), true); }
+function selectLaneSeparator(feature) { selectedCenterLineSegment = null; selectedLaneSeparator = feature.getProperties(); setMarkingStyleForm("车道分隔线样式", `第 ${selectedLaneSeparator.left_lane_index} 与第 ${selectedLaneSeparator.right_lane_index} 车道之间`, selectedLaneSeparator.effective_style || "white-dashed", false); }
+function selectEdgeLine(feature) { selectedCenterLineSegment = null; selectedLaneSeparator = null; selectedEdgeLine = feature.getProperties(); setMarkingStyleForm("道路外缘线样式", `${selectedEdgeLine.side === "left" ? "左" : "右"}侧外缘`, selectedEdgeLine.effective_style || "white-solid", false); }
+function clearCenterLineSelection() { selectedCenterLineSegment = null; selectedLaneSeparator = null; selectedEdgeLine = null; centerLineForm.hidden = true; }
+function stageCenterLineStyle(segmentId, style) { const parts = style.split("-"); const double = parts[0] === "double"; const [color, pattern] = double ? parts.slice(1) : parts; const id = `道路中心线:${segmentId}`; const existing = staged.find((item) => item.id === id) || state.overrides.overrides.find((item) => item.id === id); staged = staged.filter((item) => item.id !== id); staged.push({ ...existing, id, kind: "center-line-style", segmentId, color, pattern, double }); }
 form.onsubmit = (event) => { event.preventDefault(); const roadChanges = { widthMeters: Number(widthInput.value), laneCount: Number(lanesInput.value), sidewalkLeft: leftInput.checked, sidewalkRight: rightInput.checked }; stageRoadOverride(selectedRoad, roadChanges); const opposite = state.compiled.model.roads.find((road) => road.id !== selectedRoad.id && road.segmentId === selectedRoad.segmentId); if (opposite) stageRoadOverride(opposite, { sidewalkLeft: rightInput.checked, sidewalkRight: leftInput.checked }); updateDirtyState(); message(opposite ? "有未保存修改：双向道路的路缘与步行带已按实际侧边同步" : "有未保存修改"); };
+function stageSelectedCenterLineStyle() { if (!selectedCenterLineSegment && !selectedLaneSeparator && !selectedEdgeLine) return; if (selectedCenterLineSegment) stageCenterLineStyle(selectedCenterLineSegment, centerLineStyleInput.value); else { const [color, pattern] = centerLineStyleInput.value.split("-"); const item = selectedLaneSeparator || selectedEdgeLine; const id = selectedLaneSeparator ? `车道分隔线:${item.road_id}:${item.left_lane_index}-${item.right_lane_index}` : `道路外缘线:${item.road_id}:${item.side}`; staged = staged.filter((change) => change.id !== id); staged.push(selectedLaneSeparator ? { id, kind: "lane-separator-style", roadId: item.road_id, leftLaneIndex: item.left_lane_index, rightLaneIndex: item.right_lane_index, color, pattern } : { id, kind: "edge-line-style", roadId: item.road_id, side: item.side, color, pattern }); } updateDirtyState(); message("有未保存修改：线样式"); }
+centerLineForm.onsubmit = (event) => { event.preventDefault(); stageSelectedCenterLineStyle(); };
+centerLineStyleInput.onchange = stageSelectedCenterLineStyle;
 async function saveStagedChanges() { if (!staged.length) return true; const existing = state.overrides.overrides.filter((item) => !staged.some((change) => change.id === item.id)); const response = await fetch("/api/overrides", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ schema: "native-road-overrides/v1", overrides: [...existing, ...staged] }) }); const result = await response.json(); if (!result.ok) { message(result.error); return false; } state.overrides = result.overrides; staged = []; updateDirtyState(); return true; }
 saveButton.onclick = async () => { if (await saveStagedChanges()) message("已保存，点击“保存并重新生成”写入几何"); };
 compileButton.onclick = async () => { if (!await saveStagedChanges()) return; message("正在保存修改并重新生成..."); const response = await fetch("/api/compile", { method: "POST" }); state = await response.json(); staged = []; updateDirtyState(); updateSources(); renderDiagnostics(); renderSummary(); selectRoad(selectedRoad ? state.compiled.model.roads.find((road) => road.id === selectedRoad.id) : null); message("已保存并重新生成"); };
-for (const input of document.querySelectorAll("[data-layer]")) input.onchange = () => { layers[input.dataset.layer].setVisible(input.checked); if (input.dataset.layer === "osm") layers.osmDirection.setVisible(input.checked); };
+for (const input of document.querySelectorAll("[data-layer]")) input.onchange = () => { const visible = input.checked; layers[input.dataset.layer].setVisible(visible); if (input.dataset.layer === "osm") layers.osmDirection.setVisible(visible); };
 scenePreviewToggle.onchange = () => {
   scenePreview = scenePreviewToggle.checked;
   for (const input of document.querySelectorAll("[data-layer]")) {
@@ -190,9 +315,13 @@ scenePreviewToggle.onchange = () => {
   layers.osmDirection.setVisible(!scenePreview && document.querySelector('[data-layer="osm"]').checked);
   layers.connectors.setVisible(!scenePreview && document.querySelector('[data-layer="lanes"]').checked);
   layers.sidewalks.setVisible(document.querySelector('[data-layer="sidewalks"]').checked);
+  layers.centerLines.setVisible(document.querySelector('[data-layer="centerLines"]').checked);
+  layers.controls.setVisible(document.querySelector('[data-layer="controls"]').checked);
+  const signalsVisible = document.querySelector('[data-layer="signals"]').checked;
+  layers.signals.setVisible(signalsVisible);
   layers.diagnostics.setVisible(!scenePreview);
   layers.native.changed(); layers.sidewalks.changed();
   message(scenePreview ? "场景效果预览：当前编译面" : "编辑图层预览");
 };
 for (const button of diagnosticFilters.querySelectorAll("button")) button.onclick = () => { diagnosticFilter = button.dataset.diagnosticFilter; renderDiagnostics(); };
-fetch("/api/state").then((response) => response.json()).then((value) => { state = value; updateDirtyState(); updateSources(); renderDiagnostics(); renderSummary(); areaLabel.textContent = state.areaId; message(`已加载 ${state.compiled.model.roads.length} 条方向道路`); }).catch((error) => message(error.message));
+fetch("/api/state").then((response) => response.json()).then((value) => { state = value; updateDirtyState(); updateSources(); renderDiagnostics(); renderSummary(); areaLabel.textContent = state.areaId; const signalUid = new URLSearchParams(location.search).get("signal"); const signal = signalUid && poleFeatureForSignal(signalUid); if (signal) selectSignal(signal); message(`已加载 ${state.compiled.model.roads.length} 条方向道路`); }).catch((error) => message(error.message));

scripts/workbench/index.html

@@ -1,4 +1,4 @@
 <!doctype html>
 <html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>道路编译工作台</title><link rel="stylesheet" href="/vendor/ol/ol.css"><link rel="stylesheet" href="/app.css"></head>
 <body><header><strong>道路编译工作台</strong><span id="area"></span><span id="status"></span><span id="dirty-state" aria-live="polite"></span><label style="display:inline;margin:0 0 0 auto;white-space:nowrap"><input id="scene-preview" type="checkbox"> 场景效果</label><button id="save">保存修改</button><button id="compile">保存并重新生成</button></header>
-<main><aside class="issues"><h1>图层</h1><label><input data-layer="osm" type="checkbox" checked> OSM 道路中心线</label><label><input data-layer="native" type="checkbox" checked> 自研道路与路口面</label><label><input data-layer="sidewalks" type="checkbox" checked> 路缘与步行带</label><label><input data-layer="lanes" type="checkbox" checked> 车道与转向路径</label><label><input data-layer="reference" type="checkbox"> osm2streets 参考面</label><hr><h1>当前编译概览</h1><dl id="summary"></dl><hr><h1>待检查问题</h1><div id="diagnostic-filters" class="segmented"><button data-diagnostic-filter="all" type="button">全部</button><button data-diagnostic-filter="candidates" type="button">可连接</button><button data-diagnostic-filter="other" type="button">其他</button></div><ul id="diagnostics"></ul></aside><section id="map" class="map"></section><aside class="inspector"><h1>当前道路设置</h1><p id="hint">点击道路、车道、转向路径或路口面以查看详情。</p><section id="selected-junction" hidden><h2>当前路口</h2><output id="junction-detail"></output></section><form id="road-form" hidden><label>道路</label><output id="road-name"></output><output id="movement-summary"></output><output id="lane-convention"></output><section id="selected-movement" hidden><h2>当前行驶动作</h2><output id="movement-detail"></output></section><div id="direction-switch"></div><label>本方向道路宽度（米）<input id="width" type="number" min="1" step="0.01"></label><label>本方向车道数<input id="lanes" type="number" min="1" step="1"></label><label><input id="left" type="checkbox"> 左侧有路缘与步行带</label><label><input id="right" type="checkbox"> 右侧有路缘与步行带</label><button type="submit">暂存本道路修改</button></form><hr><h2>路口连接</h2><div id="connections">请选择一条道路。</div><button id="add-connection" type="button" hidden>手工新增驶出连接</button><details><summary>技术详情与来源</summary><pre id="evidence">无</pre></details></aside></main><script type="importmap">{"imports":{"rbush":"/vendor/rbush/index.js","quickselect":"/vendor/quickselect/index.js"}}</script><script type="module" src="/app.js"></script></body></html>
+<main><aside class="issues"><h1>图层</h1><label><input data-layer="osm" type="checkbox" checked> OSM 道路中心线</label><label><input data-layer="native" type="checkbox" checked> 自研道路与路口面</label><label><input data-layer="sidewalks" type="checkbox" checked> 路缘与步行带</label><label><input data-layer="lanes" type="checkbox" checked> 车道与转向路径</label><label><input data-layer="reference" type="checkbox"> osm2streets 参考面</label><hr><h1>当前编译概览</h1><dl id="summary"></dl><hr><h1>待检查问题</h1><div id="diagnostic-filters" class="segmented"><button data-diagnostic-filter="all" type="button">全部</button><button data-diagnostic-filter="candidates" type="button">可连接</button><button data-diagnostic-filter="other" type="button">其他</button></div><ul id="diagnostics"></ul></aside><section id="map" class="map"></section><aside class="inspector"><h1>当前道路设置</h1><p id="hint">点击道路、车道、转向路径或路口面以查看详情。</p><section id="selected-junction" hidden><h2>当前路口</h2><output id="junction-detail"></output></section><form id="road-form" hidden><label>道路</label><output id="road-name"></output><output id="movement-summary"></output><output id="lane-convention"></output><section id="selected-movement" hidden><h2>当前行驶动作</h2><output id="movement-detail"></output></section><div id="direction-switch"></div><label>本方向道路宽度（米）<input id="width" type="number" min="1" step="0.01"></label><label>本方向车道数<input id="lanes" type="number" min="1" step="1"></label><label><input id="left" type="checkbox"> 左侧有路缘与步行带</label><label><input id="right" type="checkbox"> 右侧有路缘与步行带</label><button type="submit">暂存本道路修改</button></form><form id="center-line-form" hidden><h2 id="marking-style-heading">道路中心线样式</h2><output id="center-line-segment"></output><label>样式<select id="center-line-style"><option value="yellow-dashed">黄色虚线（默认）</option><option value="white-dashed">白色虚线</option><option value="yellow-solid">黄色实线</option><option value="white-solid">白色实线</option></select></label><button type="submit">暂存标线样式</button></form><hr><h2>路口连接</h2><div id="connections">请选择一条道路。</div><button id="add-connection" type="button" hidden>手工新增驶出连接</button><details><summary>技术详情与来源</summary><pre id="evidence">无</pre></details></aside></main><script type="importmap">{"imports":{"rbush":"/vendor/rbush/index.js","quickselect":"/vendor/quickselect/index.js"}}</script><script type="module" src="/app.js"></script></body></html>