@sentropic/design-system-svelte 0.39.0 → 0.41.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (42) hide show
  1. package/LICENSE.THIRD-PARTY.md +2 -1
  2. package/README.md +7 -0
  3. package/dist/Dc2bContentSizeFixture.svelte.d.ts +10 -0
  4. package/dist/Dc2bContentSizeFixture.svelte.d.ts.map +1 -0
  5. package/dist/DiagramCard.svelte +25 -36
  6. package/dist/DiagramCard.svelte.d.ts +4 -8
  7. package/dist/DiagramCard.svelte.d.ts.map +1 -1
  8. package/dist/DiagramCardHeader.svelte +11 -10
  9. package/dist/DiagramCardHeader.svelte.d.ts.map +1 -1
  10. package/dist/DiagramSceneFigure.svelte +1207 -0
  11. package/dist/DiagramSceneFigure.svelte.d.ts +134 -0
  12. package/dist/DiagramSceneFigure.svelte.d.ts.map +1 -0
  13. package/dist/DiagramZone.svelte +21 -47
  14. package/dist/DiagramZone.svelte.d.ts +2 -4
  15. package/dist/DiagramZone.svelte.d.ts.map +1 -1
  16. package/dist/DiagramZoneHeader.svelte +2 -1
  17. package/dist/DiagramZoneHeader.svelte.d.ts.map +1 -1
  18. package/dist/diagram-icons/PROVENANCE.md +4 -0
  19. package/dist/diagram-icons/registry.d.ts.map +1 -1
  20. package/dist/diagram-icons/registry.js +2 -1
  21. package/dist/diagram-render/renderCardSvg.d.ts +5 -15
  22. package/dist/diagram-render/renderCardSvg.d.ts.map +1 -1
  23. package/dist/diagram-render/renderCardSvg.js +9 -15
  24. package/dist/diagram-render/renderZoneSvg.d.ts +2 -11
  25. package/dist/diagram-render/renderZoneSvg.d.ts.map +1 -1
  26. package/dist/diagram-render/renderZoneSvg.js +5 -10
  27. package/dist/diagramCardModel.d.ts +2 -581
  28. package/dist/diagramCardModel.d.ts.map +1 -1
  29. package/dist/diagramCardModel.js +2 -1133
  30. package/dist/diagramFontMeasure.d.ts +5 -0
  31. package/dist/diagramFontMeasure.d.ts.map +1 -0
  32. package/dist/diagramFontMeasure.js +41 -0
  33. package/dist/diagramRenderedBounds.d.ts +6 -0
  34. package/dist/diagramRenderedBounds.d.ts.map +1 -0
  35. package/dist/diagramRenderedBounds.js +51 -0
  36. package/dist/diagramSceneModel.d.ts +162 -0
  37. package/dist/diagramSceneModel.d.ts.map +1 -0
  38. package/dist/diagramSceneModel.js +309 -0
  39. package/dist/index.d.ts +6 -0
  40. package/dist/index.d.ts.map +1 -1
  41. package/dist/index.js +2 -0
  42. package/package.json +9 -5
