diff --git a/.trellis/spec/backend/direct-edit-api.md b/.trellis/spec/backend/direct-edit-api.md
index 4fc118a..1deb89e 100644
--- a/.trellis/spec/backend/direct-edit-api.md
+++ b/.trellis/spec/backend/direct-edit-api.md
@@ -298,3 +298,60 @@ document byte-identical; warnings remain saveable. This prevents a client from
skipping preview and persisting a width, corner radius, crossing offset, or
stop-line value that the compiler rejects. Version conflicts are checked first
and continue to return HTTP 409 without invoking geometry validation writes.
+
+## 16. Scoped complex junction identity
+
+### Scope and signatures
+
+Stage 1 establishes the read model consumed by later cluster editing. Use
+`resolveComplexJunctionTopology(model, cluster, helpers)` in complex geometry,
+then `structureFromTopology(topology, shape, center, features)`. Projection is
+`projectJunctionStructure({ model, layers, trafficSignals, junctionRef })`.
+
+### Contracts
+
+- `junctionRef` is `{ type: 'node' | 'cluster', id }`. Explicit `null` means no
+ junction projection; unknown references return `null`, never the first core.
+- `GET /api/state` returns `junctionStructures`, keyed by `node:` and
+ `cluster:`. The legacy singular field is null at this unscoped entry point.
+- `GET /api/edit-state?junction=` preserves the node selection contract;
+ `?cluster=` selects a cluster. Preview uses the equivalent `selection`
+ object. Cluster handle manifests are empty until a future writable contract.
+- Complex road-surface features carry `junction_key`, `object_key` and relevant
+ `arm_key`, `carriageway_key`, `corner_key`. Core (or the first remaining
+ approach when the core fails) carries `junction_structure` for persisted reads.
+- Stable keys derive from cluster and sorted source node/segment/road IDs, with
+ corner keys derived from adjacent arms. Display indices and headings are not
+ object identities. `topologyFingerprint` detects source topology changes.
+- Root provenance lists member nodes and external road/segment IDs. Arms point
+ to carriageways, corners to arms, facilities to feature IDs; normalizers must
+ preserve these fields and readonly capabilities across JSON round trips.
+- Signal projection joins exact member `node_id` / `control_id`, retaining the
+ existing `signal_uid` as `geometryRef` and `provenance.featureIds`. It does not
+ rewrite the separately persisted signal document or guess from UID substrings.
+
+### Validation matrix
+
+| Input | Result |
+| --- | --- |
+| Multiple selection keys or repeated query keys | 400, no implicit priority |
+| Empty/object-valued ID | 400 |
+| Unknown node/cluster or missing compiled complex structure | null structure, empty diagnostics |
+| Missing/ambiguous object source | readonly capability with reason |
+| Explicit cluster selection | empty handles; never all-area or member-node handles |
+
+### Cases and tests
+
+Good: reorder member/road arrays and retain semantic IDs; delete a source and
+change its identity/fingerprint. Base: legacy node editing still works. Bad:
+opening cluster B while rendering cluster A's first core. Test the 3/4/offset/5+
+arm matrix, two-cluster isolation, internal-link exclusion, grouped crossings,
+scoped signals, JSON round trips, and persisted/preview projection equality.
+
+```js
+// Wrong: chooses an arbitrary junction and loses the selected scope.
+projectJunctionStructure({ model, layers });
+// Correct for a scoped editor:
+projectJunctionStructure({ model, layers, trafficSignals,
+ junctionRef: { type: 'cluster', id: selectedClusterId } });
+```
diff --git a/.trellis/spec/frontend/direct-edit-client.md b/.trellis/spec/frontend/direct-edit-client.md
index ca766bd..f2a7dfe 100644
--- a/.trellis/spec/frontend/direct-edit-client.md
+++ b/.trellis/spec/frontend/direct-edit-client.md
@@ -271,3 +271,28 @@ The same internal node layout can resolve to different external-arm topology.
If no summary exists, omit the shape row and retain normal cluster context; do
not show an inferred fallback. The compiler's safe fallback has no complex core
and therefore no summary.
+
+## 16. Scoped structure and semantic map selection
+
+Use `structureForJunction(state, ref)` to read `state.junctionStructures`; do not
+reuse the unscoped singular structure when its ref differs. A missing structure
+stays unavailable. Use `junctionEditSelection(ref)` for edit-state and preview
+requests so a cluster never falls back to the last selected road or node.
+
+Compiler structure provenance supplies cluster hotspots and external road IDs.
+`localJunctionState` and `localJunctionPreview` recognize explicit `junction_key`
+(and legacy `cluster_id`) before testing node/road references. This keeps core
+and corner features that do not carry member node IDs and excludes neighboring
+clusters even if a connecting road is shared.
+
+Map/list selection goes through `junctionObjectKeyForFeature` and
+`junctionObjectFeatures`: compiler keys identify arms/corners/crossing groups;
+signal UIDs resolve through scoped facility provenance. Display labels and row
+indices are never parsed into IDs. Highlighting is a read-only overlay, allocated
+when selecting an object; it must not mutate baseline features or rebuild the
+map. On scope changes clear object selection and ignore obsolete manifest loads.
+Map capability reason codes into user-facing Chinese descriptions.
+
+Required checks: opposite node/cluster scopes with equal raw IDs, unknown scope,
+list-to-feature grouping and feature-to-list identity, foreign-cluster exclusion,
+raw signal UID selection, map identity preservation, and reload stability.
diff --git a/src/compile/complex-junction.js b/src/compile/complex-junction.js
index 8cfc445..81b7bbc 100644
--- a/src/compile/complex-junction.js
+++ b/src/compile/complex-junction.js
@@ -1,6 +1,7 @@
'use strict';
const fs = require('fs');
+const { topologyIdentity, structureFromTopology } = require('./junction-topology');
const { convertGeoJson, boundsOf } = require('../reference/gaode');
const metricsCache = new WeakMap();
const CORNER_FILLET_SEGMENTS = 12;
@@ -12,6 +13,82 @@ const SIDEWALK_WIDTH_METERS = 2;
// past that end and let the two overlap rather than chase an exact seam.
const SIDEWALK_CORNER_OVERRUN_METERS = 6;
+// Geometry and the durable structure use this single external topology.
+function resolveComplexJunctionTopology(model, cluster, helpers) {
+ const nodeIds = new Set(cluster.nodeIds.map(String));
+ const nodes = [...nodeIds]
+ .sort()
+ .map((id) => helpers.junctionPlans.get(id)?.node)
+ .filter(Boolean);
+ const carriageways = [];
+ for (const [nodeId, plan] of helpers.junctionPlans) {
+ if (!nodeIds.has(String(nodeId))) continue;
+ for (const approach of plan.approaches) {
+ const roads = approach.roadIds.map((id) => model.roads.find((road) => road.id === id)).filter(Boolean);
+ // Source topology is authoritative; geometric proximity is only a fallback
+ // for legacy plans with no source-node metadata.
+ const sourced = roads.filter((road) => road.sourceNodeIds?.length >= 2);
+ const internal = sourced.length
+ ? sourced.every(
+ (road) => nodeIds.has(String(road.sourceNodeIds[0])) && nodeIds.has(String(road.sourceNodeIds.at(-1))),
+ )
+ : nodes.some((node) => node !== plan.node && helpers.distanceMeters(approach.line.at(-1), node) < 4);
+ if (internal) continue;
+ carriageways.push({
+ nodeId: String(nodeId),
+ approach,
+ plan,
+ roads,
+ heading: helpers.headingAtEndpoint(approach.line),
+ length: helpers.lineLengthMeters(approach.line),
+ });
+ }
+ }
+ // Stable source ordering makes heading grouping independent of plan/road order.
+ carriageways.sort((a, b) => topologyIdentity(a).localeCompare(topologyIdentity(b)));
+ const duplicateSources = new Set();
+ const seenSources = new Set();
+ for (const item of carriageways) {
+ const identity = topologyIdentity(item);
+ if (seenSources.has(identity)) duplicateSources.add(identity);
+ seenSources.add(identity);
+ }
+ for (let index = carriageways.length - 1; index > 0; index -= 1)
+ if (topologyIdentity(carriageways[index]) === topologyIdentity(carriageways[index - 1]))
+ carriageways.splice(index, 1);
+ const arms = [];
+ for (const item of carriageways) {
+ item.ambiguousSource = duplicateSources.has(topologyIdentity(item));
+ let arm = arms.find(
+ (candidate) => Math.abs(normalizeHeading(candidate.representative.heading - item.heading)) < 20,
+ );
+ if (!arm) {
+ arm = { representative: item, members: [] };
+ arms.push(arm);
+ }
+ arm.members.push(item);
+ }
+ for (const arm of arms) arm.heading = averageHeading(arm.members.map((item) => item.heading));
+ for (const item of carriageways)
+ if (arms.filter((arm) => Math.abs(normalizeHeading(arm.representative.heading - item.heading)) < 20).length > 1)
+ item.ambiguousSource = true;
+ arms.sort(
+ (a, b) =>
+ a.heading - b.heading || topologyIdentity(a.representative).localeCompare(topologyIdentity(b.representative)),
+ );
+ const scope = `cluster:${encodeURIComponent(cluster.id)}`;
+ for (const arm of arms) {
+ arm.key = `${scope}:arm:${arm.members.map(topologyIdentity).sort().join('|')}`;
+ for (const item of arm.members) {
+ item.key = `${scope}:carriageway:${topologyIdentity(item)}`;
+ item.armKey = arm.key;
+ }
+ }
+ for (let index = 0; index < arms.length; index += 1)
+ arms[index].cornerKey = `corner:${arms[index].key}>${arms[(index + 1) % arms.length].key}`;
+ return { cluster, nodeIds: [...nodeIds].sort(), carriageways, arms };
+}
+
function buildComplexJunctionGeometry(model, cluster, helpers) {
const nodeIds = new Set(cluster.nodeIds.map(String));
const nodes = cluster.nodeIds.map((id) => helpers.junctionPlans.get(String(id))?.node).filter(Boolean);
@@ -33,20 +110,9 @@ function buildComplexJunctionGeometry(model, cluster, helpers) {
(sum, point) => [sum[0] + point[0] / nodes.length, sum[1] + point[1] / nodes.length],
[0, 0],
);
- const approaches = [];
- const carriageways = [];
- for (const [nodeId, plan] of helpers.junctionPlans) {
- if (!nodeIds.has(String(nodeId))) continue;
- for (const approach of plan.approaches) {
- const endpoint = approach.line.at(-1);
- if (nodes.some((node) => node !== plan.node && helpers.distanceMeters(endpoint, node) < 4)) continue;
- const heading = helpers.headingAtEndpoint(approach.line);
- const length = helpers.lineLengthMeters(approach.line);
- carriageways.push({ nodeId, approach, plan, heading, length });
- if (approaches.some((item) => Math.abs(normalizeHeading(item.heading - heading)) < 20)) continue;
- approaches.push({ nodeId, approach, plan, heading, length });
- }
- }
+ const topology = resolveComplexJunctionTopology(model, cluster, helpers);
+ const { carriageways, arms } = topology;
+ const approaches = arms.map((arm) => arm.representative);
if (approaches.length < 3)
return {
features: [],
@@ -62,18 +128,7 @@ function buildComplexJunctionGeometry(model, cluster, helpers) {
],
};
const { calibration, coreRadius } = complexJunctionMetrics(cluster);
- const sorted = [...approaches].sort((a, b) => a.heading - b.heading);
- const arms = sorted.map((representative) => ({
- representative,
- heading: averageHeading(
- carriageways
- .filter((candidate) => Math.abs(normalizeHeading(candidate.heading - representative.heading)) < 20)
- .map((candidate) => candidate.heading),
- ),
- members: carriageways.filter(
- (candidate) => Math.abs(normalizeHeading(candidate.heading - representative.heading)) < 20,
- ),
- }));
+ const sorted = approaches;
const shape = classifyJunctionShape(arms, center, helpers);
if (shape.kind === 'unsupported')
return {
@@ -141,6 +196,9 @@ function buildComplexJunctionGeometry(model, cluster, helpers) {
type: 'Feature',
properties: {
native_id: `complex-stop-line:${cluster.id}:${item.approach.segmentId}`,
+ object_key: `stop-line:${item.key}`,
+ arm_key: item.armKey,
+ carriageway_key: item.key,
cluster_id: cluster.id,
kind: 'complex-stop-line',
road_id: incomingRoad.id,
@@ -223,6 +281,8 @@ function buildComplexJunctionGeometry(model, cluster, helpers) {
type: 'Feature',
properties: {
native_id: `complex-crosswalk:${cluster.id}:${item.nodeId}:${item.approach.segmentId}:${stripe + 1}`,
+ object_key: `crossing:${arm.key}`,
+ arm_key: arm.key,
cluster_id: cluster.id,
kind: 'complex-crosswalk',
crossing_node_id: item.nodeId,
@@ -290,6 +350,8 @@ function buildComplexJunctionGeometry(model, cluster, helpers) {
native_id: `complex-corner-island:${cluster.id}:${index + 1}`,
cluster_id: cluster.id,
kind: 'complex-corner-island',
+ object_key: `island:${first.cornerKey}`,
+ corner_key: first.cornerKey,
corner_index: index + 1,
from_heading: first.heading,
to_heading: second.heading,
@@ -332,6 +394,8 @@ function buildComplexJunctionGeometry(model, cluster, helpers) {
native_id: `complex-corner-crosswalk:${cluster.id}:${index + 1}:${stripe + 1}`,
cluster_id: cluster.id,
kind: 'complex-corner-crosswalk',
+ object_key: `crossing:${first.cornerKey}`,
+ corner_key: first.cornerKey,
corner_index: index + 1,
direction: bisector,
radial_distance_m: stripeRadius,
@@ -394,6 +458,8 @@ function buildComplexJunctionGeometry(model, cluster, helpers) {
native_id: `complex-corner-fillet:${cluster.id}:${index + 1}`,
cluster_id: cluster.id,
kind: 'complex-corner-fillet',
+ object_key: first.cornerKey,
+ corner_key: first.cornerKey,
complex_part: 'corner-fillet',
corner_index: index + 1,
from_heading: first.heading,
@@ -453,6 +519,8 @@ function buildComplexJunctionGeometry(model, cluster, helpers) {
native_id: `complex-sidewalk-corner:${cluster.id}:${index + 1}`,
cluster_id: cluster.id,
kind: 'complex-sidewalk-corner',
+ object_key: `sidewalk-turn:${first.cornerKey}`,
+ corner_key: first.cornerKey,
corner_index: index + 1,
from_heading: first.heading,
to_heading: second.heading,
@@ -530,6 +598,9 @@ function buildComplexJunctionGeometry(model, cluster, helpers) {
native_id: `complex-junction:${cluster.id}:carriageway:${item.approach.segmentId}`,
cluster_id: cluster.id,
kind: 'complex-approach',
+ object_key: item.key,
+ carriageway_key: item.key,
+ arm_key: item.armKey,
complex_part: 'carriageway',
heading_deg: item.heading,
lane_count: item.approach.roadIds.reduce(
@@ -562,7 +633,18 @@ function buildComplexJunctionGeometry(model, cluster, helpers) {
),
]
: [];
+ const allFeatures = [...features, ...islands, ...sidewalkCorners, ...crosswalks, ...stopLines];
+ const structure = structureFromTopology(topology, shape, center, allFeatures);
+ for (const feature of allFeatures) {
+ feature.properties.junction_key = structure.junctionKey;
+ feature.properties.topology_fingerprint = structure.topologyFingerprint;
+ }
+ // Persist the compiler authority with a generated road surface, including the
+ // supported-shape case where only the central polygon had to be skipped.
+ const carrier = features.find((feature) => feature.properties.kind === 'complex-core') || features[0];
+ if (carrier) carrier.properties.junction_structure = structure;
return {
+ structure,
features,
islands: [...islands, ...sidewalkCorners],
crosswalks,
@@ -907,4 +989,9 @@ function interpolateCoordinate(first, second, ratio) {
return [first[0] + (second[0] - first[0]) * ratio, first[1] + (second[1] - first[1]) * ratio];
}
-module.exports = { buildComplexJunctionGeometry, classifyJunctionShape, complexJunctionMetrics };
+module.exports = {
+ resolveComplexJunctionTopology,
+ buildComplexJunctionGeometry,
+ classifyJunctionShape,
+ complexJunctionMetrics,
+};
diff --git a/src/compile/direct-edit-solver.js b/src/compile/direct-edit-solver.js
index a781902..7e2c49a 100644
--- a/src/compile/direct-edit-solver.js
+++ b/src/compile/direct-edit-solver.js
@@ -1093,6 +1093,8 @@ function makeJunctionHandles(model, junctionData, constraints) {
*/
function selectHandles(handles, model, selection) {
if (!selection || !selection.type) return handles;
+ // Cluster object identities are read-only until their geometry edit path exists.
+ if (selection.type === 'cluster') return [];
if (selection.type === 'segment') {
const segmentOf = new Map((model.roads || []).map((road) => [road.id, road.segmentId]));
const wanted = String(selection.id);
diff --git a/src/compile/junction-projection.js b/src/compile/junction-projection.js
index d037b1a..499437e 100644
--- a/src/compile/junction-projection.js
+++ b/src/compile/junction-projection.js
@@ -11,30 +11,57 @@ function heading(from, to) {
return (Math.atan2(to[0] - from[0], to[1] - from[1]) * 180) / Math.PI;
}
-function pointOf(feature) {
- const coordinates = feature?.geometry?.coordinates;
- if (feature?.geometry?.type === 'Point' && Array.isArray(coordinates)) return coordinates;
- if (Array.isArray(coordinates?.[0]?.[0])) return coordinates[0][0];
- if (Array.isArray(coordinates?.[0])) return coordinates[0];
- return null;
-}
-
function projectJunctionStructure({
model = {},
layers = {},
trafficSignals = null,
shape = null,
junctionKey = null,
+ junctionRef = undefined,
} = {}) {
+ if (junctionRef === null) return null;
const roads = Array.isArray(model.roads) ? model.roads : [];
const endpoints = Array.isArray(model.endpoints) ? model.endpoints : [];
- const core = featureCollection(layers.intersectionSurface).find(
- (feature) => feature.properties?.kind === 'complex-core',
- );
- const properties = core?.properties || {};
- const key = String(junctionKey || properties.cluster_id || endpoints[0]?.nodeId || 'junction:area');
- const center = pointOf(core) || endpoints[0]?.coordinate || [0, 0];
- const junctionNodeId = String(junctionKey || properties.cluster_id ? endpoints[0]?.nodeId || '' : key);
+ if (junctionRef && !['node', 'cluster'].includes(junctionRef.type))
+ throw new Error('Invalid junction reference type');
+ if (junctionRef?.type === 'cluster') {
+ const carrier = featureCollection(layers.roadSurface || layers.nativeRoadSurface || layers.road_surface).find(
+ (feature) =>
+ String(feature.properties?.cluster_id) === String(junctionRef.id) && feature.properties?.junction_structure,
+ );
+ if (!carrier) return null;
+ const structure = buildJunctionStructure(carrier.properties.junction_structure);
+ const nodeIds = new Set(structure.provenance?.nodeIds || []);
+ const signals = new Map();
+ for (const feature of featureCollection(trafficSignals?.assemblies)) {
+ const p = feature.properties || {};
+ const nodeId = p.node_id ?? p.control_id;
+ if (nodeId == null || !nodeIds.has(String(nodeId)) || !p.signal_uid) continue;
+ const uid = String(p.signal_uid);
+ if (signals.has(uid)) {
+ signals.get(uid).capability.reason = 'source-ambiguous';
+ continue;
+ }
+ signals.set(uid, {
+ key: `cluster:${encodeURIComponent(junctionRef.id)}:signal:${encodeURIComponent(uid)}`,
+ kind: 'signal',
+ label: '信号灯',
+ geometryRef: uid,
+ editable: false,
+ capability: { editable: false, reason: 'complex-geometry-editing-not-implemented' },
+ provenance: { nodeIds: [String(nodeId)], featureIds: [uid] },
+ });
+ }
+ return buildJunctionStructure({
+ ...structure,
+ facilities: [...structure.facilities, ...signals.values()].sort((a, b) => a.key.localeCompare(b.key)),
+ });
+ }
+ const properties = {};
+ const key = String(junctionRef?.id || junctionKey || endpoints[0]?.nodeId || 'junction:area');
+ const junctionNodeId = key;
+ if ((junctionRef || junctionKey) && !endpoints.some((endpoint) => String(endpoint.nodeId) === key)) return null;
+ const center = endpoints.find((endpoint) => String(endpoint.nodeId) === key)?.coordinate || [0, 0];
const endpointByNode = new Map();
for (const endpoint of endpoints) endpointByNode.set(String(endpoint.nodeId), endpoint);
const arms = roads
@@ -48,7 +75,13 @@ function projectJunctionStructure({
return {
key: `road-arm:${road.id || index + 1}`,
label: String(road.tags?.name || road.name || `道路 ${index + 1}`),
- heading: heading(center, endpoint.coordinate),
+ heading:
+ road.centerline?.length > 1
+ ? heading(
+ center,
+ String(road.sourceNodeIds?.[0]) === junctionNodeId ? road.centerline[1] : road.centerline.at(-2),
+ )
+ : heading(center, endpoint.coordinate),
directionality:
road.direction === 'oneway' || road.direction === 'one-way'
? 'one-way'
@@ -64,41 +97,53 @@ function projectJunctionStructure({
sourceRoadId: String(road.id || ''),
};
})
- .filter(Boolean);
+ .filter(Boolean)
+ .sort((a, b) => a.heading - b.heading);
const corners =
arms.length > 1
? arms.map((arm, index) => {
const next = arms[(index + 1) % arms.length];
return {
- key: `corner:${index + 1}`,
+ key: `corner:${arm.key}>${next.key}`,
label: `角部 ${index + 1}`,
fromArmKey: arm.key,
toArmKey: next.key,
- geometryRef: `${key}:corner:${index + 1}`,
+ geometryRef: `corner:${arm.key}>${next.key}`,
};
})
: [];
+ const inScope = (feature) => {
+ if (!junctionRef && !junctionKey) return true;
+ const p = feature.properties || {};
+ if (p.cluster_id) return false;
+ const node = p.node_id ?? p.osm_node_id ?? p.crossing_node_id;
+ if (node !== undefined) return String(node) === junctionNodeId;
+ return p.road_id && arms.some((arm) => arm.sourceRoadId === String(p.road_id));
+ };
const facilities = [];
- const crossingKeys = [];
for (const [kind, collection] of [
['crossing', layers.crosswalks],
['stop-line', layers.vehicleStopLines],
]) {
- featureCollection(collection).forEach((feature, index) => {
- const id = feature.properties?.native_id || feature.properties?.id || `${kind}:${index + 1}`;
- facilities.push({
- key: String(id),
- kind,
- label: kind === 'crossing' ? `人行横道 ${index + 1}` : `停止线 ${index + 1}`,
- geometryRef: String(id),
+ featureCollection(collection)
+ .filter(inScope)
+ .forEach((feature, index) => {
+ const id = feature.properties?.native_id || feature.properties?.id || `${kind}:${index + 1}`;
+ facilities.push({
+ key: String(id),
+ kind,
+ label: kind === 'crossing' ? `人行横道 ${index + 1}` : `停止线 ${index + 1}`,
+ geometryRef: String(id),
+ });
});
- if (kind === 'crossing') crossingKeys.push(String(id));
- });
}
- for (const [index, feature] of featureCollection(trafficSignals?.assemblies).entries()) {
+ for (const [index, feature] of featureCollection(trafficSignals?.assemblies).filter(inScope).entries()) {
const id = feature.properties?.signal_uid || feature.properties?.id || `signal:${index + 1}`;
const signalNode = feature.properties?.node_id || feature.properties?.control_id;
- const related = crossingKeys.find((crossingKey) => String(crossingKey).includes(String(signalNode || '')));
+ const related = featureCollection(layers.crosswalks)
+ .filter(inScope)
+ .find((crossing) => signalNode != null && String(crossing.properties?.crossing_node_id) === String(signalNode))
+ ?.properties?.native_id;
facilities.push({
key: String(id),
kind: 'signal',
@@ -112,21 +157,23 @@ function projectJunctionStructure({
['median', layers.medians],
['sidewalk-turn', layers.sidewalkTurns],
]) {
- featureCollection(collection).forEach((feature, index) => {
- if (feature.properties?.kind !== kind) return;
- const id = feature.properties?.native_id || feature.properties?.id || `${kind}:${index + 1}`;
- facilities.push({
- key: String(id),
- kind,
- label:
- kind === 'island'
- ? `导流岛 ${index + 1}`
- : kind === 'median'
- ? `中央分隔 ${index + 1}`
- : `人行道转角 ${index + 1}`,
- geometryRef: String(id),
+ featureCollection(collection)
+ .filter(inScope)
+ .forEach((feature, index) => {
+ if (feature.properties?.kind !== kind) return;
+ const id = feature.properties?.native_id || feature.properties?.id || `${kind}:${index + 1}`;
+ facilities.push({
+ key: String(id),
+ kind,
+ label:
+ kind === 'island'
+ ? `导流岛 ${index + 1}`
+ : kind === 'median'
+ ? `中央分隔 ${index + 1}`
+ : `人行道转角 ${index + 1}`,
+ geometryRef: String(id),
+ });
});
- });
}
const shapeKind =
shape?.kind ||
@@ -134,6 +181,7 @@ function projectJunctionStructure({
(arms.length === 3 ? 't-junction' : arms.length >= 5 ? 'multi-arm' : arms.length === 4 ? 'cross' : 'unsupported');
return buildJunctionStructure({
junctionKey: key,
+ junctionRef: { type: 'node', id: junctionNodeId },
label: properties.shape_label || '路口',
center,
shape: {
@@ -151,7 +199,7 @@ function projectJunctionStructure({
function standardsDiagnostics(structure, profile = CN_URBAN_DEFAULT_PROFILE) {
const diagnostics = [];
- for (const arm of structure.arms) {
+ for (const arm of structure?.arms || []) {
const rule = profile.rules.find((item) => item.id === 'effective-carriageway-width');
const severity = evaluateRange(arm.carriageway.effectiveWidthMeters, rule);
diagnostics.push({
diff --git a/src/compile/junction-structure.js b/src/compile/junction-structure.js
index ae2ed95..e6956ab 100644
--- a/src/compile/junction-structure.js
+++ b/src/compile/junction-structure.js
@@ -35,6 +35,34 @@ function overrideState(input = {}) {
};
}
+function metadata(input) {
+ const result = {};
+ if (input.provenance !== undefined) {
+ if (!input.provenance || typeof input.provenance !== 'object' || Array.isArray(input.provenance))
+ throw new Error('Junction provenance must be an object');
+ for (const field of ['nodeIds', 'segmentIds', 'roadIds', 'osmWayIds', 'carriagewayKeys', 'armKeys', 'featureIds']) {
+ const values = input.provenance[field];
+ if (values !== undefined && (!Array.isArray(values) || values.some((value) => typeof value !== 'string')))
+ throw new Error(`Junction provenance.${field} must be an array of strings`);
+ }
+ result.provenance = JSON.parse(JSON.stringify(input.provenance));
+ }
+ if (input.capability !== undefined) {
+ if (
+ typeof input.capability?.editable !== 'boolean' ||
+ (input.capability.reason !== undefined &&
+ (typeof input.capability.reason !== 'string' || !input.capability.reason.trim())) ||
+ (!input.capability.editable && !input.capability.reason)
+ )
+ throw new Error('Junction readonly capability requires a reason');
+ result.capability = {
+ editable: input.capability.editable,
+ ...(input.capability.reason ? { reason: String(input.capability.reason) } : {}),
+ };
+ }
+ return result;
+}
+
function normalizeRoadArm(input, index) {
const key = objectKey(input.key, `road-arm:${index + 1}`);
const label = readableLabel(input.label, `道路 ${index + 1}`);
@@ -43,9 +71,22 @@ function normalizeRoadArm(input, index) {
const carriageway = input.carriageway || {};
const normalized = {
key,
+ ...metadata(input),
label,
heading: finiteNumber(input.heading ?? 0, 'arm heading'),
directionality,
+ ...(input.sourceRoadId ? { sourceRoadId: String(input.sourceRoadId) } : {}),
+ ...(input.carriageways
+ ? {
+ carriageways: input.carriageways.map((item) => ({
+ key: objectKey(item.key),
+ geometryRef: objectKey(item.geometryRef, item.key),
+ ...metadata(item),
+ laneCount: finiteNumber(item.laneCount, 'carriageway lane count', { integer: true, minimum: 0 }),
+ effectiveWidthMeters: finiteNumber(item.effectiveWidthMeters, 'carriageway width', { minimum: 0 }),
+ })),
+ }
+ : {}),
carriageway: {
...(carriageway.laneCount === undefined
? {}
@@ -77,6 +118,7 @@ function normalizeCorner(input, index) {
if (fromArmKey === toArmKey) throw new Error(`Junction corner ${key} must connect two different road arms`);
return {
key,
+ ...metadata(input),
label: readableLabel(input.label, `角部 ${index + 1}`),
fromArmKey,
toArmKey,
@@ -95,6 +137,7 @@ function normalizeFacility(input, index) {
const key = objectKey(input.key, `${kind}:${index + 1}`);
return {
key,
+ ...metadata(input),
kind,
label: readableLabel(input.label, kind === 'crossing' ? `人行横道 ${index + 1}` : `设施 ${index + 1}`),
...(input.armKey ? { armKey: String(input.armKey) } : {}),
@@ -121,6 +164,10 @@ function buildJunctionStructure(input = {}) {
const kind = String(shape.kind || 'unsupported');
if (!SHAPE_KINDS.has(kind)) throw new Error(`Unsupported junction shape kind: ${kind}`);
const arms = (input.arms || []).map(normalizeRoadArm);
+ assertUniqueKeys(
+ arms.flatMap((arm) => arm.carriageways || []),
+ 'carriageway',
+ );
const armKeys = assertUniqueKeys(arms, 'road arm');
const corners = (input.corners || []).map(normalizeCorner);
const cornerKeys = assertUniqueKeys(corners, 'corner');
@@ -141,7 +188,15 @@ function buildJunctionStructure(input = {}) {
finiteNumber(effectiveArmCount, 'effective arm count', { integer: true, minimum: 0 });
if (effectiveArmCount !== arms.length)
throw new Error('Junction effective arm count must match the supplied road arms');
+ if (
+ input.junctionRef &&
+ (!['node', 'cluster'].includes(input.junctionRef.type) || !String(input.junctionRef.id || '').trim())
+ )
+ throw new Error('Junction reference requires a node or cluster type and id');
return {
+ ...metadata(input),
+ ...(input.junctionRef ? { junctionRef: { type: input.junctionRef.type, id: String(input.junctionRef.id) } } : {}),
+ ...(input.topologyFingerprint ? { topologyFingerprint: String(input.topologyFingerprint) } : {}),
schema: JUNCTION_STRUCTURE_SCHEMA,
junctionKey: objectKey(input.junctionKey, 'junction:unknown'),
label: readableLabel(input.label, '未命名路口'),
diff --git a/src/compile/junction-topology.js b/src/compile/junction-topology.js
new file mode 100644
index 0000000..dd38eb6
--- /dev/null
+++ b/src/compile/junction-topology.js
@@ -0,0 +1,130 @@
+'use strict';
+
+const { createHash } = require('crypto');
+const { buildJunctionStructure } = require('./junction-structure');
+
+function topologyIdentity(item) {
+ return [item.nodeId, item.approach.segmentId || '', ...item.approach.roadIds.map(String).sort()]
+ .map(encodeURIComponent)
+ .join('/');
+}
+
+function sourceOf(item) {
+ return {
+ nodeIds: [String(item.nodeId)],
+ segmentIds: [String(item.approach.segmentId || '')],
+ roadIds: item.approach.roadIds.map(String).sort(),
+ osmWayIds: [...new Set(item.roads.flatMap((road) => (road.osmWayIds || []).map(String)))].sort(),
+ };
+}
+
+function capability(reason = 'complex-geometry-editing-not-implemented') {
+ return { editable: false, reason };
+}
+
+function structureFromTopology(topology, shape, center, features) {
+ const { cluster } = topology;
+ const arms = topology.arms.map((arm, index) => {
+ const carriageways = arm.members.map((item) => ({
+ key: item.key,
+ geometryRef: item.key,
+ provenance: sourceOf(item),
+ capability: capability(
+ item.ambiguousSource
+ ? 'source-ambiguous'
+ : item.approach.segmentId &&
+ item.roads.length > 0 &&
+ item.roads.length === item.approach.roadIds.length &&
+ item.roads.every((road) => road.sourceNodeIds?.length >= 2)
+ ? undefined
+ : 'source-missing',
+ ),
+ laneCount: item.roads.reduce((sum, road) => sum + (Number(road.laneCount) || 0), 0),
+ effectiveWidthMeters: item.approach.widthMeters,
+ }));
+ return {
+ key: arm.key,
+ label: arm.members[0].roads[0]?.tags?.name || `道路 ${index + 1}`,
+ heading: arm.heading,
+ directionality: arm.members.some((item) => item.roads.length > 1) ? 'two-way' : 'one-way',
+ carriageway: {
+ laneCount: carriageways.reduce((sum, item) => sum + item.laneCount, 0),
+ effectiveWidthMeters: carriageways.reduce((sum, item) => sum + item.effectiveWidthMeters, 0),
+ },
+ carriageways,
+ geometryRef: arm.key,
+ provenance: { carriagewayKeys: carriageways.map((item) => item.key) },
+ capability: capability(),
+ };
+ });
+ const corners =
+ topology.arms.length > 1
+ ? topology.arms.map((arm, index) => ({
+ key: arm.cornerKey,
+ label: `角部 ${index + 1}`,
+ fromArmKey: arm.key,
+ toArmKey: topology.arms[(index + 1) % topology.arms.length].key,
+ geometryRef: arm.cornerKey,
+ provenance: { armKeys: [arm.key, topology.arms[(index + 1) % topology.arms.length].key] },
+ capability: capability(),
+ }))
+ : [];
+ const facilitiesByKey = new Map();
+ for (const feature of features) {
+ const p = feature.properties;
+ const kind = {
+ 'complex-crosswalk': 'crossing',
+ 'complex-corner-crosswalk': 'crossing',
+ 'complex-stop-line': 'stop-line',
+ 'complex-corner-island': 'island',
+ 'complex-sidewalk-corner': 'sidewalk-turn',
+ }[p.kind];
+ if (!kind || !p.object_key) continue;
+ if (!facilitiesByKey.has(p.object_key))
+ facilitiesByKey.set(p.object_key, {
+ key: p.object_key,
+ kind,
+ label: `${{ crossing: '人行横道', 'stop-line': '停止线', island: '导流岛', 'sidewalk-turn': '人行道转角' }[kind]}`,
+ geometryRef: p.object_key,
+ ...(p.arm_key ? { armKey: p.arm_key } : {}),
+ ...(p.corner_key ? { cornerKey: p.corner_key } : {}),
+ ...(kind === 'stop-line' && features.some((f) => f.properties.object_key === `crossing:${p.arm_key}`)
+ ? { relatedFacilityKey: `crossing:${p.arm_key}` }
+ : {}),
+ editable: false,
+ capability: capability(),
+ provenance: { featureIds: [], ...(p.road_id ? { roadIds: [String(p.road_id)] } : {}) },
+ });
+ facilitiesByKey.get(p.object_key).provenance.featureIds.push(String(p.native_id));
+ }
+ const facilities = [...facilitiesByKey.values()].sort((a, b) => a.key.localeCompare(b.key));
+ for (const facility of facilities) facility.provenance.featureIds.sort();
+ const fingerprint = createHash('sha256')
+ .update(
+ JSON.stringify({
+ nodeIds: topology.nodeIds,
+ arms: arms.map((arm) => arm.key).sort(),
+ corners: corners.map((corner) => corner.key).sort(),
+ }),
+ )
+ .digest('hex');
+ return buildJunctionStructure({
+ junctionKey: `cluster:${cluster.id}`,
+ junctionRef: { type: 'cluster', id: String(cluster.id) },
+ label: shape.label,
+ center,
+ topologyFingerprint: fingerprint,
+ provenance: {
+ nodeIds: topology.nodeIds,
+ roadIds: [...new Set(topology.carriageways.flatMap((item) => sourceOf(item).roadIds))].sort(),
+ segmentIds: [...new Set(topology.carriageways.flatMap((item) => sourceOf(item).segmentIds))].sort(),
+ },
+ capability: capability(),
+ shape: { ...shape, effectiveArmCount: arms.length },
+ arms,
+ corners,
+ facilities,
+ });
+}
+
+module.exports = { topologyIdentity, structureFromTopology };
diff --git a/test/e2e-server.js b/test/e2e-server.js
index 59de9bd..dc21675 100644
--- a/test/e2e-server.js
+++ b/test/e2e-server.js
@@ -24,7 +24,13 @@ fs.writeFileSync(
fs.readFileSync(path.join(__dirname, '..', 'outputs', 'fengshu-er-road', 'native-traffic-signals.json')),
);
-const server = startWorkbench({ input, repoRoot: path.resolve(__dirname, '..'), dataRoot: root, port: 8899 });
+const server = startWorkbench({
+ input,
+ repoRoot: path.resolve(__dirname, '..'),
+ dataRoot: root,
+ debug: true,
+ port: 8899,
+});
const cleanup = () => {
server.close(() => fs.rmSync(root, { recursive: true, force: true }));
};
diff --git a/test/e2e/workbench.spec.ts b/test/e2e/workbench.spec.ts
index c4f9a7e..4858181 100644
--- a/test/e2e/workbench.spec.ts
+++ b/test/e2e/workbench.spec.ts
@@ -1,6 +1,9 @@
import fs from 'node:fs';
import { expect, test } from '@playwright/test';
import { strFromU8, unzipSync } from 'fflate';
+import type OLMap from 'ol/Map';
+import type VectorLayer from 'ol/layer/Vector';
+import type VectorSource from 'ol/source/Vector';
test.describe('workbench editing shell', () => {
test.beforeEach(async ({ page }) => {
@@ -194,4 +197,61 @@ test.describe('workbench editing shell', () => {
await page.getByRole('button', { name: '放弃草稿' }).click();
await expect(heading).toHaveValue(original);
});
+
+ test('keeps complex junction structure and map selection linked across reload', async ({ page }) => {
+ const initial = await page.request.get('/api/state').then((response) => response.json());
+ const candidate = initial.debug.junctionCandidates.find((item: { nodeIds: string[] }) => item.nodeIds.length >= 3);
+ expect(candidate).toBeTruthy();
+ const acceptedResponse = await page.request.post('/api/junction-clusters', {
+ data: { candidateId: candidate.id, nodeIds: candidate.nodeIds },
+ });
+ expect(acceptedResponse.ok()).toBe(true);
+ const accepted = await acceptedResponse.json();
+ const id = accepted.added.id;
+ const structure = accepted.junctionStructures[`cluster:${id}`];
+ expect(structure.arms.length).toBeGreaterThanOrEqual(3);
+ await page.goto(`/junction/cluster/${encodeURIComponent(id)}`);
+ const workspace = page.getByLabel('路口编辑工作区');
+ await expect(workspace).toBeVisible();
+ const armButtons = workspace.locator('.junction-workspace__object-list').first().getByRole('button');
+ await expect(armButtons).toHaveCount(structure.arms.length);
+ const map = await page
+ .getByLabel('道路地图')
+ .evaluateHandle((element) => (element as HTMLDivElement & { __roadWorkbenchMap: OLMap }).__roadWorkbenchMap);
+ await armButtons.first().click();
+ await expect(armButtons.first()).toHaveAttribute('aria-pressed', 'true');
+ await expect
+ .poll(async () =>
+ page.getByLabel('道路地图').evaluate((element) => {
+ const map = (element as HTMLDivElement & { __roadWorkbenchMap: OLMap }).__roadWorkbenchMap;
+ const layer = map
+ .getLayers()
+ .getArray()
+ .find((item) => item.getZIndex() === 89) as VectorLayer | undefined;
+ return layer?.getSource()?.getFeatures().length || 0;
+ }),
+ )
+ .toBeGreaterThan(0);
+ const sameMap = await page
+ .getByLabel('道路地图')
+ .evaluate(
+ (element, original) =>
+ (element as HTMLDivElement & { __roadWorkbenchMap: OLMap }).__roadWorkbenchMap === original,
+ map,
+ );
+ expect(sameMap).toBe(true);
+ await expect(workspace.getByText('路口参数', { exact: true })).toHaveCount(0);
+ const scoped = await page.request
+ .get(`/api/edit-state?cluster=${encodeURIComponent(id)}`)
+ .then((response) => response.json());
+ expect(scoped.handles.handles).toEqual([]);
+ expect(scoped.junctionStructure.topologyFingerprint).toBe(structure.topologyFingerprint);
+ await page.reload();
+ await expect(armButtons).toHaveCount(structure.arms.length);
+ await expect(armButtons.first()).toHaveAttribute('aria-pressed', 'false');
+ const refreshed = await page.request.get('/api/state').then((response) => response.json());
+ expect(refreshed.junctionStructures[`cluster:${id}`].arms.map((arm: { key: string }) => arm.key)).toEqual(
+ structure.arms.map((arm: { key: string }) => arm.key),
+ );
+ });
});
diff --git a/test/junction-projection.js b/test/junction-projection.js
index a588e87..e1801f4 100644
--- a/test/junction-projection.js
+++ b/test/junction-projection.js
@@ -93,3 +93,214 @@ assert.equal(diagnostics[1].severity, 'warning');
assert.equal(diagnostics[1].objectKey, 'road-arm:road:east');
console.log('junction projection tests passed');
+
+// Real geographic topology survives input and persisted-layer ordering changes.
+const fs = require('fs');
+const path = require('path');
+const { compileRoadModel, compileGeometry } = require('../src/compile/native-road');
+const { buildJunctionStructure } = require('../src/compile/junction-structure');
+const overrides = { schema: 'native-road-overrides/v1', overrides: [] };
+const baseline = compileRoadModel(
+ fs.readFileSync(path.join(__dirname, 'fixtures/fengshu-er-road.osm'), 'utf8'),
+ overrides,
+);
+const cluster = {
+ id: 'identity',
+ template: 'complex-junction-v1',
+ nodeIds: ['8005332807', '8024512135', '8024512145', '8024512147', '8613058676'],
+ coreRadiusMeters: 24,
+};
+function compileCluster(input, config) {
+ return compileGeometry(input, overrides, {
+ edgeLines: false,
+ junctionTemplates: { enabled: true, clusters: [config] },
+ });
+}
+const layers = compileCluster(baseline, cluster);
+const ref = { type: 'cluster', id: cluster.id };
+const authoritative = projectJunctionStructure({ model: baseline, layers, junctionRef: ref });
+assert.equal(authoritative.arms.length, 5);
+assert.equal(authoritative.junctionRef.type, 'cluster');
+assert.equal(authoritative.capability.editable, false);
+assert.ok(authoritative.arms.every((arm) => arm.carriageways.length && arm.capability.reason));
+assert.deepEqual(buildJunctionStructure(JSON.parse(JSON.stringify(authoritative))), authoritative);
+assert.throws(
+ () => buildJunctionStructure({ ...authoritative, provenance: { nodeIds: 'invalid' } }),
+ /array of strings/,
+);
+assert.throws(
+ () => buildJunctionStructure({ ...authoritative, capability: { editable: false, reason: ' ' } }),
+ /requires a reason/,
+);
+const reversed = structuredClone(baseline);
+reversed.roads.reverse();
+reversed.endpoints.reverse();
+const reorderedLayers = compileCluster(reversed, { ...cluster, nodeIds: [...cluster.nodeIds].reverse() });
+reorderedLayers.roadSurface.features.reverse();
+const reordered = projectJunctionStructure({ model: reversed, layers: reorderedLayers, junctionRef: ref });
+for (const kind of ['arms', 'corners', 'facilities'])
+ assert.deepEqual(reordered[kind].map((item) => item.key).sort(), authoritative[kind].map((item) => item.key).sort());
+assert.equal(reordered.topologyFingerprint, authoritative.topologyFingerprint);
+function closeCoordinates(actual, expected) {
+ assert.equal(actual.length, expected.length);
+ actual.forEach((value, index) => {
+ if (Array.isArray(value)) closeCoordinates(value, expected[index]);
+ else assert.ok(Math.abs(value - expected[index]) < 1e-9, `${value} != ${expected[index]}`);
+ });
+}
+for (const [name, collection] of Object.entries(layers)) {
+ const originalFeatures = (collection?.features || []).filter((feature) => feature.properties?.object_key);
+ const recompiledFeatures = new Map(
+ (reorderedLayers[name]?.features || []).map((feature) => [feature.properties?.native_id, feature]),
+ );
+ for (const feature of originalFeatures) {
+ const recompiled = recompiledFeatures.get(feature.properties.native_id);
+ assert.ok(recompiled, feature.properties.native_id);
+ assert.equal(recompiled.properties.object_key, feature.properties.object_key);
+ closeCoordinates(recompiled.geometry.coordinates, feature.geometry.coordinates);
+ }
+}
+assert.equal(
+ projectJunctionStructure({ model: baseline, layers, junctionRef: { type: 'cluster', id: 'missing' } }),
+ null,
+);
+const otherLayers = compileCluster(baseline, { ...cluster, id: 'other' });
+const combined = {
+ roadSurface: {
+ type: 'FeatureCollection',
+ features: [...otherLayers.roadSurface.features, ...layers.roadSurface.features],
+ },
+};
+assert.equal(projectJunctionStructure({ layers: combined, junctionRef: ref }).junctionKey, 'cluster:identity');
+assert.equal(
+ projectJunctionStructure({ layers: combined, junctionRef: { type: 'cluster', id: 'other' } }).junctionKey,
+ 'cluster:other',
+);
+const objectKeys = new Set(
+ [
+ ...authoritative.arms,
+ ...authoritative.corners,
+ ...authoritative.facilities,
+ ...authoritative.arms.flatMap((arm) => arm.carriageways),
+ ].map((item) => item.key),
+);
+for (const collection of Object.values(layers)) {
+ for (const feature of collection?.features || []) {
+ if (feature.properties?.cluster_id !== cluster.id || !feature.properties.object_key) continue;
+ assert.ok(objectKeys.has(feature.properties.object_key), feature.properties.object_key);
+ }
+}
+const sources = authoritative.arms.flatMap((arm) => arm.carriageways).flatMap((item) => item.provenance.roadIds);
+for (const id of sources) {
+ const road = baseline.roads.find((item) => item.id === id);
+ assert.ok(
+ !(
+ cluster.nodeIds.includes(String(road.sourceNodeIds[0])) &&
+ cluster.nodeIds.includes(String(road.sourceNodeIds.at(-1)))
+ ),
+ );
+}
+const removedId = sources[0];
+const removed = structuredClone(baseline);
+removed.roads = removed.roads.filter((road) => road.id !== removedId);
+removed.endpoints = removed.endpoints.filter((endpoint) => endpoint.roadId !== removedId);
+const afterRemoval = projectJunctionStructure({ layers: compileCluster(removed, cluster), junctionRef: ref });
+assert.notEqual(afterRemoval.topologyFingerprint, authoritative.topologyFingerprint);
+assert.ok(
+ !afterRemoval.arms.flatMap((arm) => arm.carriageways).some((item) => item.provenance.roadIds.includes(removedId)),
+);
+assert.deepEqual(standardsDiagnostics(null), []);
+console.log('complex junction identity and provenance tests passed');
+
+const signalFeatures = [
+ { properties: { signal_uid: 'signal:member', control_id: cluster.nodeIds[0] } },
+ { properties: { signal_uid: 'signal:node', node_id: cluster.nodeIds[1] } },
+ { properties: { signal_uid: `signal:${cluster.nodeIds[0]}`, control_id: 'elsewhere' } },
+ { properties: { signal_uid: 'signal:unscoped' } },
+];
+const withSignals = (features) =>
+ projectJunctionStructure({ layers, junctionRef: ref, trafficSignals: { assemblies: { features } } });
+const signalStructure = withSignals(signalFeatures);
+const projectedSignals = signalStructure.facilities.filter((item) => item.kind === 'signal');
+assert.equal(projectedSignals.length, 2);
+assert.ok(projectedSignals.every((item) => !item.editable && !item.capability.editable));
+assert.deepEqual(
+ projectedSignals.map((item) => item.provenance.featureIds),
+ [['signal:member'], ['signal:node']],
+);
+assert.deepEqual(withSignals([...signalFeatures].reverse()), signalStructure);
+assert.deepEqual(buildJunctionStructure(JSON.parse(JSON.stringify(signalStructure))), signalStructure);
+assert.equal(withSignals([]).facilities.filter((item) => item.kind === 'signal').length, 0);
+assert.equal(
+ withSignals([...signalFeatures, signalFeatures[0]]).facilities.find((item) => item.geometryRef === 'signal:member')
+ .capability.reason,
+ 'source-ambiguous',
+);
+
+const { resolveComplexJunctionTopology, classifyJunctionShape } = require('../src/compile/complex-junction');
+const { structureFromTopology } = require('../src/compile/junction-topology');
+for (const headings of [
+ [0, 90, 180],
+ [0, 90, 180, 270],
+ [0, 60, 120, 180, 240, 300],
+]) {
+ const syntheticModel = {
+ roads: headings.map((angle) => ({ id: `road:${angle}`, sourceNodeIds: ['a', `outer:${angle}`], laneCount: 1 })),
+ };
+ const approaches = headings.map((angle) => ({
+ segmentId: `segment:${angle}`,
+ roadIds: [`road:${angle}`],
+ widthMeters: 3.5,
+ line: [
+ [0, 0],
+ [Math.sin((angle * Math.PI) / 180) * 30, Math.cos((angle * Math.PI) / 180) * 30],
+ ],
+ }));
+ const plans = new Map([
+ ['a', { node: [0, 0], approaches }],
+ ['b', { node: [1, 1], approaches: [] }],
+ ]);
+ const helpers = {
+ junctionPlans: plans,
+ headingAtEndpoint: (line) => (Math.atan2(line[1][0], line[1][1]) * 180) / Math.PI,
+ lineLengthMeters: () => 30,
+ distanceMeters: (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]),
+ };
+ const topology = resolveComplexJunctionTopology(syntheticModel, { id: 'synthetic', nodeIds: ['a', 'b'] }, helpers);
+ assert.equal(topology.arms.length, headings.length);
+ const shape = classifyJunctionShape(topology.arms, [0, 0], helpers);
+ assert.equal(structureFromTopology(topology, shape, [0, 0], []).shape.effectiveArmCount, headings.length);
+ if (headings.length === 4) {
+ approaches[0].line[1] = [0, 50];
+ const offset = resolveComplexJunctionTopology(syntheticModel, { id: 'synthetic', nodeIds: ['a', 'b'] }, helpers);
+ const offsetShape = classifyJunctionShape(offset.arms, [0, 0], helpers);
+ assert.equal(offsetShape.kind, 'offset-cross');
+ const offsetStructure = structureFromTopology(offset, offsetShape, [0, 0], []);
+ assert.equal(offsetStructure.arms.length, 4);
+ assert.deepEqual(
+ offsetStructure.arms.map((arm) => arm.key),
+ structureFromTopology(topology, shape, [0, 0], []).arms.map((arm) => arm.key),
+ );
+ }
+ // Duplicate provenance never invents another editable object.
+ approaches.push(approaches[0]);
+ const duplicate = resolveComplexJunctionTopology(syntheticModel, { id: 'synthetic', nodeIds: ['a', 'b'] }, helpers);
+ const duplicateStructure = structureFromTopology(duplicate, shape, [0, 0], []);
+ assert.equal(duplicateStructure.arms.length, headings.length);
+ assert.ok(
+ duplicateStructure.arms
+ .flatMap((arm) => arm.carriageways)
+ .some((item) => item.capability.reason === 'source-ambiguous'),
+ );
+ syntheticModel.roads[1].sourceNodeIds = [];
+ const missingSource = resolveComplexJunctionTopology(
+ syntheticModel,
+ { id: 'synthetic', nodeIds: ['a', 'b'] },
+ helpers,
+ );
+ assert.ok(
+ structureFromTopology(missingSource, shape, [0, 0], [])
+ .arms.flatMap((arm) => arm.carriageways)
+ .some((item) => item.capability.reason === 'source-missing'),
+ );
+}
diff --git a/test/workbench-edit-api.js b/test/workbench-edit-api.js
index 978812d..409835a 100644
--- a/test/workbench-edit-api.js
+++ b/test/workbench-edit-api.js
@@ -7,7 +7,14 @@ const path = require('path');
const { compileInput } = require('../src/compile/compiler');
const { compileRoadModel, loadOverrides } = require('../src/compile/native-road');
const { ensureRevisionStore } = require('../src/compile/road-revisions');
-const { editPreview, editState, rebaseEdits, saveEdits } = require('../workbench/server');
+const {
+ editPreview,
+ editState,
+ rebaseEdits,
+ saveEdits,
+ state: browseState,
+ selectionFrom,
+} = require('../workbench/server');
const { snapshot: outputSnapshot } = require('./fixture-baseline');
const workspace = fs.mkdtempSync(path.join(os.tmpdir(), 'workbench-edit-api-'));
@@ -219,5 +226,100 @@ assert.notDeepEqual(
'a saved constraint must change the compiled output, or saving cannot survive a refresh',
);
+// Typed scope must survive parsing and cannot silently choose the first key.
+assert.deepEqual(selectionFrom(new URLSearchParams('cluster=fixture-five-arm')), {
+ type: 'cluster',
+ id: 'fixture-five-arm',
+});
+assert.deepEqual(selectionFrom({ junction: '8005332807' }), { type: 'junction', id: '8005332807' });
+for (const invalid of [
+ { cluster: 'one', junction: 'two' },
+ { cluster: '' },
+ { cluster: {} },
+ new URLSearchParams('cluster=one&cluster=two'),
+]) {
+ assert.throws(() => selectionFrom(invalid), /selection/);
+}
+assert.throws(() => editPreview(area, { selection: { cluster: 'one', segment: 'two' } }), /selection/);
+
+const cluster = {
+ id: 'fixture-five-arm',
+ template: 'complex-junction-v1',
+ nodeIds: ['8005332807', '8024512135', '8024512145', '8024512147', '8613058676'],
+ coreRadiusMeters: 24,
+};
+const complexInput = {
+ ...input,
+ outDir: path.join(workspace, 'outputs', 'complex'),
+ stagingDir: path.join(workspace, 'outputs', '_complex'),
+ options: { edgeLines: false, junctionTemplates: { enabled: true, clusters: [cluster] } },
+};
+const complexArea = compileInput(complexInput).area;
+const clusterState = editState(complexArea, selectionFrom({ cluster: cluster.id }));
+assert.deepEqual(clusterState.handles.handles, [], 'cluster selection must never fall through to node handles');
+assert.deepEqual(clusterState.junctionStructure.junctionRef, { type: 'cluster', id: cluster.id });
+assert.equal(clusterState.junctionStructure.shape.effectiveArmCount, 5);
+assert.equal(clusterState.junctionStructure.capability.editable, false);
+const complexTracked = trackedFiles.map(({ file }) => ({
+ file,
+ bytes: fs.readFileSync(file),
+ mtimeMs: fs.statSync(file).mtimeMs,
+}));
+const emptyDocument = { ...clusterState.document, constraints: [], operations: [] };
+const clusterPreview = editPreview(complexArea, { document: emptyDocument, selection: { cluster: cluster.id } });
+assert.deepEqual(clusterPreview.handles.handles, []);
+assert.deepEqual(
+ clusterPreview.junctionStructure,
+ clusterState.junctionStructure,
+ 'preview and persisted compiler structure agree',
+);
+const browsing = browseState(complexArea);
+const unavailableStructureState = browseState({
+ ...complexArea,
+ nativeRoad: {
+ ...complexArea.nativeRoad,
+ junctionTemplates: {
+ ...complexArea.nativeRoad.junctionTemplates,
+ clusters: [
+ ...complexArea.nativeRoad.junctionTemplates.clusters,
+ { id: 'not-compiled', template: 'complex-junction-v1', nodeIds: ['missing-1', 'missing-2'] },
+ ],
+ },
+ },
+});
+assert.equal(unavailableStructureState.junctionStructures['cluster:not-compiled'], undefined);
+assert.ok(browsing.standardsDiagnostics.length, 'browse state retains structure diagnostics');
+assert.equal(new Set(browsing.standardsDiagnostics.map((item) => item.id)).size, browsing.standardsDiagnostics.length);
+assert.ok(
+ Object.values(browsing.junctionStructures).every(Boolean),
+ 'the structure index contains only available structures',
+);
+assert.deepEqual(browsing.junctionStructures[`cluster:${cluster.id}`], clusterState.junctionStructure);
+const simpleKey = Object.keys(browsing.junctionStructures).find(
+ (key) => key.startsWith('node:') && !cluster.nodeIds.includes(key.slice(5)),
+);
+assert.ok(simpleKey, 'fixture includes a simple junction outside the cluster');
+const simpleState = editState(complexArea, selectionFrom({ junction: simpleKey.slice(5) }));
+assert.deepEqual(simpleState.junctionStructure, browsing.junctionStructures[simpleKey]);
+assert.equal(simpleState.junctionStructure.junctionRef.type, 'node');
+for (const item of clusterState.standardsDiagnostics) {
+ assert.ok(browsing.standardsDiagnostics.some((candidate) => candidate.id === item.id));
+}
+assert.ok(simpleState.handles.handles.length);
+for (const type of ['cluster', 'junction']) {
+ const missing = editState(complexArea, selectionFrom({ [type]: 'missing-junction' }));
+ assert.equal(missing.junctionStructure, null);
+ assert.deepEqual(missing.handles.handles, []);
+ assert.deepEqual(missing.standardsDiagnostics, []);
+ assert.equal(
+ editPreview(complexArea, { document: emptyDocument, selection: { [type]: 'missing-junction' } }).junctionStructure,
+ null,
+ );
+}
+for (const tracked of complexTracked) {
+ assert.deepEqual(fs.readFileSync(tracked.file), tracked.bytes, 'scoped reads and previews preserve active files');
+ assert.equal(fs.statSync(tracked.file).mtimeMs, tracked.mtimeMs);
+}
+
fs.rmSync(workspace, { recursive: true, force: true });
console.log('workbench edit API tests passed');
diff --git a/workbench/client/src/App.tsx b/workbench/client/src/App.tsx
index 70e1a27..b722d54 100644
--- a/workbench/client/src/App.tsx
+++ b/workbench/client/src/App.tsx
@@ -57,6 +57,12 @@ import type { JunctionRef } from './junction/hotspots';
import { candidateForJunction, junctionDescriptors, hotspotAt } from './junction/hotspots';
import { JunctionWorkspace } from './junction/JunctionWorkspace';
import { localJunctionPreview, localJunctionState } from './junction/local-state';
+import {
+ junctionEditSelection,
+ junctionObjectFeatures,
+ junctionObjectKeyForFeature,
+ structureForJunction,
+} from './junction/structure';
import {
applyJunctionDraft,
cancelJunctionSession,
@@ -164,7 +170,7 @@ function App() {
editMode,
state,
selectedSegmentId: selected?.segmentId,
- selectedJunctionId: junctionRoute?.type === 'node' ? junctionRoute.id : undefined,
+ selectedJunction: junctionRoute,
setStatus,
});
const {
@@ -206,6 +212,17 @@ function App() {
() => (state && junctionDescriptor && junctionRoute ? localJunctionState(state, junctionDescriptor) : state),
[junctionDescriptor, junctionRoute, state],
);
+ const junctionStructure = useMemo(
+ () => (junctionRoute ? structureForJunction(state, junctionRoute) : null),
+ [junctionRoute, state],
+ );
+ const junctionSelectionFeatures = useMemo(
+ () => junctionObjectFeatures(state, junctionStructure, selectedObjectKey),
+ [state, junctionStructure, selectedObjectKey],
+ );
+ useEffect(() => {
+ setSelectedObjectKey(null);
+ }, [junctionRoute]);
const junctionMapPreview = useMemo(
() =>
state && junctionDescriptor && junctionRoute
@@ -417,12 +434,11 @@ function App() {
// fall back to the approach segment here: doing so makes an accepted preview
// replace the junction manifest with a road-scoped one, which drops the
// width/cutback/radius rows immediately after the first edit.
- selectionRef.current =
- junctionRoute?.type === 'node'
- ? { junction: junctionRoute.id }
- : selected?.segmentId
- ? { segment: selected.segmentId }
- : undefined;
+ selectionRef.current = junctionRoute
+ ? junctionEditSelection(junctionRoute)
+ : selected?.segmentId
+ ? { segment: selected.segmentId }
+ : undefined;
/**
* One gesture, one operation id. Minted on the first draft of a drag and cleared
* on release: reusing an id across gestures would put two operations with the
@@ -902,13 +918,15 @@ function App() {
};
const handleFeature = (properties: Record) => {
setMarking(properties);
- const objectKey = properties.signal_uid
- ? `signal:${String(properties.signal_uid)}`
- : properties.crossing_node_id
- ? `${properties.provenance === 'stop-line' ? 'stop-line' : 'crossing'}:${String(properties.crossing_node_id)}`
- : properties.road_id
- ? `road-arm:${String(properties.road_id)}`
- : null;
+ const objectKey = junctionStructure
+ ? junctionObjectKeyForFeature(junctionStructure, properties)
+ : properties.signal_uid
+ ? `signal:${String(properties.signal_uid)}`
+ : properties.crossing_node_id
+ ? `${properties.provenance === 'stop-line' ? 'stop-line' : 'crossing'}:${String(properties.crossing_node_id)}`
+ : properties.road_id
+ ? `road-arm:${String(properties.road_id)}`
+ : null;
setSelectedObjectKey(objectKey);
// A crosswalk is six features but one editable thing; a stop line is one.
// `provenance` picks which, and therefore which layer holds its siblings —
@@ -1065,6 +1083,7 @@ function App() {
scene={scene}
junctionHotspots={junctionHotspots}
junctionNodeMarkers={junctionNodeMarkers}
+ junctionSelectionFeatures={junctionSelectionFeatures}
referenceOpacity={referenceOpacity}
onJunctionHotspot={(ref: JunctionRef, _coordinate, descriptor) => {
openJunction(ref);
@@ -1080,6 +1099,7 @@ function App() {
onBackground={() => {
setElement(null);
setMarking(null);
+ setSelectedObjectKey(null);
}}
onSignalDrag={moveSignal}
onSignalDragEnd={finishSignalMove}
@@ -1178,7 +1198,7 @@ function App() {
descriptor={junctionDescriptor}
session={junctionSession}
dirty={Boolean(junctionSession.dirty || signalDirty)}
- state={state}
+ state={junctionMapState}
diagnostics={junctionDiagnostics}
selectedObjectKey={selectedObjectKey}
onSelectObject={(key) => setSelectedObjectKey(key)}
diff --git a/workbench/client/src/components/MapCanvas.tsx b/workbench/client/src/components/MapCanvas.tsx
index 4e5c6ef..f2edd62 100644
--- a/workbench/client/src/components/MapCanvas.tsx
+++ b/workbench/client/src/components/MapCanvas.tsx
@@ -1,5 +1,6 @@
import { useEffect, useRef } from 'react';
import Feature from 'ol/Feature';
+import GeoJSON from 'ol/format/GeoJSON';
import LineString from 'ol/geom/LineString';
import Map from 'ol/Map';
import Point from 'ol/geom/Point';
@@ -78,6 +79,8 @@ interface Props {
junctionHotspots?: boolean;
onJunctionHotspot?: (ref: JunctionRef, coordinate: Coordinate, descriptor: JunctionDescriptor) => void;
junctionNodeMarkers?: Array<{ coordinate: Coordinate; label: string; selected: boolean }>;
+ /** Read-only semantic object selection from the compiler's stable object keys. */
+ junctionSelectionFeatures?: GeoJson['features'];
referenceOpacity?: number;
}
export function MapCanvas({
@@ -115,6 +118,7 @@ export function MapCanvas({
junctionHotspots = true,
onJunctionHotspot,
junctionNodeMarkers = [],
+ junctionSelectionFeatures,
referenceOpacity = 0.55,
}: Props) {
const target = useRef(null);
@@ -129,6 +133,7 @@ export function MapCanvas({
const laneSelectionLayerRef = useRef | null>(null);
const signalTransformSourceRef = useRef(null);
const signalTransformLayerRef = useRef | null>(null);
+ const junctionSelectionLayerRef = useRef | null>(null);
const junctionNodeMarkerSourceRef = useRef(null);
const laneSelectionFeaturesRef = useRef([]);
const laneSelectionAnchorRef = useRef(null);
@@ -285,6 +290,7 @@ export function MapCanvas({
// road inspector, and dragging is owned by the edit interaction.
layers: (layer) =>
layer !== layers.selectedRoad &&
+ layer !== junctionSelectionLayerRef.current &&
layer !== handleLayer?.layer &&
layer !== laneSelectionLayer &&
layer !== signalTransformLayer &&
@@ -448,12 +454,40 @@ export function MapCanvas({
return () => {
select.un('select', listener);
junctionNodeMarkerSourceRef.current = null;
+ junctionSelectionLayerRef.current = null;
map.setTarget(undefined);
delete (target.current as HTMLDivElement & { __roadWorkbenchMap?: Map })?.__roadWorkbenchMap;
};
// Map construction must be once per mounted canvas; state changes update sources below.
// eslint-disable-next-line react-hooks/exhaustive-deps
}, []);
+ useEffect(() => {
+ const map = mapRef.current;
+ if (!map) return;
+ let layer = junctionSelectionLayerRef.current;
+ if (!layer && junctionSelectionFeatures?.length) {
+ layer = new VectorLayer({
+ source: new VectorSource(),
+ zIndex: 89,
+ style: new Style({
+ stroke: new Stroke({ color: '#0891b2', width: 3 }),
+ fill: new Fill({ color: 'rgba(8,145,178,0.16)' }),
+ image: new CircleStyle({ radius: 8, stroke: new Stroke({ color: '#0891b2', width: 3 }) }),
+ }),
+ });
+ junctionSelectionLayerRef.current = layer;
+ map.addLayer(layer);
+ }
+ const source = layer?.getSource();
+ if (!source) return;
+ source.clear();
+ source.addFeatures(
+ new GeoJSON().readFeatures(
+ { type: 'FeatureCollection', features: junctionSelectionFeatures || [] },
+ { dataProjection: 'EPSG:4326', featureProjection: 'EPSG:3857' },
+ ),
+ );
+ }, [junctionSelectionFeatures]);
useEffect(() => {
const source = junctionNodeMarkerSourceRef.current;
if (!source) return;
diff --git a/workbench/client/src/edit/types.ts b/workbench/client/src/edit/types.ts
index 81daa3f..2eb41b9 100644
--- a/workbench/client/src/edit/types.ts
+++ b/workbench/client/src/edit/types.ts
@@ -214,7 +214,7 @@ export interface EditStateResponse {
* renders about six handles. Wire form matches the `?segment=` / `?junction=`
* query the GET route accepts.
*/
-export type EditSelection = { segment: string } | { junction: string };
+export type EditSelection = { segment: string } | { junction: string } | { cluster: string };
/**
* `POST /api/edit-preview`. Sending `constraints` alone lets the server merge
diff --git a/workbench/client/src/hooks/useDirectEditSession.ts b/workbench/client/src/hooks/useDirectEditSession.ts
index f41f32a..e3e4f63 100644
--- a/workbench/client/src/hooks/useDirectEditSession.ts
+++ b/workbench/client/src/hooks/useDirectEditSession.ts
@@ -2,7 +2,8 @@ import { useEffect, useRef, useState } from 'react';
import { api } from '../lib/api';
import { EditSession } from '../edit/session';
import type { EditDiagnostic, HandleManifest, PreviewLayerName } from '../edit/types';
-import type { GeoJson, WorkbenchState } from '../types/state';
+import type { GeoJson, JunctionRef, WorkbenchState } from '../types/state';
+import { junctionEditSelection } from '../junction/structure';
/**
* Owns the stable v2 session and the server state that surrounds it. Gesture
@@ -12,13 +13,13 @@ export function useDirectEditSession({
editMode,
state,
selectedSegmentId,
- selectedJunctionId,
+ selectedJunction,
setStatus,
}: {
editMode: boolean;
state?: WorkbenchState;
selectedSegmentId?: string;
- selectedJunctionId?: string;
+ selectedJunction?: JunctionRef | null;
setStatus: (status: string) => void;
}) {
const [manifest, setManifest] = useState(null);
@@ -33,16 +34,18 @@ export function useDirectEditSession({
useEffect(() => {
// Flag off: no manifest request at all, so the network trace matches browse mode.
if (!editMode) return;
+ let current = true;
+ setManifest(null);
api
.editState(
- selectedJunctionId
- ? { junction: selectedJunctionId }
+ selectedJunction
+ ? junctionEditSelection(selectedJunction)
: selectedSegmentId
? { segment: selectedSegmentId }
: undefined,
)
.then((value) => {
- if (!('handles' in value)) return;
+ if (!current || !('handles' in value)) return;
setManifest(value.handles);
const key = `${value.areaId}:${value.documentVersion}`;
if (loadedDocument.current === key) return;
@@ -50,8 +53,13 @@ export function useDirectEditSession({
sessionRef.current?.load(value.document.constraints, value.document.operations, value.documentVersion);
touch();
})
- .catch((error: Error) => setStatus(`直接编辑手柄不可用:${error.message}`));
- }, [editMode, selectedJunctionId, selectedSegmentId, setStatus, state]);
+ .catch((error: Error) => {
+ if (current) setStatus(`直接编辑手柄不可用:${error.message}`);
+ });
+ return () => {
+ current = false;
+ };
+ }, [editMode, selectedJunction, selectedSegmentId, setStatus, state]);
return {
session: sessionRef.current,
diff --git a/workbench/client/src/junction/JunctionWorkspace.tsx b/workbench/client/src/junction/JunctionWorkspace.tsx
index dbf545f..d22b877 100644
--- a/workbench/client/src/junction/JunctionWorkspace.tsx
+++ b/workbench/client/src/junction/JunctionWorkspace.tsx
@@ -10,6 +10,7 @@ import type { WorkbenchState } from '../types/state';
import type { Coordinate } from '../edit/meters';
import { junctionLabelForHandle, junctionRoadName } from './labels';
import { junctionFacilities } from './facilities';
+import { junctionCapabilityReason, structureForJunction } from './structure';
import { SignalEditor } from '../components/ElementEditors';
interface Props {
@@ -175,7 +176,7 @@ export function JunctionWorkspace({
() => (state ? junctionFacilities(state, descriptor.nodeIds, roads) : []),
[descriptor.nodeIds, roads, state],
);
- const structure = state?.junctionStructure;
+ const structure = structureForJunction(state, descriptor.ref);
const standardDiagnostics = state?.standardsDiagnostics || [];
return (
@@ -237,6 +238,7 @@ export function JunctionWorkspace({
{state.junctionReference.source || '已加载参考文件'}
) : null}
+ {structure.capability?.reason ? {junctionCapabilityReason(structure.capability.reason)}
: null}
- 道路臂
-
@@ -248,6 +250,8 @@ export function JunctionWorkspace({
key={arm.key}
className={selectedObjectKey === arm.key ? 'is-selected' : undefined}
onClick={() => onSelectObject?.(arm.key)}
+ aria-pressed={selectedObjectKey === arm.key}
+ title={junctionCapabilityReason(arm.capability?.reason)}
>
{arm.label}
@@ -258,7 +262,26 @@ export function JunctionWorkspace({
)}
- 角部
- - {structure.corners.length ? structure.corners.map((corner) => corner.label).join('、') : '无'}
+ -
+ {structure.corners.length ? (
+
+ {structure.corners.map((corner) => (
+
+ ))}
+
+ ) : (
+ '无'
+ )}
+
- 设施
-
{structure.facilities.length ? (
@@ -270,7 +293,16 @@ export function JunctionWorkspace({
已识别 {structure.facilities.length} 项设施
{structure.facilities.map((facility) => (
- - {facility.label}
+ -
+
+
))}
diff --git a/workbench/client/src/junction/hotspots.ts b/workbench/client/src/junction/hotspots.ts
index 1faef0f..815cbf0 100644
--- a/workbench/client/src/junction/hotspots.ts
+++ b/workbench/client/src/junction/hotspots.ts
@@ -1,6 +1,7 @@
import type { Diagnostic, JunctionCandidate, Position, WorkbenchState, JunctionClusterConfig } from '../types/state';
-export type JunctionRef = { type: 'node' | 'cluster'; id: string };
+export type { JunctionRef } from '../types/state';
+import type { JunctionRef } from '../types/state';
export type JunctionHotspotStatus = 'editable' | 'readonly' | 'candidate';
export interface JunctionDescriptor {
ref: JunctionRef;
@@ -158,6 +159,24 @@ export function junctionDescriptors(state: WorkbenchState): JunctionDescriptor[]
const descriptor = candidateDescriptor(candidate, diagnostic, configured);
if (descriptor) result.push(descriptor);
}
+ // Compiler-owned topology replaces heuristic cluster footprints when available.
+ // This also works outside debug mode and excludes cluster-internal connections.
+ for (const structure of Object.values(state.junctionStructures || {})) {
+ if (structure.junctionRef?.type !== 'cluster' || !structure.center || !structure.provenance) continue;
+ const descriptor: JunctionDescriptor = {
+ ref: structure.junctionRef,
+ status: 'readonly',
+ coordinate: structure.center,
+ radiusMeters: 16,
+ nodeIds: structure.provenance.nodeIds,
+ approachRoadIds: structure.provenance.roadIds,
+ diagnosticIds: [],
+ source: 'cluster-config',
+ };
+ const existing = result.findIndex((item) => item.ref.type === 'cluster' && item.ref.id === descriptor.ref.id);
+ if (existing >= 0) result[existing] = descriptor;
+ else result.push(descriptor);
+ }
const unique = new Map();
for (const descriptor of result) {
const key = `${descriptor.ref.type}:${descriptor.ref.id}`;
diff --git a/workbench/client/src/junction/local-state.ts b/workbench/client/src/junction/local-state.ts
index 715af87..4034249 100644
--- a/workbench/client/src/junction/local-state.ts
+++ b/workbench/client/src/junction/local-state.ts
@@ -1,6 +1,7 @@
import type { GeoFeature, GeoJson, Road, WorkbenchState } from '../types/state';
import type { JunctionDescriptor } from './hotspots';
import type { PreviewLayerName } from '../edit/types';
+import { structureForJunction } from './structure';
const empty: GeoJson = { type: 'FeatureCollection', features: [] };
@@ -28,8 +29,16 @@ function text(value: unknown): string | null {
return typeof value === 'string' || typeof value === 'number' ? String(value) : null;
}
-function related(feature: GeoFeature, nodeIds: Set, roadIds: Set, segmentIds: Set): boolean {
+function related(
+ feature: GeoFeature,
+ nodeIds: Set,
+ roadIds: Set,
+ segmentIds: Set,
+ descriptor?: JunctionDescriptor,
+): boolean {
const props = feature.properties || {};
+ if (descriptor && props.junction_key) return props.junction_key === `${descriptor.ref.type}:${descriptor.ref.id}`;
+ if (descriptor?.ref.type === 'cluster' && props.cluster_id) return String(props.cluster_id) === descriptor.ref.id;
const nodeKeys = ['node_id', 'osm_node_id', 'control_id', 'crossing_node_id', 'junction_node_id'];
if (
nodeKeys.some((key) => {
@@ -75,7 +84,7 @@ export function localJunctionPreview(
if (value === null || value === undefined) continue;
scoped[name] = {
type: 'FeatureCollection',
- features: value.features.filter((feature) => related(feature, nodeIds, roadIds, segmentIds)),
+ features: value.features.filter((feature) => related(feature, nodeIds, roadIds, segmentIds, descriptor)),
};
}
return scoped;
@@ -92,7 +101,7 @@ export function localJunctionState(state: WorkbenchState, descriptor: JunctionDe
const segmentIds = new Set(roads.map((road) => road.segmentId));
const keep = (value: GeoJson | null | undefined): GeoJson => ({
type: 'FeatureCollection',
- features: (value?.features || []).filter((feature) => related(feature, nodeIds, roadIds, segmentIds)),
+ features: (value?.features || []).filter((feature) => related(feature, nodeIds, roadIds, segmentIds, descriptor)),
});
const layerNames = [
'nativeRoadSurface',
@@ -113,10 +122,16 @@ export function localJunctionState(state: WorkbenchState, descriptor: JunctionDe
layers.nativeRoadSurface = keep(state.layers.nativeRoadSurface);
layers.nativeIntersectionSurface = keep(state.layers.nativeIntersectionSurface);
const signals = state.trafficSignals.assemblies.features.filter((feature) =>
- related(feature, nodeIds, roadIds, segmentIds),
+ related(feature, nodeIds, roadIds, segmentIds, descriptor),
+ );
+ const structure = structureForJunction(state, descriptor.ref);
+ const objectKeys = new Set(
+ structure ? [...structure.arms, ...structure.corners, ...structure.facilities].map((object) => object.key) : [],
);
return {
...state,
+ junctionStructure: structure,
+ standardsDiagnostics: state.standardsDiagnostics?.filter((item) => objectKeys.has(item.objectKey)),
compiled: {
...state.compiled,
model: {
diff --git a/workbench/client/src/junction/structure.test.ts b/workbench/client/src/junction/structure.test.ts
new file mode 100644
index 0000000..2d5570a
--- /dev/null
+++ b/workbench/client/src/junction/structure.test.ts
@@ -0,0 +1,144 @@
+import { describe, expect, it } from 'vitest';
+import type { GeoFeature, JunctionStructure, WorkbenchState } from '../types/state';
+import { junctionDescriptors } from './hotspots';
+import { localJunctionPreview, localJunctionState } from './local-state';
+import {
+ junctionEditSelection,
+ junctionObjectFeatures,
+ junctionObjectKeyForFeature,
+ structureForJunction,
+} from './structure';
+
+const structure: JunctionStructure = {
+ schema: 'junction-structure/v1',
+ junctionKey: 'cluster:a',
+ junctionRef: { type: 'cluster', id: 'a' },
+ label: '路口 A',
+ center: [120, 30],
+ provenance: { nodeIds: ['1', '2'], roadIds: ['external'], segmentIds: ['external-segment'] },
+ capability: { editable: false, reason: 'complex-geometry-editing-not-implemented' },
+ shape: { kind: 't-junction', label: 'T 字', effectiveArmCount: 3, throughPairCount: 1 },
+ arms: ['a', 'b', 'c'].map((id) => ({ key: `arm:${id}`, label: `道路 ${id}`, directionality: 'two-way' })),
+ corners: [{ key: 'corner:a', label: '角部 A', fromArmKey: 'arm:a', toArmKey: 'arm:b' }],
+ facilities: [{ key: 'crossing:a', label: '过街 A', kind: 'crossing' }],
+};
+const feature = (object: string, junction = 'cluster:a', arm?: string): GeoFeature => ({
+ type: 'Feature',
+ properties: { junction_key: junction, object_key: object, arm_key: arm },
+ geometry: {
+ type: 'Polygon',
+ coordinates: [
+ [
+ [120, 30],
+ [120.001, 30],
+ [120, 30.001],
+ [120, 30],
+ ],
+ ],
+ },
+});
+const road = (id: string, nodes: string[]) => ({
+ id,
+ sourceNodeIds: nodes,
+ segmentId: `${id}-segment`,
+ centerline: [],
+ osmWayIds: [],
+ tags: {},
+ highway: 'residential',
+ direction: 'forward',
+ widthMeters: 7,
+ laneCount: 2,
+ sidewalkLeft: false,
+ sidewalkRight: false,
+});
+const state: WorkbenchState = {
+ areaId: 'test',
+ compiled: {
+ model: { roads: [road('external', ['1', '3']), road('internal', ['1', '2'])], endpoints: [], connections: [] },
+ diagnostics: [],
+ },
+ overrides: { schema: 'native-road-overrides/v1', overrides: [] },
+ trafficSignals: { provenance: 'empty', assemblies: { type: 'FeatureCollection', features: [] } },
+ trafficRuntime: { signals: [] },
+ comparison: {},
+ junctionStructures: { 'cluster:a': structure },
+ junctionStructure: structure,
+ layers: {
+ nativeRoadSurface: {
+ type: 'FeatureCollection',
+ features: [feature('carriageway:a', 'cluster:a', 'arm:a'), feature('carriageway:b', 'cluster:b', 'arm:a')],
+ },
+ crosswalks: {
+ type: 'FeatureCollection',
+ features: [feature('crossing:a'), feature('crossing:a'), feature('crossing:b', 'cluster:b')],
+ },
+ nativeIntersectionSurface: { type: 'FeatureCollection', features: [feature('corner:a')] },
+ },
+};
+
+describe('authoritative junction structures', () => {
+ it('uses typed scopes without leaking the legacy first structure', () => {
+ expect(junctionEditSelection({ type: 'cluster', id: 'a' })).toEqual({ cluster: 'a' });
+ expect(junctionEditSelection({ type: 'node', id: 'a' })).toEqual({ junction: 'a' });
+ expect(structureForJunction(state, { type: 'cluster', id: 'a' })).toBe(structure);
+ expect(structureForJunction(state, { type: 'node', id: 'a' })).toBeNull();
+ expect(structureForJunction(state, { type: 'cluster', id: 'missing' })).toBeNull();
+ });
+
+ it('makes map and list select the same arm, corner and crossing group', () => {
+ expect(junctionObjectKeyForFeature(structure, feature('carriageway:a', 'cluster:a', 'arm:a').properties!)).toBe(
+ 'arm:a',
+ );
+ expect(junctionObjectKeyForFeature(structure, feature('corner:a').properties!)).toBe('corner:a');
+ expect(junctionObjectKeyForFeature(structure, feature('crossing:a').properties!)).toBe('crossing:a');
+ expect(junctionObjectKeyForFeature(structure, feature('crossing:a', 'cluster:b').properties!)).toBeNull();
+ expect(junctionObjectFeatures(state, structure, 'arm:a')).toHaveLength(1);
+ expect(junctionObjectFeatures(state, structure, 'crossing:a')).toHaveLength(2);
+ expect(junctionObjectFeatures(state, structure, 'corner:a')).toHaveLength(1);
+ expect(junctionObjectFeatures(state, structure, 'deleted')).toEqual([]);
+ });
+
+ it('scopes the canvas and preview using cluster ownership, retaining core features without node IDs', () => {
+ const descriptor = junctionDescriptors(state).find((item) => item.ref.type === 'cluster')!;
+ expect(descriptor.status).toBe('readonly');
+ expect(descriptor.approachRoadIds).toEqual(['external']);
+ const local = localJunctionState(state, descriptor);
+ expect(local.compiled.model.roads.map((item) => item.id)).toEqual(['external']);
+ expect(local.junctionStructure).toBe(structure);
+ expect(local.layers.nativeRoadSurface?.features).toHaveLength(1);
+ expect(local.layers.nativeIntersectionSurface?.features).toHaveLength(1);
+ const preview = localJunctionPreview(
+ { roadSurface: state.layers.nativeRoadSurface },
+ descriptor,
+ state.compiled.model.roads,
+ );
+ expect(preview?.roadSurface?.features).toHaveLength(1);
+ });
+
+ it('resolves separately persisted signals through scoped provenance without parsing their IDs', () => {
+ const signal = { ...feature('unused'), properties: { signal_uid: 'raw:signal:uid' } };
+ const withSignal = {
+ ...structure,
+ facilities: [
+ ...structure.facilities,
+ {
+ key: 'cluster:a:signal:raw',
+ kind: 'signal',
+ label: '信号灯',
+ geometryRef: 'raw:signal:uid',
+ provenance: { featureIds: ['raw:signal:uid'] },
+ },
+ ],
+ };
+ const signalState = {
+ ...state,
+ trafficSignals: {
+ ...state.trafficSignals,
+ assemblies: { ...state.trafficSignals.assemblies, features: [signal] },
+ },
+ };
+ expect(junctionObjectKeyForFeature(withSignal, signal.properties)).toBe('cluster:a:signal:raw');
+ expect(junctionObjectFeatures(signalState, withSignal, 'cluster:a:signal:raw')).toEqual([signal]);
+ expect(junctionObjectKeyForFeature(structure, signal.properties)).toBeNull();
+ });
+});
diff --git a/workbench/client/src/junction/structure.ts b/workbench/client/src/junction/structure.ts
new file mode 100644
index 0000000..903dc5e
--- /dev/null
+++ b/workbench/client/src/junction/structure.ts
@@ -0,0 +1,79 @@
+import type { GeoFeature, JunctionRef, JunctionStructure, WorkbenchState } from '../types/state';
+import type { EditSelection } from '../edit/types';
+
+export function junctionEditSelection(ref: JunctionRef): EditSelection {
+ return ref.type === 'cluster' ? { cluster: ref.id } : { junction: ref.id };
+}
+
+/** A missing scoped structure must never show another junction's first result. */
+export function structureForJunction(state: WorkbenchState | undefined, ref: JunctionRef): JunctionStructure | null {
+ const structure = state?.junctionStructures?.[`${ref.type}:${ref.id}`] ?? state?.junctionStructure;
+ if (!structure) return null;
+ return structure.junctionRef?.type === ref.type && structure.junctionRef.id === ref.id ? structure : null;
+}
+
+function objects(structure: JunctionStructure) {
+ return [...structure.arms, ...structure.corners, ...structure.facilities];
+}
+
+export function junctionCapabilityReason(reason: string | undefined): string | undefined {
+ if (!reason) return undefined;
+ switch (reason) {
+ case 'complex-geometry-editing-not-implemented':
+ return '当前可查看和选择,参数编辑将在后续阶段开放。';
+ case 'source-missing':
+ return '对象来源已缺失,暂不可编辑。';
+ case 'source-ambiguous':
+ return '对象来源存在歧义,暂不可编辑。';
+ default:
+ return '当前对象暂不可编辑。';
+ }
+}
+
+export function junctionObjectKeyForFeature(
+ structure: JunctionStructure | null,
+ properties: Record,
+): string | null {
+ if (!structure) return null;
+ if (properties.junction_key && properties.junction_key !== structure.junctionKey) return null;
+ const keys = [properties.object_key, properties.facility_key, properties.corner_key, properties.arm_key];
+ const candidates = objects(structure);
+ for (const key of keys) {
+ if (typeof key === 'string' && candidates.some((object) => object.key === key)) return key;
+ }
+ // Signals are a separate persisted layer. The server attaches their existing
+ // UID to the scoped structure without rewriting the signal document.
+ if (typeof properties.signal_uid === 'string') {
+ return (
+ structure.facilities.find(
+ (object) => object.kind === 'signal' && object.provenance?.featureIds?.includes(String(properties.signal_uid)),
+ )?.key ?? null
+ );
+ }
+ if (structure.junctionRef?.type === 'node') {
+ const ids = [properties.native_id, properties.signal_uid, properties.road_id];
+ return candidates.find((object) => object.geometryRef && ids.includes(object.geometryRef))?.key ?? null;
+ }
+ return null;
+}
+
+/** Resolve the selected semantic object to its published map features. */
+export function junctionObjectFeatures(
+ state: WorkbenchState | undefined,
+ structure: JunctionStructure | null,
+ key: string | null,
+): GeoFeature[] {
+ if (!state || !structure || !key || !objects(structure).some((object) => object.key === key)) return [];
+ const seen = new Set();
+ return [...Object.values(state.layers), state.trafficSignals.assemblies].flatMap((layer) =>
+ (layer?.features ?? []).filter((feature) => {
+ if (seen.has(feature)) return false;
+ seen.add(feature);
+ const properties = feature.properties || {};
+ if (typeof properties.signal_uid === 'string') return junctionObjectKeyForFeature(structure, properties) === key;
+ if (structure.junctionRef?.type === 'node') return junctionObjectKeyForFeature(structure, properties) === key;
+ if (properties.junction_key !== structure.junctionKey) return false;
+ return [properties.object_key, properties.arm_key, properties.corner_key, properties.facility_key].includes(key);
+ }),
+ );
+}
diff --git a/workbench/client/src/types/state.ts b/workbench/client/src/types/state.ts
index e6aaa43..526fba0 100644
--- a/workbench/client/src/types/state.ts
+++ b/workbench/client/src/types/state.ts
@@ -87,19 +87,62 @@ export interface Diagnostic {
geometry?: { type: string; coordinates: unknown };
manualCandidates?: Array<{ roadId: string; distanceMeters: number }>;
}
+export type JunctionRef = { type: 'node' | 'cluster'; id: string };
+export interface JunctionProvenance {
+ nodeIds?: string[];
+ segmentIds?: string[];
+ roadIds?: string[];
+ osmWayIds?: string[];
+ carriagewayKeys?: string[];
+ armKeys?: string[];
+ featureIds?: string[];
+}
+export interface JunctionSource extends JunctionProvenance {
+ nodeIds: string[];
+ segmentIds: string[];
+ roadIds: string[];
+}
+export interface JunctionCapability {
+ editable: boolean;
+ reason?: string;
+}
+export interface JunctionObject {
+ key: string;
+ label: string;
+ geometryRef?: string;
+ geometryRefs?: string[];
+ provenance?: JunctionProvenance;
+ capability?: JunctionCapability;
+}
export interface JunctionStructure {
schema: string;
junctionKey: string;
+ junctionRef?: JunctionRef;
+ topologyFingerprint?: string;
+ provenance?: JunctionSource;
+ capability?: JunctionCapability;
+ center?: Position;
label: string;
shape: { kind: string; label: string; effectiveArmCount: number; throughPairCount: number };
- arms: Array<{
- key: string;
- label: string;
- directionality: string;
- carriageway?: { laneCount?: number; effectiveWidthMeters?: number };
- }>;
- corners: Array<{ key: string; label: string; fromArmKey: string; toArmKey: string }>;
- facilities: Array<{ key: string; kind: string; label: string }>;
+ arms: Array<
+ JunctionObject & {
+ heading?: number;
+ directionality: string;
+ carriageway?: { laneCount?: number; effectiveWidthMeters?: number };
+ carriageways?: Array<{
+ key: string;
+ geometryRef: string;
+ laneCount: number;
+ effectiveWidthMeters: number;
+ provenance: JunctionSource;
+ capability: JunctionCapability;
+ }>;
+ }
+ >;
+ corners: Array;
+ facilities: Array<
+ JunctionObject & { kind: string; armKey?: string; cornerKey?: string; relatedFacilityKey?: string }
+ >;
}
export interface StandardsDiagnostic {
id: string;
@@ -133,6 +176,7 @@ export interface WorkbenchState {
junctionShapes?: JunctionShapeSummary[];
} | null;
junctionStructure?: JunctionStructure | null;
+ junctionStructures?: Record;
standardsProfile?: { id: string; label: string };
standardsDiagnostics?: StandardsDiagnostic[];
}
diff --git a/workbench/server.js b/workbench/server.js
index e63fcf7..de724e9 100644
--- a/workbench/server.js
+++ b/workbench/server.js
@@ -247,7 +247,38 @@ function state(area, junctionReference = null, debug = false) {
const trafficRuntime = runtime(trafficSignals);
const compiled = readCompiled(area);
const layers = readWorkbenchLayers(nativeDir, osm2streetsRoadSurface);
- const junctionStructure = projectJunctionStructure({ model: compiled.model, layers, trafficSignals });
+ const clusters = area.nativeRoad?.junctionTemplates?.clusters || [];
+ const nodeSegments = new Map();
+ const roadsById = new Map((compiled.model.roads || []).map((road) => [road.id, road]));
+ for (const endpoint of compiled.model.endpoints || []) {
+ const id = String(endpoint.nodeId);
+ if (!nodeSegments.has(id)) nodeSegments.set(id, new Set());
+ nodeSegments.get(id).add(roadsById.get(endpoint.roadId)?.segmentId || endpoint.roadId);
+ }
+ const refs = [
+ ...[...nodeSegments].filter(([, segments]) => segments.size >= 2).map(([id]) => ({ type: 'node', id })),
+ ...clusters.map((cluster) => ({ type: 'cluster', id: String(cluster.id) })),
+ ];
+ const junctionStructures = Object.fromEntries(
+ refs
+ .map((junctionRef) => [
+ `${junctionRef.type}:${junctionRef.id}`,
+ projectJunctionStructure({
+ model: compiled.model,
+ layers: {
+ ...layers,
+ roadSurface: layers.nativeRoadSurface,
+ intersectionSurface: layers.nativeIntersectionSurface,
+ sidewalkSurface: layers.nativeSidewalkSurface,
+ },
+ trafficSignals,
+ junctionRef,
+ clusters,
+ }),
+ ])
+ .filter(([, structure]) => structure !== null),
+ );
+ const junctionStructure = null;
const junctionShapes = debug
? (readLayer(path.join(nativeDir, 'layers', 'road_surface.geojson')).features || [])
.filter((feature) => feature.properties?.kind === 'complex-core' && feature.properties?.cluster_id)
@@ -276,9 +307,16 @@ function state(area, junctionReference = null, debug = false) {
}
: null,
compiled,
+ junctionStructures,
junctionStructure,
standardsProfile: { id: 'cn-urban-default', label: '中国城市道路(项目默认)' },
- standardsDiagnostics: standardsDiagnostics(junctionStructure),
+ standardsDiagnostics: [
+ ...new Map(
+ Object.values(junctionStructures)
+ .flatMap((structure) => standardsDiagnostics(structure))
+ .map((item) => [item.id, item]),
+ ).values(),
+ ],
overrides: loadOverrides(area.outputs.nativeRoadOverrides),
trafficSignals,
trafficRuntime,
@@ -323,11 +361,28 @@ function activeRevisionFields(area) {
// while the map renders about six handles. Omitting it keeps the full manifest for
// callers that want it.
function selectionFrom(source) {
- if (!source) return null;
- const segment = source.segment ?? source.get?.('segment');
- if (segment) return { type: 'segment', id: String(segment) };
- const junction = source.junction ?? source.get?.('junction');
- if (junction) return { type: 'junction', id: String(junction) };
+ if (source == null) return null;
+ if (typeof source !== 'object' || Array.isArray(source)) throw new Error('selection must be an object.');
+ const keys = ['segment', 'junction', 'cluster'];
+ const entries = keys.flatMap((key) => {
+ if (typeof source.getAll === 'function') return source.getAll(key).map((value) => [key, value]);
+ return Object.hasOwn(source, key) ? [[key, source[key]]] : [];
+ });
+ if (entries.length > 1) throw new Error('selection must specify only one of segment, junction, or cluster.');
+ if (!entries.length) return null;
+ const [key, value] = entries[0];
+ if (
+ (typeof value !== 'string' && typeof value !== 'number') ||
+ !String(value).trim() ||
+ (typeof value === 'number' && !Number.isFinite(value))
+ )
+ throw new Error(`selection.${key} must be a non-empty ID.`);
+ return { type: key, id: String(value).trim() };
+}
+
+function junctionRefFromSelection(selection) {
+ if (selection?.type === 'junction') return { type: 'node', id: selection.id };
+ if (selection?.type === 'cluster') return { type: 'cluster', id: selection.id };
return null;
}
@@ -339,13 +394,21 @@ function editState(area, selection = null) {
const resolution = resolveDirectEditConstraints(model, directEdits, {
revisionId: initialized.active.activeRevisionId,
compilerGeometryVersion: GEOMETRY_VERSION,
+ junctionTemplates: area.nativeRoad?.junctionTemplates,
selection,
});
const compiled = readCompiled(area);
const layers = readWorkbenchLayers(area.outputs.nativeRoadDir, null);
const junctionStructure = projectJunctionStructure({
model: compiled.model,
- layers,
+ junctionRef: junctionRefFromSelection(selection),
+ clusters: area.nativeRoad?.junctionTemplates?.clusters || [],
+ layers: {
+ ...layers,
+ roadSurface: layers.nativeRoadSurface,
+ intersectionSurface: layers.nativeIntersectionSurface,
+ sidewalkSurface: layers.nativeSidewalkSurface,
+ },
trafficSignals: readJson(area.outputs.nativeTrafficSignals),
});
return {
@@ -381,12 +444,14 @@ function editPreview(area, body = {}) {
const activeState = readJson(activeStateFile);
const persistedOverrides = loadOverrides(area.outputs.nativeRoadOverrides);
const model = compileRoadModel(fs.readFileSync(area.input, 'utf8'), persistedOverrides);
+ const selection = selectionFrom(body.selection);
const previewSeq = Number.isInteger(body.previewSeq) ? body.previewSeq : 0;
const resolution = resolveDirectEditConstraints(model, draft, {
revisionId: activeState.activeRevisionId,
previewSeq,
compilerGeometryVersion: GEOMETRY_VERSION,
- selection: selectionFrom(body.selection),
+ junctionTemplates: area.nativeRoad?.junctionTemplates,
+ selection,
});
const compiled = compileGeometry(model, persistedOverrides, {
edgeLines: area.nativeRoad.edgeLines,
@@ -396,7 +461,14 @@ function editPreview(area, body = {}) {
const diagnostics = [...compiled.diagnostics, ...resolution.diagnostics];
const junctionStructure = projectJunctionStructure({
model,
+ junctionRef: junctionRefFromSelection(selection),
+ clusters: area.nativeRoad?.junctionTemplates?.clusters || [],
layers: {
+ roadSurface: compiled.roadSurface,
+ sidewalkSurface: compiled.sidewalkSurface,
+ islands: compiled.intersectionSurface,
+ medians: compiled.intersectionSurface,
+ sidewalkTurns: compiled.sidewalkSurface,
crosswalks: compiled.crosswalks,
vehicleStopLines: compiled.vehicleStopLines,
intersectionSurface: compiled.intersectionSurface,
@@ -456,6 +528,7 @@ function saveEdits(area, body = {}) {
const resolution = resolveDirectEditConstraints(model, candidate, {
revisionId: initialized.active.activeRevisionId,
compilerGeometryVersion: GEOMETRY_VERSION,
+ junctionTemplates: area.nativeRoad?.junctionTemplates,
});
const blockingDiagnostic = resolution.diagnostics.find((item) => item.severity === 'error');
if (blockingDiagnostic) {
@@ -484,6 +557,7 @@ function rebaseEdits(area, revisionId) {
const resolution = resolveDirectEditConstraints(model, revision.directEdits, {
revisionId,
compilerGeometryVersion: GEOMETRY_VERSION,
+ junctionTemplates: area.nativeRoad?.junctionTemplates,
replay: true,
});
const counts = Object.fromEntries(
@@ -750,4 +824,13 @@ function sendJson(response, status, value) {
response.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' });
response.end(`${JSON.stringify(value)}\n`);
}
-module.exports = { startWorkbench, readMultipart, editState, editPreview, saveEdits, rebaseEdits };
+module.exports = {
+ startWorkbench,
+ readMultipart,
+ state,
+ selectionFrom,
+ editState,
+ editPreview,
+ saveEdits,
+ rebaseEdits,
+};