@@ -0,0 +1,1207 @@
1
+ <script lang="ts">
2
+ import { getDiagramGlyph } from "./diagram-icons/registry.js";
3
+ import { tick, untrack } from "svelte";
4
+ import { Minus, Plus } from "@lucide/svelte";
5
+ import {
6
+ renderErdCardSvg, renderErdTable,
7
+ clampZoom,
8
+ createLayoutCache,
9
+ FIT_ASPECT,
10
+ zoomReadout,
11
+ type LayoutHints,
12
+ type LayoutMetrics,
13
+ type LayoutOptions,
14
+ type LayoutResult,
15
+ type LineMeasurer,
16
+ type Rect,
17
+ type RowPackOptions,
18
+ } from "@sentropic/diagram-canvas";
19
+ import Button from "./Button.svelte";
20
+ import DiagramCard from "./DiagramCard.svelte";
21
+ import DiagramZone from "./DiagramZone.svelte";
22
+ import IconButton from "./IconButton.svelte";
23
+ import { measureRenderedBounds } from "./diagramRenderedBounds.js";
24
+ import { measureRenderedSceneFont } from "./diagramFontMeasure.js";
25
+ import Select from "./Select.svelte";
26
+ import { DEFAULT_FLOW_TOKENS, type FlowTokens } from "@sentropic/diagram-canvas";
27
+ import { INITIAL_FLOW_STATE, DEFAULT_FLOW_STRINGS, visibleOf, effectiveTarget, highlightOf, flowStateOf, reduce, describeTarget, announce, flowHitSize, stepChange, stepsOf, type FlowState, type FlowAction, type Visible, type StepChange, type EffectiveTarget, type FlowStrings } from "@sentropic/diagram-canvas/flowModel";
28
+ import {
29
+ cardLineMeasurer,
30
+ sceneCardMeasure,
31
+ defaultCardMeasure,
32
+ projectCardProps,
33
+ projectZoneProps,
34
+ type CardLineMeasure,
35
+ type DiagramGlyphPaths,
36
+ } from "./diagramCardModel.js";
37
+ import {
38
+ collapsedOccurrencesOf,
39
+ sceneContentSize,
40
+ type DiagramSceneSize,
41
+ type SceneLayoutCache,
42
+ DEFAULT_SCENE_TARGET_WIDTH,
43
+ displayedRects,
44
+ layoutScene,
45
+ parseDurationMs,
46
+ parseEasing,
47
+ parseScale,
48
+ rectsOf,
49
+ resolveScene,
50
+ resolveZoom,
51
+ sameRects,
52
+ sceneFit,
53
+ sceneTextRows,
54
+ scenePlacement,
55
+ WHEEL_ZOOM_RATE,
56
+ ZOOM_STEP_RATIO,
57
+ type Easing,
58
+ type SceneDocument,
59
+ type SceneModel,
60
+ type SceneNodeModel,
61
+ type SceneOccurrenceRef,
62
+ type SceneOrientations,
63
+ type ScenePresentation,
64
+ type SceneView,
65
+ } from "@sentropic/diagram-canvas/diagramSceneModel";
66
+
67
+ /**
68
+ * `DiagramSceneFigure` — the generic scene host (DC-2a lot L4,
69
+ * SPEC_EVOL_DC2A §4.3, §5, §6.7 and Appendix D; CARDS §7.6).
70
+ *
71
+ * The figure lays a scene out with the `@sentropic/diagram-canvas`
72
+ * row-pack engine and draws it at emitted geometry with `DiagramCard` /
73
+ * `DiagramZone`. It keeps no packer of its own.
74
+ *
75
+ * Camera (Z-1–Z-8). Readout 100 % is the maximum display scale (token
76
+ * `diagramScene.maxDisplayScale`), never zoom 1: no input — buttons,
77
+ * keys, Ctrl + wheel, pinch, `setZoom` — goes above it. The fit frames
78
+ * the scene bounds plus the placed label boxes on both axes inside the
79
+ * fit box `viewW × min(viewW × 9/16, 0.85 × windowH)`. Fit reaches the
80
+ * whole rendered drawing, including below the readability preference.
81
+ * Zooming in scrolls the overflowing axis from its start. The camera is never seeded from the
82
+ * layout fit report. Zoom is a transform: it re-runs no layout.
83
+ *
84
+ * Folds. A fold toggle re-runs the whole layout, feeding the previous
85
+ * orientation record back so a level keeps its orientation inside the
86
+ * hysteresis band (O-4), reclamps the zoom into the new range, then
87
+ * moves every box from its displayed to its new rectangle over the
88
+ * `diagramScene.transitionDuration` token with the
89
+ * `foundation.motion.easing` token. Under `prefers-reduced-motion:
90
+ * reduce`, read at toggle time, the new geometry applies at once. A
91
+ * toggle during a transition retargets from the displayed rectangles.
92
+ *
93
+ * The figure owns no model: the documents are props, and the fold state
94
+ * is either controlled (`collapsed` + `onFoldChange`) or starts from
95
+ * `defaultFolds` / the source view's fold groups.
96
+ *
97
+ * SSR-safe: `window`, `document` and the observers are read in effects
98
+ * and handlers only; a server render draws the scene at its fit in a
99
+ * nominal 16:9 box.
100
+ */
101
+ export interface DiagramSceneFigureLabels {
102
+ navigator: string;
103
+ step: string;
104
+ scenario: string;
105
+ count: string;
106
+ node: string;
107
+ previous: string;
108
+ next: string;
109
+ allScenarios: string;
110
+ /** Accessible name of the camera control group. */
111
+ controls: string;
112
+ zoomIn: string;
113
+ zoomOut: string;
114
+ /** Visible text of the fit / reset control (« Ajuster »). */
115
+ fit: string;
116
+ /** Accessible name of the readout, e.g. « Zoom 85 % ». */
117
+ zoomLevel: (percent: number) => string;
118
+ /** Accessible name of the scrollable drawing region. */
119
+ viewport: string;
120
+ expand: (title: string) => string;
121
+ collapse: (title: string) => string;
122
+ }
123
+
124
+ export interface DiagramSceneCamera {
125
+ readonly zoom: number;
126
+ /** `round(zoom / maxDisplayScale × 100)`. */
127
+ readonly readout: number;
128
+ readonly minZoom: number;
129
+ readonly maxZoom: number;
130
+ /** The zoom a fit or reset applies. */
131
+ readonly fitZoom: number;
132
+ readonly pans: boolean;
133
+ }
134
+
135
+ export interface DiagramSceneFigureProps {
136
+ flows?: { fanOutMax?: number };
137
+ scenario?: string | null;
138
+ defaultScenario?: string;
139
+ activeStep?: string | null;
140
+ defaultActiveStep?: string;
141
+ onStepChange?: (change: StepChange | null) => void;
142
+ onScenarioChange?: (scenario: string | null) => void;
143
+ onHighlightChange?: (target: EffectiveTarget | null) => void;
144
+ document: SceneDocument;
145
+ /** Retained source view (occurrences, fold groups). Optional: the engine synthesises one. */
146
+ view?: SceneView;
147
+ registry: LayoutOptions["registry"];
148
+ bindings?: LayoutOptions["bindings"];
149
+ presentation: ScenePresentation;
150
+ /** Declaration order (`rootOrder`, `ordering[parent]`) and the other layout hints. */
151
+ hints?: LayoutHints;
152
+ /** Runtime token numbers for the engine (gaps, caps). */
153
+ metrics?: Partial<LayoutMetrics>;
154
+ rowPack?: RowPackOptions;
155
+ /** L-R7 report width. The measured path never re-packs on it (D-3). */
156
+ targetWidth?: number;
157
+ /** Card text measurer, shared by the cards, the zones and the layout. */
158
+ measure?: CardLineMeasure;
159
+ /** Layout line measurer. Defaults to the bridge over `measure`. */
160
+ measureLines?: LineMeasurer;
161
+ /** Controlled fold state: collapsed occurrence ids. */
162
+ collapsed?: readonly SceneOccurrenceRef[];
163
+ /** Initial collapsed occurrence ids when `collapsed` is not controlled. */
164
+ defaultFolds?: readonly SceneOccurrenceRef[];
165
+ title?: string;
166
+ /** Accessible name of the figure. Defaults to `title`. */
167
+ label?: string;
168
+ compact?: boolean;
169
+ labels?: Partial<DiagramSceneFigureLabels>;
170
+ iconBindings?: import("@sentropic/diagram-canvas/diagramSceneModel").SceneIconBindings;
171
+ strictIcons?: boolean;
172
+ resolveGlyph?: (name: string) => DiagramGlyphPaths | undefined;
173
+ onFoldChange?: (
174
+ collapsed: readonly SceneOccurrenceRef[],
175
+ change: { occurrence: SceneOccurrenceRef; collapsed: boolean },
176
+ ) => void;
177
+ onSelect?: (event: { entityId: string }) => void;
178
+ /** One call per layout pass, with the engine result (warnings, refusals, orientations). */
179
+ onLayout?: (result: LayoutResult) => void;
180
+ onCameraChange?: (camera: DiagramSceneCamera) => void;
181
+ layoutCache?: SceneLayoutCache;
182
+ contentSize?: DiagramSceneSize;
183
+ onSizeChange?: (size: DiagramSceneSize) => void;
184
+ }
185
+
186
+ const DEFAULT_LABELS: DiagramSceneFigureLabels = {
187
+ ...DEFAULT_FLOW_STRINGS,
188
+ controls: "Zoom",
189
+ zoomIn: "Zoom in",
190
+ zoomOut: "Zoom out",
191
+ fit: "Fit",
192
+ zoomLevel: (percent) => `Zoom ${percent} %`,
193
+ viewport: "Diagram",
194
+ expand: (title) => `Expand ${title}`,
195
+ collapse: (title) => `Collapse ${title}`,
196
+ };
197
+
198
+ const TOKEN_MAX_DISPLAY_SCALE = "--st-component-diagramScene-maxDisplayScale";
199
+ const TOKEN_MIN_READABLE_SCALE = "--st-component-diagramScene-minReadableScale";
200
+ const TOKEN_TRANSITION_DURATION = "--st-component-diagramScene-transitionDuration";
201
+ const TOKEN_EASING = "--st-foundation-motion-easing";
202
+ const REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
203
+
204
+ let {
205
+ document: semanticDocument,
206
+ view,
207
+ registry,
208
+ bindings,
209
+ presentation,
210
+ hints,
211
+ metrics,
212
+ rowPack,
213
+ targetWidth,
214
+ measure = defaultCardMeasure,
215
+ measureLines,
216
+ collapsed,
217
+ defaultFolds,
218
+ title,
219
+ label,
220
+ compact = false,
221
+ labels,
222
+ resolveGlyph = getDiagramGlyph,
223
+ iconBindings,
224
+ strictIcons = true,
225
+ onFoldChange,
226
+ onSelect,
227
+ onLayout,
228
+ onCameraChange,
229
+ layoutCache,
230
+ contentSize = $bindable({ width: 0, height: 0 }),
231
+ onSizeChange,
232
+ flows,
233
+ scenario,
234
+ defaultScenario,
235
+ activeStep,
236
+ defaultActiveStep,
237
+ onStepChange,
238
+ onScenarioChange,
239
+ onHighlightChange,
240
+ }: DiagramSceneFigureProps = $props();
241
+
242
+ const ownedCache = createLayoutCache();
243
+ let publishedSize: DiagramSceneSize | undefined;
244
+
245
+ const strings = $derived({ ...DEFAULT_LABELS, ...labels });
246
+ const flowOptions = $derived({ ...flows, countTemplate: strings.count });
247
+ let flowTokens = $state.raw<FlowTokens>(DEFAULT_FLOW_TOKENS);
248
+
249
+ /* ── fold state and layout ─────────────────────────────────────── */
250
+
251
+ let foldState = $state.raw<readonly SceneOccurrenceRef[]>(
252
+ untrack(() => defaultFolds ?? collapsedOccurrencesOf(view)),
253
+ );
254
+ const collapsedNow = $derived(collapsed ?? foldState);
255
+ const arrowInstance = $props.id();
256
+ const arrowId = "diagram-arrow-" + arrowInstance;
257
+ let browserMeasure = $state.raw<CardLineMeasure>();
258
+ const effectiveMeasure = $derived(sceneCardMeasure(measure === defaultCardMeasure ? browserMeasure ?? measure : measure));
259
+ let tokenMetrics = $state.raw<Partial<LayoutMetrics>>({});
260
+ const effectiveMetrics = $derived({ ...tokenMetrics, ...metrics });
261
+ const lineMeasurer = $derived<LineMeasurer>(measureLines ?? cardLineMeasurer(effectiveMeasure));
262
+
263
+ // O-4: the orientation record last emitted, fed back to the next layout
264
+ // call. Deliberately not reactive state: it is an input of the next pass,
265
+ // never a reason to run one. A different document starts with no record.
266
+ let previousOrientation: SceneOrientations | undefined;
267
+ let orientationDocument: string | undefined;
268
+
269
+ const layoutResult = $derived.by<LayoutResult>(() => {
270
+ if (orientationDocument !== semanticDocument.documentId) {
271
+ orientationDocument = semanticDocument.documentId;
272
+ previousOrientation = undefined;
273
+ }
274
+ const result = layoutScene({
275
+ cache: layoutCache ?? ownedCache,
276
+ document: semanticDocument,
277
+ ...(view === undefined ? {} : { view }),
278
+ registry,
279
+ flows: flowOptions,
280
+ flowTokens,
281
+ ...(bindings === undefined ? {} : { bindings }),
282
+ presentation,
283
+ ...(iconBindings === undefined ? {} : { iconBindings }),
284
+ strictIcons,
285
+ resolveGlyph: resolveGlyph as typeof getDiagramGlyph,
286
+ measureLines: lineMeasurer,
287
+ collapsed: collapsedNow,
288
+ ...(hints === undefined ? {} : { hints }),
289
+ metrics: effectiveMetrics,
290
+ ...(rowPack === undefined ? {} : { rowPack }),
291
+ ...(targetWidth === undefined ? {} : { targetWidth }),
292
+ ...(previousOrientation === undefined ? {} : { previousOrientation }),
293
+ });
294
+ if (result.status === "laid-out" && result.orientations !== undefined) {
295
+ previousOrientation = result.orientations;
296
+ }
297
+ return result;
298
+ });
299
+
300
+ const scene = $derived<SceneModel | undefined>(
301
+ layoutResult.status === "laid-out"
302
+ ? resolveScene(layoutResult, {
303
+ document: semanticDocument,
304
+ ...(view === undefined ? {} : { view }),
305
+ presentation,
306
+ ...(iconBindings === undefined ? {} : { iconBindings }),
307
+ strictIcons,
308
+ resolveGlyph,
309
+ measureLines: lineMeasurer,
310
+ flows: flowOptions,
311
+ metrics: effectiveMetrics,
312
+ })
313
+ : undefined,
314
+ );
315
+ const sceneRects = $derived<ReadonlyMap<string, Rect>>(scene === undefined ? new Map() : rectsOf(scene));
316
+
317
+ /* Logical flow state never participates in layout or scene resolution. */
318
+ let flowLocal = $state.raw<FlowState>(untrack(() => ({ ...INITIAL_FLOW_STATE,
319
+ selection: defaultActiveStep === undefined ? null : { kind: "step", relation: defaultActiveStep },
320
+ ...(defaultScenario === undefined ? {} : { scenario: defaultScenario }),
321
+ })));
322
+ const flowState = $derived.by<FlowState>(() => {
323
+ const { scenario: _localScenario, ...rest } = flowLocal;
324
+ const filter = scenario === undefined ? flowLocal.scenario : scenario ?? undefined;
325
+ return { ...rest,
326
+ selection: activeStep === undefined ? flowLocal.selection : activeStep === null ? null : { kind: "step", relation: activeStep },
327
+ ...(filter === undefined ? {} : { scenario: filter }),
328
+ };
329
+ });
330
+ const flowHighlight = $derived(scene === undefined ? undefined : highlightOf(scene, flowState));
331
+ const flowEffective = $derived(scene === undefined ? null : effectiveTarget(scene, flowState));
332
+ const flowSteps = $derived(scene === undefined ? [] : stepsOf(scene));
333
+ let flowAnnouncement = $state("");
334
+ let pendingNavigation = $state<string>();
335
+ let badgeCursor = $state<string>();
336
+ let nodeCursor = $state<string>();
337
+ const selectedVisible = $derived(scene === undefined ? null : visibleOf(scene, flowState.selection));
338
+ const selectedBadge = $derived(scene?.badges.find((badge) => JSON.stringify(badge.target) === JSON.stringify(selectedVisible))?.id);
339
+ const badgeTab = $derived(scene?.badges.some((b) => b.id === badgeCursor) ? badgeCursor : selectedBadge ?? scene?.badges[0]?.id);
340
+ const nodeTab = $derived(scene?.nodeTargets.some((n) => n.occurrence === nodeCursor) ? nodeCursor : selectedVisible?.kind === "box" && scene?.nodeTargets.some((n) => n.occurrence === selectedVisible.occurrence) ? selectedVisible.occurrence : scene?.nodeTargets[0]?.occurrence);
341
+ const stateOf = (id: string) => flowHighlight === undefined ? undefined : flowStateOf(flowHighlight, id);
342
+ const descriptionId = (group: string, id: string) => `${hostId}-${group}-${encodeURIComponent(id)}`;
343
+ const hostId = arrowInstance;
344
+ const flowDescription = (target: Visible) => scene === undefined ? "" : describeTarget(scene, target, strings as FlowStrings);
345
+ const boxTarget = (occurrence: string): Visible => ({ kind: "box", occurrence });
346
+ function dispatchFlow(action: FlowAction): void {
347
+ if (scene === undefined || flowSteps.length === 0) return;
348
+ const before = flowEffective;
349
+ const change = reduce(scene, flowState, action);
350
+ let next = change.state;
351
+ if (activeStep !== undefined && change.emit.includes("step")) next = { ...next, selection: flowState.selection };
352
+ if (scenario !== undefined && change.emit.includes("scenario")) {
353
+ const { scenario: _nextFilter, ...rest } = next;
354
+ next = { ...rest, ...(flowState.scenario === undefined ? {} : { scenario: flowState.scenario }) };
355
+ }
356
+ flowLocal = next;
357
+ if (change.emit.includes("step")) onStepChange?.(stepChange(scene, change.state.selection));
358
+ if (change.emit.includes("scenario")) onScenarioChange?.(change.state.scenario ?? null);
359
+ const displayed = effectiveTarget(scene, next);
360
+ if (JSON.stringify(displayed) !== JSON.stringify(before)) onHighlightChange?.(displayed);
361
+ if (["next", "previous", "first", "last"].includes(action.type) && change.emit.includes("step")) {
362
+ if (activeStep === undefined) flowAnnouncement = announce(scene, next, strings);
363
+ else pendingNavigation = change.state.selection?.kind === "step" ? change.state.selection.relation : undefined;
364
+ } else if (change.emit.includes("step")) pendingNavigation = undefined;
365
+ if (change.emit.includes("step") && activeStep === undefined) {
366
+ badgeCursor = undefined; nodeCursor = undefined;
367
+
368
+ }
369
+ }
370
+ $effect(() => {
371
+ if (scene !== undefined && pendingNavigation !== undefined && flowState.selection?.kind === "step" && flowState.selection.relation === pendingNavigation) {
372
+ flowAnnouncement = announce(scene, flowState, strings);
373
+ pendingNavigation = undefined;
374
+ }
375
+ });
376
+ function scrollFlowSelection(): void {
377
+ if (scene === undefined || viewportEl === undefined) return;
378
+ const target = visibleOf(scene, flowState.selection);
379
+ const occurrence = target?.kind === "bundle" ? scene.edges.find((e) => e.bundle?.id === target.id)?.occurrence : target?.occurrence;
380
+ const points = scene.edges.find((edge) => edge.occurrence === occurrence)?.points;
381
+ const routeBox = points === undefined || points.length === 0 ? undefined : { x: Math.min(...points.map((p) => p.x)), y: Math.min(...points.map((p) => p.y)), width: Math.max(...points.map((p) => p.x)) - Math.min(...points.map((p) => p.x)), height: Math.max(...points.map((p) => p.y)) - Math.min(...points.map((p) => p.y)) };
382
+ const box = scene.badges.find((b) => b.occurrence === occurrence)?.box ?? scene.nodes.find((n) => n.occurrence === occurrence)?.rect ?? routeBox;
383
+ if (box === undefined) return;
384
+ const left = box.x * zoom + placement.translateX, top = box.y * zoom + placement.translateY;
385
+ if (left < viewportEl.scrollLeft) viewportEl.scrollLeft = left;
386
+ else if (left + box.width * zoom > viewportEl.scrollLeft + viewportEl.clientWidth) viewportEl.scrollLeft = left + box.width * zoom - viewportEl.clientWidth;
387
+ if (top < viewportEl.scrollTop) viewportEl.scrollTop = top;
388
+ else if (top + box.height * zoom > viewportEl.scrollTop + viewportEl.clientHeight) viewportEl.scrollTop = top + box.height * zoom - viewportEl.clientHeight;
389
+ }
390
+ function targetAt(element: EventTarget | null): Visible | null {
391
+ if (!(element instanceof Element) || scene === undefined) return null;
392
+ const target = element.closest<HTMLElement>("[data-flow-badge],[data-flow-node],[data-flow-hit],[data-scene-occurrence]");
393
+ if (target === null) return null;
394
+ const badge = target.dataset["flowBadge"];
395
+ if (badge !== undefined) return scene.badges.find((b) => b.id === badge)?.target ?? null;
396
+ const edge = scene.edges.find((e) => e.occurrence === target.dataset["flowHit"]);
397
+ if (edge !== undefined) return edge.bundle === undefined ? { kind: "edge", occurrence: edge.occurrence } : { kind: "bundle", id: edge.bundle.id };
398
+ const node = target.dataset["flowNode"] ?? target.dataset["sceneOccurrence"];
399
+ return node !== undefined && scene.nodeTargets.some((n) => n.occurrence === node) ? boxTarget(node) : null;
400
+ }
401
+ function flowPointer(event: PointerEvent, leaving: boolean): void {
402
+ dispatchFlow({ type: "hover", target: targetAt(leaving ? event.relatedTarget : event.target) });
403
+ }
404
+ function flowFocus(event: FocusEvent, leaving: boolean): void {
405
+ dispatchFlow({ type: "focus", target: targetAt(leaving ? event.relatedTarget : event.target) });
406
+ }
407
+ function flowClick(event: MouseEvent): void {
408
+ if (suppressFlowClick) { suppressFlowClick = false; return; }
409
+ const element = event.target as Element;
410
+ if (element.closest("button[aria-expanded],input,select,textarea,a,[contenteditable=true]")) return;
411
+ const target = targetAt(event.target);
412
+ if (target !== null) {
413
+ // Cards/zones dispatch through their existing onSelect callback below.
414
+ if (element.closest("[data-flow-badge],[data-flow-node],[data-flow-hit]")) dispatchFlow({ type: "activate", target });
415
+ } else if (!element.closest("button")) dispatchFlow({ type: "escape" });
416
+ }
417
+ function flowClickCapture(event: MouseEvent): void {
418
+ if (flowSteps.length === 0) return;
419
+ if (event.detail === 0) suppressFlowClick = false;
420
+ if (suppressFlowClick) { suppressFlowClick = false; event.stopPropagation(); event.preventDefault(); return; }
421
+ const toggle = (event.target as Element).closest("button[aria-expanded]");
422
+ const occurrence = toggle?.closest<HTMLElement>("[data-scene-occurrence]")?.dataset["sceneOccurrence"];
423
+ const node = scene?.nodes.find((entry) => entry.occurrence === occurrence);
424
+ if (node !== undefined) { event.stopPropagation(); toggleFold(node); }
425
+ }
426
+ function selectNode(node: SceneNodeModel, event: { entityId: string }): void {
427
+ if (suppressFlowClick) { suppressFlowClick = false; return; }
428
+ dispatchFlow({ type: "activate", target: boxTarget(node.occurrence) });
429
+ onSelect?.(event);
430
+ }
431
+ function roveFlow(event: KeyboardEvent): boolean {
432
+ const target = event.target as HTMLElement;
433
+ const group = target.dataset["flowBadge"] !== undefined ? "flowBadge" : target.dataset["flowNode"] !== undefined ? "flowNode" : undefined;
434
+ if (group === undefined || !["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End"].includes(event.key)) return false;
435
+ const candidates = [...(viewportEl?.querySelectorAll<HTMLElement>(group === "flowBadge" ? "[data-flow-badge]" : "[data-flow-node]") ?? [])];
436
+ const current = candidates.indexOf(target);
437
+ const index = event.key === "Home" ? 0 : event.key === "End" ? candidates.length - 1 : Math.max(0, Math.min(candidates.length - 1, current + (["ArrowLeft", "ArrowUp"].includes(event.key) ? -1 : 1)));
438
+ const next = candidates[index];
439
+ if (next !== undefined) { if (group === "flowBadge") badgeCursor = next.dataset[group]; else nodeCursor = next.dataset[group]; next.focus(); }
440
+ event.preventDefault(); return true;
441
+ }
442
+ let scrollIdentity: string | undefined;
443
+ $effect(() => {
444
+ const identity = JSON.stringify([flowState.selection,selectedVisible]);
445
+ if (scrollIdentity !== undefined && scrollIdentity !== identity) {
446
+ badgeCursor = undefined; nodeCursor = undefined;
447
+ void tick().then(scrollFlowSelection);
448
+ }
449
+ scrollIdentity = identity;
450
+ });
451
+ let previousFlowScene: SceneModel | undefined;
452
+ let removedSelection: string | undefined;
453
+ $effect.pre(() => {
454
+ const current = scene;
455
+ untrack(() => {
456
+ if (current === undefined) return;
457
+ if (previousFlowScene !== undefined && previousFlowScene !== current) {
458
+ const focused = viewportEl?.ownerDocument.activeElement as HTMLElement | null;
459
+ const group = focused?.hasAttribute("data-flow-badge") ? "[data-flow-badge]" : focused?.hasAttribute("data-flow-node") ? "[data-flow-node]" : undefined;
460
+ if (group !== undefined) void tick().then(() => { if (focused !== null && !focused.isConnected) (viewportEl?.querySelector<HTMLElement>(`${group}[tabindex="0"]`) ?? viewportEl)?.focus({ preventScroll: true }); });
461
+ const before = flowState;
462
+ const repaired = reduce(current, before, { type: "repair" });
463
+ flowLocal = { ...repaired.state, selection: activeStep === undefined ? repaired.state.selection : before.selection };
464
+ if (before.selection?.kind === "step" && repaired.state.selection === null && removedSelection !== before.selection.relation) {
465
+ removedSelection = before.selection.relation;
466
+ if (activeStep === undefined) flowLocal = repaired.state;
467
+ onStepChange?.(null);
468
+ } else if (repaired.state.selection !== null) removedSelection = undefined;
469
+ }
470
+ previousFlowScene = current;
471
+ });
472
+ });
473
+
474
+ $effect(() => {
475
+ const result = layoutResult;
476
+ untrack(() => onLayout?.(result));
477
+ });
478
+
479
+ $effect(() => {
480
+ const size = sceneContentSize(layoutResult);
481
+ if (publishedSize?.width === size.width && publishedSize?.height === size.height) return;
482
+ publishedSize = size;
483
+ contentSize = size;
484
+ untrack(() => onSizeChange?.(size));
485
+ });
486
+
487
+ /* ── measured frame and tokens (client only) ───────────────────── */
488
+
489
+ let frameEl = $state<HTMLElement>();
490
+ let viewportEl = $state<HTMLElement>();
491
+ $effect(() => {
492
+ const filter = flowState.scenario;
493
+ if (scenario !== undefined) {
494
+ const select = frameEl?.parentElement?.querySelector<HTMLSelectElement>(".st-diagramSceneFigure-flowNavigator select");
495
+ if (select !== undefined && select !== null) select.value = filter === undefined ? "all" : `scenario:${filter}`;
496
+ }
497
+ });
498
+ let viewWidth = $state<number>();
499
+ let windowHeight = $state<number>();
500
+ let maxDisplayScale = $state<number>();
501
+ let minReadableScale = $state<number>();
502
+ let renderedBounds = $state.raw<{ scene: SceneModel; bounds: Rect }>();
503
+ const cameraBounds = $derived(renderedBounds?.scene === scene ? renderedBounds?.bounds : scene?.bounds);
504
+ function readRenderedBounds(): void {
505
+ if (frameEl === undefined || scene === undefined) return;
506
+ const bounds = measureRenderedBounds(frameEl, scene.bounds, zoom);
507
+ if (bounds !== undefined && bounds !== scene.bounds) {
508
+ if (atFit && (renderedBounds === undefined || renderedBounds.scene === scene)) requestedZoom = undefined;
509
+ renderedBounds = { scene, bounds };
510
+ }
511
+ }
512
+ $effect(() => {
513
+ const current = scene;
514
+ if (current === undefined) return;
515
+ let active = true;
516
+ void tick().then(() => { if (active && scene === current) readRenderedBounds(); });
517
+ return () => { active = false; };
518
+ });
519
+
520
+ $effect(() => {
521
+ const element = frameEl;
522
+ const current = scene;
523
+ if (element === undefined || current === undefined || browserMeasure !== undefined
524
+ || measureLines !== undefined || measure !== defaultCardMeasure) return;
525
+ let active = true;
526
+ void document.fonts?.ready.then(() => {
527
+ if (!active) return;
528
+ browserMeasure = measureRenderedSceneFont(element, current, effectiveMeasure);
529
+ });
530
+ return () => { active = false; };
531
+ });
532
+
533
+ function tokenValue(name: string): string | undefined {
534
+ if (frameEl === undefined) return undefined;
535
+ const value = getComputedStyle(frameEl).getPropertyValue(name).trim();
536
+ return value === "" ? undefined : value;
537
+ }
538
+
539
+ // The camera sits at the fit until an input moves it; a resize keeps a
540
+ // camera that is still at the fit on the fit, and reclamps any other.
541
+ let requestedZoom = $state<number>();
542
+ let atFit = true;
543
+
544
+ // m3: camera tokens are re-read on every measure and before every camera
545
+ // input, so a post-mount theme change applies without waiting for a resize.
546
+ function readCameraTokens(): void {
547
+ const values: Record<string, number> = {};
548
+ for (const key of ["gapMin","gapMinBlock","gapBase","gapBaseBlock","trackSpacing","trackSpacingBlock","labelBand","gapMax","bundleLabelMaxWidth","containerPadding"]) {
549
+ const value = parseFloat(tokenValue('--st-component-diagramScene-' + key) ?? '');
550
+ if (Number.isFinite(value)) values[key] = value;
551
+ }
552
+ if (JSON.stringify(values) !== JSON.stringify(tokenMetrics)) tokenMetrics = values;
553
+ const nextTokens = { ...DEFAULT_FLOW_TOKENS };
554
+ for (const name of Object.keys(nextTokens) as (keyof FlowTokens)[]) {
555
+ const value = tokenValue(`--st-component-diagramScene-${name}`);
556
+ if (name === "flowArrowPath") { if (value?.trim()) nextTokens.flowArrowPath = value.trim(); }
557
+ else { const number = parseScale(value); if (number !== undefined) (nextTokens as unknown as Record<string, number>)[name] = number; }
558
+ }
559
+ if (JSON.stringify(nextTokens) !== JSON.stringify(flowTokens)) flowTokens = nextTokens;
560
+ maxDisplayScale = parseScale(tokenValue(TOKEN_MAX_DISPLAY_SCALE));
561
+ minReadableScale = parseScale(tokenValue(TOKEN_MIN_READABLE_SCALE));
562
+ }
563
+
564
+ function measureFrame(): void {
565
+ if (frameEl === undefined) return;
566
+ // m6: the fit width is the viewport narrowed by its scrollbar, not the
567
+ // frame wrapper.
568
+ const viewportWidth = viewportEl?.clientWidth ?? 0;
569
+ const width = viewportWidth > 0 ? viewportWidth : frameEl.clientWidth;
570
+ viewWidth = width > 0 ? width : undefined;
571
+ windowHeight = window.innerHeight > 0 ? window.innerHeight : undefined;
572
+ readCameraTokens();
573
+ if (atFit) requestedZoom = undefined;
574
+ }
575
+
576
+ $effect(() => {
577
+ const element = frameEl;
578
+ if (element === undefined) return;
579
+ untrack(measureFrame);
580
+ const onResize = (): void => measureFrame();
581
+ window.addEventListener("resize", onResize);
582
+ const observer = typeof ResizeObserver === "undefined" ? undefined : new ResizeObserver(onResize);
583
+ observer?.observe(element);
584
+ return () => {
585
+ window.removeEventListener("resize", onResize);
586
+ observer?.disconnect();
587
+ };
588
+ });
589
+
590
+ /* ── camera (Z-1–Z-8) ──────────────────────────────────────────── */
591
+
592
+ const measured = $derived(viewWidth !== undefined && windowHeight !== undefined);
593
+ const fit = $derived(
594
+ sceneFit({
595
+ ...(cameraBounds === undefined ? {} : { bounds: cameraBounds }),
596
+ // Before the frame is measured (server render, hidden mount) the fit
597
+ // box is the nominal 16:9 box of the layout target width.
598
+ viewWidth: viewWidth ?? targetWidth ?? DEFAULT_SCENE_TARGET_WIDTH,
599
+ windowHeight: windowHeight ?? Number.POSITIVE_INFINITY,
600
+ ...(maxDisplayScale === undefined ? {} : { maxDisplayScale }),
601
+ ...(minReadableScale === undefined ? {} : { minReadableScale }),
602
+ }),
603
+ );
604
+ const zoom = $derived(resolveZoom(requestedZoom, fit));
605
+ const readout = $derived(zoomReadout(zoom, fit.maxZoom));
606
+ const placement = $derived(scenePlacement(cameraBounds, zoom, fit));
607
+ const canZoomIn = $derived(zoom < fit.maxZoom);
608
+ const canZoomOut = $derived(zoom > fit.minZoom);
609
+
610
+ // A new scene starts at its fit (Z-8).
611
+ let cameraDocument: string | undefined;
612
+ $effect.pre(() => {
613
+ const id = semanticDocument.documentId;
614
+ if (cameraDocument !== undefined && cameraDocument !== id) {
615
+ atFit = true;
616
+ requestedZoom = undefined;
617
+ browserMeasure = undefined;
618
+ renderedBounds = undefined;
619
+ }
620
+ cameraDocument = id;
621
+ });
622
+
623
+ // Z-7: once the frame is measured the camera holds a number, clamped to
624
+ // the nearest bound of the current range; a zoom inside the range stays.
625
+ $effect(() => {
626
+ if (!measured) return;
627
+ const current = zoom;
628
+ const fitZoom = fit.zoom;
629
+ untrack(() => {
630
+ if (requestedZoom !== current) requestedZoom = current;
631
+ if (current !== fitZoom) atFit = false;
632
+ });
633
+ });
634
+
635
+ $effect(() => {
636
+ const camera: DiagramSceneCamera = {
637
+ zoom,
638
+ readout,
639
+ minZoom: fit.minZoom,
640
+ maxZoom: fit.maxZoom,
641
+ fitZoom: fit.zoom,
642
+ pans: placement.overflowX || placement.overflowY,
643
+ };
644
+ untrack(() => onCameraChange?.(camera));
645
+ });
646
+
647
+ /** Z-1: any request lands inside the current range. The viewport centre is kept where scrolling allows. */
648
+ export function setZoom(next: number): void {
649
+ if (!Number.isFinite(next)) return;
650
+ readCameraTokens();
651
+ const before = zoom;
652
+ const target = clampZoom(next, fit);
653
+ atFit = target === fit.zoom;
654
+ if (target === before) return;
655
+ const element = viewportEl;
656
+ const centre =
657
+ element === undefined
658
+ ? undefined
659
+ : {
660
+ x: (element.scrollLeft + element.clientWidth / 2 - placement.translateX) / before,
661
+ y: (element.scrollTop + element.clientHeight / 2 - placement.translateY) / before,
662
+ };
663
+ requestedZoom = target;
664
+ if (element === undefined || centre === undefined) return;
665
+ void tick().then(() => {
666
+ element.scrollLeft = centre.x * zoom + placement.translateX - element.clientWidth / 2;
667
+ element.scrollTop = centre.y * zoom + placement.translateY - element.clientHeight / 2;
668
+ });
669
+ }
670
+
671
+ export function zoomIn(): void {
672
+ setZoom(zoom * ZOOM_STEP_RATIO);
673
+ }
674
+
675
+ export function zoomOut(): void {
676
+ setZoom(zoom / ZOOM_STEP_RATIO);
677
+ }
678
+
679
+ /** Z-3/Z-4: fit and reset are one action. An overflowing axis scrolls from its start. */
680
+ export function fitToFrame(): void {
681
+ readCameraTokens();
682
+ readRenderedBounds();
683
+ atFit = true;
684
+ requestedZoom = fit.zoom;
685
+ const element = viewportEl;
686
+ if (element === undefined) return;
687
+ void tick().then(() => {
688
+ element.scrollLeft = 0;
689
+ element.scrollTop = 0;
690
+ });
691
+ }
692
+
693
+ export function getCamera(): DiagramSceneCamera {
694
+ return {
695
+ zoom,
696
+ readout,
697
+ minZoom: fit.minZoom,
698
+ maxZoom: fit.maxZoom,
699
+ fitZoom: fit.zoom,
700
+ pans: placement.overflowX || placement.overflowY,
701
+ };
702
+ }
703
+
704
+ function onKeydown(event: KeyboardEvent): void {
705
+ if (event.ctrlKey || event.metaKey || event.altKey) return;
706
+ // m5: shortcuts work from non-input descendants (card buttons, nodes);
707
+ // only typing targets keep the keys.
708
+ const target = event.target as HTMLElement | null;
709
+ if (target !== null && target !== event.currentTarget) {
710
+ const tag = target.tagName;
711
+ if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT" || target.isContentEditable || target.closest("[contenteditable]")) return;
712
+ }
713
+ if (!event.shiftKey && roveFlow(event)) return;
714
+ if (!event.shiftKey && flowSteps.length > 0 && ["]", "[", "Escape"].includes(event.key)) {
715
+ dispatchFlow({ type: event.key === "]" ? "next" : event.key === "[" ? "previous" : "escape" }); event.preventDefault(); return;
716
+ }
717
+ if (event.key === "+" || event.key === "=") zoomIn();
718
+ else if (event.key === "-" || event.key === "_") zoomOut();
719
+ else if (event.key === "0") fitToFrame();
720
+ else return;
721
+ event.preventDefault();
722
+ }
723
+
724
+ // Ctrl + wheel (and the trackpad pinch browsers report as Ctrl + wheel)
725
+ // zooms; a plain wheel scrolls. Registered non-passive so the page zoom
726
+ // is not triggered as well.
727
+ $effect(() => {
728
+ const element = viewportEl;
729
+ if (element === undefined) return;
730
+ const onWheel = (event: WheelEvent): void => {
731
+ if (!event.ctrlKey && !event.metaKey) return;
732
+ event.preventDefault();
733
+ setZoom(zoom * Math.exp(-event.deltaY * WHEEL_ZOOM_RATE));
734
+ };
735
+ element.addEventListener("wheel", onWheel, { passive: false });
736
+ return () => element.removeEventListener("wheel", onWheel);
737
+ });
738
+
739
+ // Two-finger pinch on a touch screen.
740
+ const touches = new Map<number, { x: number; y: number }>();
741
+ let pinch: { distance: number; zoom: number } | undefined;
742
+ let touchOrigin: { x: number; y: number } | undefined;
743
+ let suppressFlowClick = false;
744
+ const touchDistance = (): number => {
745
+ const [first, second] = [...touches.values()];
746
+ return first === undefined || second === undefined ? 0 : Math.hypot(first.x - second.x, first.y - second.y);
747
+ };
748
+ function onPointerDown(event: PointerEvent): void {
749
+ suppressFlowClick = false;
750
+ if (event.pointerType !== "touch") return;
751
+ touchOrigin = { x: event.clientX, y: event.clientY };
752
+ touches.set(event.pointerId, { x: event.clientX, y: event.clientY });
753
+ pinch = touches.size === 2 ? { distance: touchDistance(), zoom } : undefined;
754
+ }
755
+ function onPointerMove(event: PointerEvent): void {
756
+ if (!touches.has(event.pointerId)) return;
757
+ if (touchOrigin !== undefined && (event.clientX !== touchOrigin.x || event.clientY !== touchOrigin.y)) suppressFlowClick = true;
758
+ touches.set(event.pointerId, { x: event.clientX, y: event.clientY });
759
+ if (pinch === undefined || pinch.distance <= 0) return;
760
+ event.preventDefault();
761
+ setZoom(pinch.zoom * (touchDistance() / pinch.distance));
762
+ }
763
+ function onPointerEnd(event: PointerEvent): void {
764
+ touches.delete(event.pointerId);
765
+ pinch = undefined;
766
+ }
767
+
768
+ /* ── fold transition (T-1–T-4) ─────────────────────────────────── */
769
+
770
+ let origin = $state.raw<ReadonlyMap<string, Rect>>();
771
+ let progress = $state(1);
772
+ let easing: Easing = (value) => value;
773
+ let duration = 0;
774
+ let startedAt = 0;
775
+ let frameHandle: number | undefined;
776
+ // The rectangles on screen after the last render: the start of the next
777
+ // transition, interpolated ones included (T-4).
778
+ let shown: ReadonlyMap<string, Rect> | undefined;
779
+ let shownDocument: string | undefined;
780
+
781
+ const eased = $derived(origin === undefined ? 1 : easing(progress));
782
+ const displayed = $derived(origin === undefined ? sceneRects : displayedRects(origin, sceneRects, eased));
783
+ const animating = $derived(origin !== undefined);
784
+
785
+ function stopFrames(): void {
786
+ if (frameHandle !== undefined) cancelAnimationFrame(frameHandle);
787
+ frameHandle = undefined;
788
+ }
789
+
790
+ function settle(): void {
791
+ stopFrames();
792
+ origin = undefined;
793
+ progress = 1;
794
+ }
795
+
796
+ function step(): void {
797
+ frameHandle = undefined;
798
+ const elapsed = performance.now() - startedAt;
799
+ if (elapsed >= duration) {
800
+ settle();
801
+ return;
802
+ }
803
+ progress = elapsed / duration;
804
+ frameHandle = requestAnimationFrame(step);
805
+ }
806
+
807
+ // Runs before the DOM is patched with a new layout, so the first frame
808
+ // of a transition already draws the displayed rectangles, never a jump.
809
+ $effect.pre(() => {
810
+ const next = sceneRects;
811
+ const documentId = semanticDocument.documentId;
812
+ untrack(() => {
813
+ const from = shown;
814
+ const sameScene = shownDocument === documentId;
815
+ shownDocument = documentId;
816
+ if (from === undefined || !sameScene || sameRects(from, next)) {
817
+ settle();
818
+ return;
819
+ }
820
+ // T-3: the reduced-motion preference is read at toggle time.
821
+ const reduced = typeof window.matchMedia === "function" && window.matchMedia(REDUCED_MOTION_QUERY).matches;
822
+ duration = reduced ? 0 : parseDurationMs(tokenValue(TOKEN_TRANSITION_DURATION));
823
+ if (duration <= 0) {
824
+ settle();
825
+ return;
826
+ }
827
+ // T-4: retarget from what is displayed; no queue of stale targets.
828
+ stopFrames();
829
+ easing = parseEasing(tokenValue(TOKEN_EASING));
830
+ origin = from;
831
+ progress = 0;
832
+ startedAt = performance.now();
833
+ frameHandle = requestAnimationFrame(step);
834
+ });
835
+ });
836
+
837
+ $effect(() => {
838
+ shown = displayed;
839
+ });
840
+
841
+ $effect(() => () => {
842
+ stopFrames();
843
+ touches.clear();
844
+ pinch = undefined;
845
+ ownedCache.dispose();
846
+ });
847
+
848
+ /* ── drawing ───────────────────────────────────────────────────── */
849
+
850
+ const rectOf = (node: SceneNodeModel): Rect => displayed.get(node.occurrence) ?? node.rect;
851
+ const entering = (node: SceneNodeModel): boolean => origin !== undefined && !origin.has(node.occurrence);
852
+
853
+ function toggleFold(node: SceneNodeModel): void {
854
+ const next = node.collapsed
855
+ ? collapsedNow.filter((id) => id !== node.occurrence)
856
+ : [...collapsedNow, node.occurrence];
857
+ if (collapsed === undefined) foldState = next;
858
+ onFoldChange?.(next, { occurrence: node.occurrence, collapsed: !node.collapsed });
859
+ // The toggle button is re-created by the fold: give the focus back to it.
860
+ const element = viewportEl;
861
+ if (element === undefined) return;
862
+ void tick().then(() => {
863
+ for (const candidate of element.querySelectorAll<HTMLElement>("[data-scene-occurrence]")) {
864
+ if (candidate.dataset["sceneOccurrence"] !== node.occurrence) continue;
865
+ candidate.querySelector<HTMLElement>("button[aria-expanded]")?.focus({ preventScroll: true });
866
+ return;
867
+ }
868
+ });
869
+ }
870
+
871
+ const cardPropsOf = (node: SceneNodeModel) => {
872
+ const projected = projectCardProps(node.presentation, {
873
+ entityId: node.entity,
874
+ ...(resolveGlyph === undefined ? {} : { resolveGlyph }),
875
+ });
876
+ return projected.kind === "card" ? { ...projected.props, autoSize: true, height: node.rect.height } : undefined;
877
+ };
878
+
879
+ const zonePropsOf = (node: SceneNodeModel, rect: Rect) => {
880
+ const zoneTitle = node.presentation?.text.title ?? "";
881
+ const projected = projectZoneProps(node.presentation, {
882
+ containerPadding: effectiveMetrics.containerPadding,
883
+ entityId: node.entity,
884
+ collapsed: node.collapsed,
885
+ toggleLabel: node.collapsed ? strings.expand(zoneTitle) : strings.collapse(zoneTitle),
886
+ ...(node.collapsed ? {} : { width: rect.width, height: rect.height }),
887
+ ...(resolveGlyph === undefined ? {} : { resolveGlyph }),
888
+ });
889
+ return projected.kind === "zone" ? { ...projected.props, autoSize: true, height: rect.height } : undefined;
890
+ };
891
+
892
+ const erdTable = $derived(semanticDocument.profileRefs.includes("erd@1") ? renderErdTable(semanticDocument) : "");
893
+
894
+ const pointsOf = (points: readonly { readonly x: number; readonly y: number }[]): string =>
895
+ points.map((point) => `${point.x},${point.y}`).join(" ");
896
+
897
+ const edgeLabelLineHeight = $derived(lineMeasurer({ text: "Mg", role: "edge-label", availableWidth: 400, allocatedLines: 1, folded: false }).height);
898
+ const viewportStyle = $derived(
899
+ `${measured ? `height:${fit.fitHeight}px` : `aspect-ratio:${FIT_ASPECT}`};--st-diagram-zoom:${zoom};--st-diagram-label-line-height:${edgeLabelLineHeight}px${flowSteps.length > 0 ? `;--st-diagramSceneFigure-flowHit:${flowHitSize(zoom, flowTokens)}px` : ""}`,
900
+ );
901
+ const worldStyle = $derived(
902
+ `transform:translate(${placement.translateX}px,${placement.translateY}px) scale(${zoom})`,
903
+ );
904
+ </script>
905
+
906
+ <figure
907
+ class="st-diagramSceneFigure{compact ? " st-diagramSceneFigure--compact" : ""}"
908
+ aria-label={label ?? title}
909
+ data-zoom={zoom}
910
+ data-zoom-readout={readout}
911
+ data-scene-refused={layoutResult.status === "refused" ? layoutResult.refusals[0]?.code : undefined}
912
+ >
913
+ {#if title !== undefined}
914
+ <figcaption class="st-diagramSceneFigure-title">{title}</figcaption>
915
+ {/if}
916
+ <div class="st-diagramSceneFigure-controls" role="group" aria-label={strings.controls}>
917
+ <IconButton size="sm" variant="secondary" aria-label={strings.zoomOut} disabled={!canZoomOut} onclick={zoomOut}>
918
+ <Minus size="var(--st-component-button-anatomy-density-sm-fontSize)" aria-hidden="true" />
919
+ </IconButton>
920
+ <output class="st-diagramSceneFigure-readout" aria-live="polite" aria-label={strings.zoomLevel(readout)}>
921
+ {readout} %
922
+ </output>
923
+ <IconButton size="sm" variant="secondary" aria-label={strings.zoomIn} disabled={!canZoomIn} onclick={zoomIn}>
924
+ <Plus size="var(--st-component-button-anatomy-density-sm-fontSize)" aria-hidden="true" />
925
+ </IconButton>
926
+ <Button size="sm" variant="secondary" onclick={fitToFrame}>{strings.fit}</Button>
927
+ </div>
928
+ {#if flowSteps.length > 0}
929
+ <div class="st-diagramSceneFigure-flowNavigator" role="group" aria-label={strings.navigator}>
930
+ <Button size="sm" variant="secondary" onclick={() => dispatchFlow({ type: "previous" })}>{strings.previous}</Button>
931
+ <output aria-label={strings.step}>{scene === undefined ? "" : announce(scene, flowState, strings)}</output>
932
+ <Button size="sm" variant="secondary" onclick={() => dispatchFlow({ type: "next" })}>{strings.next}</Button>
933
+ {#if scene !== undefined && scene.flows.scenarios.length >= 2}
934
+ <Select label={strings.scenario} value={flowState.scenario === undefined ? "all" : `scenario:${flowState.scenario}`} onchange={(event) => { const value = event.currentTarget.value; dispatchFlow(value === "all" ? { type: "scenario" } : { type: "scenario", id: value.slice("scenario:".length) }); if (scenario !== undefined) { const select = event.currentTarget; void tick().then(() => { select.value = flowState.scenario === undefined ? "all" : `scenario:${flowState.scenario}`; }); } }}>
935
+ <option value="all">{strings.allScenarios}</option>
936
+ {#each scene.flows.scenarios as entry (entry.id)}<option value={`scenario:${entry.id}`}>{entry.label || strings.scenario}</option>{/each}
937
+ </Select>
938
+ {/if}
939
+ <output class="st-diagramSceneFigure-flowDescription" aria-live="polite">{flowAnnouncement}</output>
940
+ </div>
941
+ {/if}
942
+ <div class="st-diagramSceneFigure-frame" bind:this={frameEl}>
943
+ <!-- m5: a refused layout draws visible text, not only the data attribute. -->
944
+ {#if layoutResult.status === "refused"}
945
+ <p class="st-diagramSceneFigure-refused" role="alert">
946
+ Diagram unavailable ({layoutResult.refusals[0]?.code ?? "refused"})
947
+ </p>
948
+ {/if}
949
+ <!-- The scrollable drawing region is focusable so the keyboard reaches
950
+ both the scroll (arrow keys) and the camera keys (+, −, 0). -->
951
+ <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
952
+ <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
953
+ <div
954
+ class="st-diagramSceneFigure-viewport"
955
+ bind:this={viewportEl}
956
+ role="group"
957
+ tabindex="0"
958
+ aria-label={strings.viewport}
959
+ aria-keyshortcuts={flowSteps.length > 0 ? "+ - 0 [ ] Escape" : "+ - 0"}
960
+ aria-busy={animating}
961
+ data-pans={placement.overflowX || placement.overflowY ? "true" : "false"}
962
+ style={viewportStyle}
963
+ onkeydown={onKeydown}
964
+ onpointerdown={onPointerDown}
965
+ onpointermove={onPointerMove}
966
+ onpointerup={onPointerEnd}
967
+ onpointercancel={onPointerEnd}
968
+ onpointerover={(event) => flowPointer(event, false)}
969
+ onpointerout={(event) => flowPointer(event, true)}
970
+ onfocusin={(event) => flowFocus(event, false)}
971
+ onfocusout={(event) => flowFocus(event, true)}
972
+ onclick={flowClick}
973
+ onclickcapture={flowClickCapture}
974
+ >
975
+ <div
976
+ class="st-diagramSceneFigure-extent"
977
+ style={`width:${placement.contentWidth}px;height:${placement.contentHeight}px`}
978
+ >
979
+ <div class="st-diagramSceneFigure-world" style={worldStyle} data-flow-active={flowHighlight !== undefined && (flowHighlight.primary.size > 0 || flowHighlight.dimmed.size > 0) ? "true" : undefined}>
980
+ {#if scene !== undefined}
981
+ <!-- m4: edges paint before nodes, labels last; edges and labels
982
+ fade in with the transition (T-1) while the boxes move. -->
983
+ <svg
984
+ class="st-diagramSceneFigure-edges"
985
+ aria-hidden="true"
986
+ style={animating ? `opacity:${eased}` : undefined}
987
+ >
988
+ <defs><marker id={arrowId} viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0 0L10 5L0 10Z" fill="var(--st-component-diagramScene-edgeStroke, #64748b)" /></marker></defs>
989
+ {#each scene.edges as edge (edge.occurrence)}
990
+ <polyline marker-end={edge.markers === undefined && !edge.directed ? `url(#${arrowId})` : undefined} class="st-diagramSceneFigure-edge" data-scene-edge={edge.occurrence} data-flow-step={edge.flow?.relation} data-flow-bundle={edge.bundle?.id} data-flow-state={stateOf(edge.occurrence)} points={pointsOf(edge.points)} />
991
+ {#if edge.directed}
992
+ <polyline class="st-diagramSceneFigure-flowHit" data-flow-hit={edge.occurrence} points={pointsOf(edge.points)} />
993
+ {#each edge.arrows as arrow, index (index)}
994
+ <path class="st-diagramSceneFigure-flowArrow" data-flow-arrow={edge.occurrence} data-flow-state={stateOf(edge.occurrence)} d={flowTokens.flowArrowPath} transform={`translate(${arrow.tip.x} ${arrow.tip.y}) rotate(${arrow.angle}) translate(${-flowTokens.flowArrowLength} ${-flowTokens.flowArrowWidth / 2})`} />
995
+ {/each}
996
+ {/if}
997
+ {/each}
998
+ {#each scene.edges as edge (edge.occurrence)}
999
+ {#if edge.markers}<g>{@html edge.markers}</g>{/if}
1000
+ {/each}
1001
+ {#each scene.labels as edgeLabel (edgeLabel.occurrence)}
1002
+ {#if edgeLabel.leader}<polyline class="st-diagramSceneFigure-edge" points={pointsOf(edgeLabel.leader)} />{/if}
1003
+ {/each}
1004
+ </svg>
1005
+ {#each scene.nodes as node (node.occurrence)}
1006
+ {@const rect = rectOf(node)}
1007
+ <div
1008
+ class="st-diagramSceneFigure-node"
1009
+ data-scene-occurrence={node.occurrence}
1010
+ data-scene-kind={node.kind}
1011
+ data-flow-state={stateOf(node.occurrence)}
1012
+ style={`left:${rect.x}px;top:${rect.y}px;width:${rect.width}px;height:${rect.height}px${entering(node) ? `;opacity:${eased}` : ""}`}
1013
+ >
1014
+ {#if node.kind === "erd" && node.erd}
1015
+ <button class="st-diagramErd-toggle" type="button" aria-label={node.collapsed ? strings.expand(node.erd.title) : strings.collapse(node.erd.title)} aria-expanded={!node.collapsed} style={`--st-erd-header-height: ${node.erd.headerHeight}px`} onclick={() => toggleFold(node)}>{node.erd.title}</button>
1016
+ <div class="st-diagramErd-svg">{@html renderErdCardSvg(node.erd)}</div>
1017
+ {:else if node.kind === "card"}
1018
+ {@const cardProps = cardPropsOf(node)}
1019
+ {#if cardProps !== undefined}
1020
+ <DiagramCard {...cardProps} measure={effectiveMeasure} onSelect={(event) => selectNode(node, event)} />
1021
+ {/if}
1022
+ {:else if node.kind === "zone"}
1023
+ {@const zoneProps = zonePropsOf(node, rect)}
1024
+ {#if zoneProps !== undefined}
1025
+ <DiagramZone {...zoneProps} measure={effectiveMeasure} onSelect={(event) => selectNode(node, event)} onToggle={() => toggleFold(node)} />
1026
+ {/if}
1027
+ {:else}
1028
+ <div class="st-diagramSceneFigure-label" data-entity={node.entity}>{node.text}</div>
1029
+ {/if}
1030
+ </div>
1031
+ {/each}
1032
+ {#each scene.badges as badge (badge.id)}
1033
+ <button type="button" class="st-diagramSceneFigure-flowBadge" data-flow-badge={badge.id} data-flow-state={stateOf(badge.occurrence)} aria-pressed={JSON.stringify(selectedVisible) === JSON.stringify(badge.target)} aria-describedby={descriptionId("badge", badge.id)} tabindex={badgeTab === badge.id ? 0 : -1} style={`left:${badge.box.x}px;top:${badge.box.y}px;width:${badge.box.width}px;height:${badge.box.height}px`}>{badge.text}</button>
1034
+ <span class="st-diagramSceneFigure-flowDescription" id={descriptionId("badge", badge.id)}>{flowDescription(badge.target)}</span>
1035
+ {/each}
1036
+ {#each scene.nodeTargets as target (target.occurrence)}
1037
+ <button type="button" class="st-diagramSceneFigure-flowNode" data-flow-node={target.occurrence} data-flow-state={stateOf(target.occurrence)} aria-label={flowDescription(boxTarget(target.occurrence))} aria-pressed={selectedVisible?.kind === "box" && selectedVisible.occurrence === target.occurrence} aria-describedby={descriptionId("node", target.occurrence)} tabindex={nodeTab === target.occurrence ? 0 : -1} style={`left:${target.anchor.x}px;top:${target.anchor.y}px`}>{strings.node}</button>
1038
+ <span class="st-diagramSceneFigure-flowDescription" id={descriptionId("node", target.occurrence)}>{flowDescription(boxTarget(target.occurrence))}</span>
1039
+ {/each}
1040
+ {#each scene.labels as edgeLabel (edgeLabel.occurrence)}
1041
+ <div
1042
+ class="st-diagramSceneFigure-edgeLabel"
1043
+ data-scene-label={edgeLabel.occurrence}
1044
+ title={edgeLabel.title}
1045
+ data-erd-label={edgeLabel.erd || undefined}
1046
+ style={`left:${edgeLabel.box.x}px;top:${edgeLabel.box.y}px;width:${edgeLabel.box.width}px;height:${edgeLabel.box.height}px${animating ? `;opacity:${eased}` : ""}`}
1047
+ >
1048
+ {#if edgeLabel.bundle !== undefined}
1049
+ <strong class="st-diagramSceneFigure-bundleHeader">{edgeLabel.bundle.header}</strong>
1050
+ {#each edgeLabel.bundle.groups as group, index (index)}
1051
+ <div class="st-diagramSceneFigure-bundleRelation" data-bundle-relation={index}>
1052
+ <span aria-hidden="true">•</span><div>{#each group.lines as line}<span>{line}</span>{/each}</div>
1053
+ </div>
1054
+ {/each}
1055
+ {:else}
1056
+ {#each edgeLabel.lines as line, lineIndex (lineIndex)}<span>{line}</span>{/each}
1057
+ {/if}
1058
+ </div>
1059
+ {/each}
1060
+ {/if}
1061
+ </div>
1062
+ </div>
1063
+ </div>
1064
+ </div>
1065
+ {#if scene}<div class="st-diagramSceneFigure-fallback">{#each sceneTextRows(scene, semanticDocument) as row}<p>{row}</p>{/each}</div>{/if}
1066
+ {#if erdTable}<div class="st-diagramErd-fallback">{@html erdTable}</div>{/if}
1067
+ </figure>
1068
+
1069
+ <style>
1070
+ .st-diagramSceneFigure-fallback { position: absolute; width: var(--st-component-diagramCard-ruleHeight, 1px); height: var(--st-component-diagramCard-ruleHeight, 1px); padding: 0; margin: calc(-1 * var(--st-component-diagramCard-ruleHeight, 1px)); overflow: hidden; clip-path: inset(50%); white-space: nowrap; }
1071
+
1072
+ .st-diagramSceneFigure-flowNavigator { display: flex; align-items: center; gap: var(--st-spacing-2); grid-column: 1 / -1; }
1073
+ .st-diagramSceneFigure-flowHit { fill: none; stroke: var(--st-component-diagramScene-flowHitStroke); stroke-width: var(--st-component-diagramScene-flowHitWidth); pointer-events: stroke; cursor: pointer; }
1074
+ .st-diagramSceneFigure-edge[data-flow-step] { stroke: var(--st-component-diagramScene-flowStroke); stroke-width: var(--st-component-diagramScene-flowStrokeWidth); }
1075
+ .st-diagramSceneFigure-flowArrow { fill: var(--st-component-diagramScene-flowStroke); }
1076
+ .st-diagramSceneFigure-flowBadge, .st-diagramSceneFigure-flowNode { position: absolute; box-sizing: border-box; color: var(--st-component-diagramScene-flowBadgeText); background: var(--st-component-diagramScene-flowBadgeBackground); border: var(--st-component-diagramScene-flowStrokeWidth) solid var(--st-component-diagramScene-flowBadgeBorder); border-radius: var(--st-component-diagramScene-flowBadgeRadius); font-family: var(--st-component-diagramCard-fontFamily); font-size: var(--st-component-diagramScene-flowBadgeFontSize); line-height: var(--st-component-diagramScene-flowBadgeLineHeight); padding: 0; cursor: pointer; }
1077
+ .st-diagramSceneFigure-flowBadge::before { content: ""; position: absolute; left: 50%; top: 50%; transform: translate(-50%, -50%); min-width: 100%; min-height: 100%; width: var(--st-diagramSceneFigure-flowHit); height: var(--st-diagramSceneFigure-flowHit); }
1078
+ .st-diagramSceneFigure-flowNode { opacity: var(--st-component-diagramScene-flowHiddenOpacity); pointer-events: none; min-width: var(--st-diagramSceneFigure-flowHit); min-height: var(--st-diagramSceneFigure-flowHit); }
1079
+ .st-diagramSceneFigure-flowNode:focus-visible { pointer-events: auto; }
1080
+ .st-diagramSceneFigure-flowDescription { position: absolute; clip-path: inset(50%); width: 0; height: 0; overflow: hidden; }
1081
+ [data-flow-active] [data-flow-state="dim"] { opacity: var(--st-component-diagramScene-flowDimOpacity); }
1082
+ .st-diagramSceneFigure-edge[data-flow-state="primary"] { stroke: var(--st-component-diagramScene-flowPrimaryStroke); stroke-width: var(--st-component-diagramScene-flowPrimaryStrokeWidth); }
1083
+ .st-diagramSceneFigure-edge[data-flow-state="related"] { stroke: var(--st-component-diagramScene-flowStroke); stroke-width: var(--st-component-diagramScene-flowRelatedStrokeWidth); }
1084
+ .st-diagramSceneFigure-flowArrow[data-flow-state="primary"] { fill: var(--st-component-diagramScene-flowPrimaryStroke); }
1085
+ .st-diagramSceneFigure-node[data-flow-state="primary"] { outline: var(--st-component-diagramScene-flowOutlineWidth) solid var(--st-component-diagramScene-flowPrimaryStroke); }
1086
+ .st-diagramSceneFigure-flowBadge[aria-pressed="true"] { color: var(--st-component-diagramScene-flowBadgeBackground); background: var(--st-component-diagramScene-flowPrimaryStroke); }
1087
+ .st-diagramSceneFigure-flowNode:not(:focus-visible) { opacity: var(--st-component-diagramScene-flowHiddenOpacity); }
1088
+ .st-diagramSceneFigure-flowBadge:focus-visible, .st-diagramSceneFigure-flowNode:focus-visible { opacity: var(--st-component-diagramScene-flowFullOpacity); outline: var(--st-component-diagramScene-flowOutlineWidth) solid var(--st-component-diagramScene-flowFocusOutline); }
1089
+ .st-diagramErd-toggle { position: absolute; inset: 0 0 auto; height: var(--st-erd-header-height); width: 100%; background: transparent; border: 0; color: transparent; cursor: pointer; }
1090
+ .st-diagramErd-svg { height: 100%; width: 100%; }
1091
+
1092
+ .st-diagramSceneFigure-edgeLabel[data-erd-label] { background: var(--st-semantic-surface-default); }
1093
+ .st-diagramErd-fallback { grid-column: 1 / -1; overflow: auto; color: var(--st-semantic-text-primary); }
1094
+ .st-diagramErd-toggle:focus-visible { outline: var(--st-component-diagramErd-strokeWidth) solid var(--st-semantic-border-interactive); outline-offset: calc(-1 * var(--st-component-diagramErd-strokeWidth)); }
1095
+ .st-diagramSceneFigure {
1096
+ /* Title and camera controls share the first row; the frame spans both. */
1097
+ align-items: center;
1098
+ display: grid;
1099
+ gap: var(--st-spacing-2, 0.5rem);
1100
+ grid-template-columns: minmax(0, 1fr) auto;
1101
+ margin: 0;
1102
+ min-width: 0;
1103
+ }
1104
+ .st-diagramSceneFigure--compact {
1105
+ gap: var(--st-spacing-1, 0.25rem);
1106
+ }
1107
+ .st-diagramSceneFigure-title {
1108
+ color: var(--st-semantic-text-primary);
1109
+ grid-column: 1;
1110
+ font-weight: var(--st-component-button-anatomy-typography-weight);
1111
+ }
1112
+ .st-diagramSceneFigure--compact .st-diagramSceneFigure-title {
1113
+ font-size: var(--st-component-button-anatomy-density-sm-fontSize, 0.875rem);
1114
+ }
1115
+ .st-diagramSceneFigure-controls {
1116
+ align-items: center;
1117
+ display: inline-flex;
1118
+ gap: var(--st-spacing-1, 0.25rem);
1119
+ grid-column: 2;
1120
+ }
1121
+ .st-diagramSceneFigure-readout {
1122
+ color: var(--st-semantic-text-secondary);
1123
+ font-size: var(--st-component-button-anatomy-density-sm-fontSize, 0.875rem);
1124
+ font-variant-numeric: tabular-nums;
1125
+ min-width: var(--st-component-diagramScene-readoutMinWidth);
1126
+ text-align: center;
1127
+ }
1128
+ .st-diagramSceneFigure-frame {
1129
+ grid-column: 1 / -1;
1130
+ min-width: 0;
1131
+ width: 100%;
1132
+ }
1133
+ .st-diagramSceneFigure-viewport {
1134
+ /* The fit box: its height comes from the camera (inline). It scrolls
1135
+ only the axis the drawing overflows at the current zoom. */
1136
+ box-sizing: border-box;
1137
+ overflow: auto;
1138
+ position: relative;
1139
+ touch-action: pan-x pan-y;
1140
+ width: 100%;
1141
+ }
1142
+ .st-diagramSceneFigure-viewport:focus-visible {
1143
+ box-shadow: inset 0 0 0 var(--st-component-diagramCard-borderWidth) var(--st-component-iconButton-focusRing, var(--st-semantic-border-interactive));
1144
+ outline: none;
1145
+ }
1146
+ .st-diagramSceneFigure-extent {
1147
+ min-height: 100%;
1148
+ min-width: 100%;
1149
+ position: relative;
1150
+ }
1151
+ .st-diagramSceneFigure-world {
1152
+ left: 0;
1153
+ position: absolute;
1154
+ top: 0;
1155
+ transform-origin: 0 0;
1156
+ }
1157
+ .st-diagramSceneFigure-node {
1158
+ position: absolute;
1159
+ }
1160
+ .st-diagramSceneFigure-label {
1161
+ align-items: center;
1162
+ box-sizing: border-box;
1163
+ color: var(--st-component-diagramCard-text, var(--st-semantic-text-primary));
1164
+ display: flex;
1165
+ font-family: var(--st-component-diagramCard-fontFamily, var(--st-font-sans, Inter, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif));
1166
+ font-size: var(--st-component-diagramCard-bodyFontSize, 24px);
1167
+ height: 100%;
1168
+ line-height: var(--st-component-diagramCard-bodyLineHeight, 1.3);
1169
+ width: 100%;
1170
+ }
1171
+ .st-diagramSceneFigure-edges {
1172
+ height: var(--st-component-diagramCard-ruleHeight);
1173
+ left: 0;
1174
+ overflow: visible;
1175
+ pointer-events: none;
1176
+ position: absolute;
1177
+ top: 0;
1178
+ width: var(--st-component-diagramCard-ruleHeight);
1179
+ }
1180
+ .st-diagramSceneFigure-edge {
1181
+ fill: none;
1182
+ stroke: var(--st-component-diagramScene-edgeStroke, var(--st-semantic-border-strong));
1183
+ stroke-linejoin: round;
1184
+ stroke-width: var(--st-component-diagramZone-borderWidth, 1.5px);
1185
+ vector-effect: non-scaling-stroke;
1186
+ }
1187
+ .st-diagramSceneFigure-edgeLabel {
1188
+ box-sizing: border-box;
1189
+ background: var(--st-component-diagramScene-labelSurface, var(--st-semantic-surface-raised));
1190
+ box-shadow: inset 0 0 0 var(--st-component-diagramScene-labelBorderWidth, 1px) var(--st-component-diagramScene-labelBorder, var(--st-semantic-border-subtle));
1191
+ align-items: center;
1192
+ color: var(--st-component-diagramScene-labelText, var(--st-semantic-text-primary));
1193
+ display: flex;
1194
+ flex-direction: column;
1195
+ font-family: var(--st-component-diagramCard-fontFamily, var(--st-font-sans, Inter, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif));
1196
+ font-size: var(--st-component-diagramScene-edgeLabelFontSize, 18px);
1197
+ justify-content: center;
1198
+ line-height: var(--st-diagram-label-line-height, var(--st-component-diagramScene-edgeLabelLineHeight, 22px));
1199
+ pointer-events: none;
1200
+ position: absolute;
1201
+ white-space: nowrap;
1202
+ }
1203
+ .st-diagramSceneFigure-edgeLabel > span { display: block; flex: none; height: var(--st-diagram-label-line-height, 22px); }
1204
+ .st-diagramSceneFigure-bundleHeader { display: block; padding: var(--st-component-diagramScene-labelPadding, 4px); font-weight: 400; }
1205
+ .st-diagramSceneFigure-bundleRelation { display: flex; align-self: stretch; gap: var(--st-component-diagramScene-bundleMarkerGap, 6px); padding: var(--st-component-diagramScene-labelPadding, 4px); box-shadow: inset 0 var(--st-component-diagramScene-labelBorderWidth, 1px) 0 var(--st-component-diagramScene-labelBorder, var(--st-semantic-border-subtle)); }
1206
+ .st-diagramSceneFigure-bundleRelation div { display: flex; flex-direction: column; }
1207
+ </style>