jui-tools-mcp-server 2.15.3 → 2.15.7

package/README.md

@@ -55,7 +55,7 @@ bash ~/.jsonui-mcp-server/uninstall.sh
 | `lookup_component` | コンポーネント仕様を取得（属性、binding、プラットフォーム別詳細） |
 | `lookup_attribute` | 属性定義を取得（型、binding対応、使用コンポーネント） |
 | `search_components` | キーワードでコンポーネント/属性を検索 |
-| `get_modifier_order` | プラットフォーム別 modifier 適用順序 |
+| `get_modifier_order` | プラットフォーム別 modifier 適用順序（Swift は jsonui-cli の `sjui_tools/lib/swiftui/views/modifier_order.json` から導出。Kotlin / React は手書きで、`source` にそう出る） |
 | `get_binding_rules` | binding 構文ルール（two-way / read-only） |
 | `get_platform_mapping` | プラットフォーム間の値変換マッピング |
 | `get_screen_identity` | スクリーン正準定義（screen とは何か・id 導出・表示判定述語） |

package/data/attribute_definitions.json

@@ -284,7 +284,7 @@
     },
     "responsive": {
       "type": "object",
-      "description": "Size class overrides. Keys: compact, medium, regular, landscape, or hyphenated combos (e.g. regular-landscape). Values: object of attribute overrides for that size class."
+      "description": "Size class or window-width overrides. Keys: compact, medium, regular, landscape, or hyphenated combos (e.g. regular-landscape); or window-width conditions minWidth:N (the window is at least N wide) and maxWidth:N (narrower than N; N is not included, unlike jsonui-test-runner's maxWidth test condition), N a whole number of pt / dp / CSS px. One block uses size classes or width conditions, never both; every maxWidth's N is at most every minWidth's N; no landscape combination for a width condition. The one key that holds and ranks highest wins alone (size classes: regular-landscape > medium-landscape > compact-landscape > landscape > regular > medium > compact; width: the smallest maxWidth, else the largest minWidth). Values: object of attribute overrides."
     },
     "visibility": {
       "type": [
@@ -1169,7 +1169,7 @@
         "equalSpacing",
         "equalCentering"
       ],
-      "description": "Child distribution for orientation-bearing containers. SwiftUI: Spacer/weight synthesis; Compose: Arrangement.",
+      "description": "Child distribution for orientation-bearing containers. SwiftUI: Spacer/weight synthesis; Compose: Arrangement. `fill` and `fillEqually` distribute SIZE: a child whose width (in a vertical stack, its height) is `wrapContent` grows, and the growing children share the axis \u2014 `fill` grows each from its content, `fillEqually` makes them equal shares of what is left. Only a child that declares a numeric size keeps it. `equalSpacing` and `equalCentering` leave the children's sizes alone and distribute the free space between them (equal gaps / equal centre-to-centre tracks).",
       "platform": [
         "swift",
         "kotlin"
@@ -3544,7 +3544,7 @@
         "equalSpacing",
         "equalCentering"
       ],
-      "description": "Child distribution mode for stacks",
+      "description": "Child distribution mode for stacks. `fill` and `fillEqually` distribute SIZE: a child whose width (in a vertical stack, its height) is `wrapContent` grows, and the growing children share the axis \u2014 `fill` grows each from its content, `fillEqually` makes them equal shares of what is left. Only a child that declares a numeric size keeps it. `equalSpacing` and `equalCentering` leave the children's sizes alone and distribute the free space between them (equal gaps / equal centre-to-centre tracks).",
       "mode": [
         "swiftui",
         "compose",
@@ -4043,7 +4043,7 @@
     },
     "scrollTo": {
       "type": "binding",
-      "description": "Binding that requests a programmatic scroll. The declared DATA CLASS is a plain value, and it decides what the value names, on every path (4f ruling 2026-09-27, round 14; jsonui-cli 1.9.0): an `Int` is a cell's index, a `String` a cell's key. cellIdProperty decides what a cell's key is — its `cellId`, else its cellIdProperty value — and not the class: a Collection with cellIdProperty may declare an `Int`, and one without it a `String` (its cells' cellIds are the keys). What it names across sections (4f ruling 2026-09-27, jsonui-cli 1.9.0; one rule on every path — sjui, kjui and rjui codegen, SwiftJsonUI and KotlinJsonUI Dynamic): an `Int` is the index of a CELL counted across all the drawn sections in order, cells only — a section's header or footer, and a grid's filler, is not counted (the same n as the paging address `<id>_item_<n>`); a `String` is the FIRST cell, in section order, whose key (its `cellId`, else its cellIdProperty value) it is, when two cells share the key — in two sections or in one; a cell with no key has none, and no String names it. A value that names no cell scrolls nowhere. Kotlin only (legacy): a String that is no cell's key and reads `<digits>` or `<digits>#<anything>` scrolls to lazy item <digits>, with a DEBUG warning, on the lazy lists; a container that is not one (the flow, the EAGER one, the wrapContent Column) has no lazy item and does not read it, and iOS and web do not read it. (A consuming Android screen asks its keyed, reverse-laid-out list for its bottom-most item with `\"0#<time>\"`; read as a cell, 0 would be section 0's first cell, which is not the bottom-most item when a later section has cells.) The request is a CHANGE of the value (4f ruling 2026-09-27, jsonui-cli 1.9.0): the value a Collection is drawn with scrolls nowhere, a value arriving where there was none is a change like any other, and sending the same value again does not re-scroll. It is deliberately NOT `PassthroughSubject<Int, Never>`, which this description used to prescribe: PassthroughSubject is a Combine type, and naming a Swift transport in the cross-platform SSoT is what made consumers write it into their data section, where kjui's map_to_kotlin_type passes unknown classes through verbatim and the Kotlin build dies on it. How the request is delivered is each platform's own business — iOS keys `.onChange(of:)` on the value inside a ScrollViewReader, Compose a LaunchedEffect, web a useEffect that compares the value with the one it last saw. STATUS 2026-09-27 (jsonui-cli 1.9.0): every path reads the plain value — sjui and SwiftJsonUI Dynamic, kjui and KotlinJsonUI Dynamic, rjui. On iOS and web it reaches the cells of every route with a scroll container of its own: the lists (the class-list shape's included), the grids, the flows, the horizontal Collections and the pagers — a pager turns to the page the value names, its currentPage when one is bound. On Compose (kjui codegen and KotlinJsonUI Dynamic) it reaches the lazy lists and grids, the horizontal rows, the pagers and a flow that scrolls in its own bounds (4f ruling 2026-09-27, round 11), and the EAGER container (kjui's CollectionStack EAGER, KotlinJsonUI Dynamic's Column and Row) and the Column of a vertical Collection whose height wraps its content (see `lazy`), by the same rule (4f ruling 2026-09-27, round 12); until jsonui-cli 1.9.0 neither scrolled to a cell. Until 1.9.0 kjui codegen read every value as its text and scrolled to that LAZY ITEM index - headers, footers and grid fillers counted -, with cellIdProperty looked an Int up as a key first (so an Int never became a cell there) and read a String without cellIdProperty as the index, scrolled on the value the list was first drawn with, landed bottom and center with the target's top edge at the viewport's bottom edge and middle, drew no scroll on the flow and the pager, and a key two cells shared took the lazy list down (\"Key ... was already used\"); KotlinJsonUI Dynamic read only a SharedFlow<Int>, so the plain value never scrolled, landed center and bottom at the top, and drew no scroll on the flow and the pager. Until 1.9.0 web's grid was no scroll container (a grid of a declared height drew its rows past its box and a scrollTo moved nothing); on iOS the flow (sjui codegen and SwiftJsonUI Dynamic), SwiftJsonUI Dynamic's sectioned List, the class-list List and the pager drew no scroll at all; and a String on a Collection with no cellIdProperty never met a cellId — web read a string of digits there as an index. Until 1.9.0 sjui codegen took what the value names from cellIdProperty, not from the declared class: an `Int` with cellIdProperty did not compile on the class-list List and the pager and scrolled nowhere on the other routes; and its cell ids with cellIdProperty let a String reach a cell with no key (its id was \"\\(index)\"), and gave two cells of one section with one key one id, the cell it reached SwiftUI's choice. A Collection with `lazy: none` has no scroll container of its own and scrolls nowhere. Until 2026-09-27 this paragraph named the SwiftUI Dynamic renderer as the one that could not read a plain value; it was the KotlinJsonUI Dynamic renderer, which reads it today."
+      "description": "Binding that requests a programmatic scroll. The declared DATA CLASS is a plain value, and it decides what the value names, on every path (4f ruling 2026-09-27, round 14; jsonui-cli 1.9.0): an `Int` is a cell's index, a `String` a cell's key. cellIdProperty decides what a cell's key is — its `cellId`, else its cellIdProperty value — and not the class: a Collection with cellIdProperty may declare an `Int`, and one without it a `String` (its cells' cellIds are the keys). What it names across sections (4f ruling 2026-09-27, jsonui-cli 1.9.0; one rule on every path — sjui, kjui and rjui codegen, SwiftJsonUI and KotlinJsonUI Dynamic): an `Int` is the index of a CELL counted across all the drawn sections in order, cells only — a section's header or footer, and a grid's filler, is not counted (the same n as the paging address `<id>_item_<n>`); a `String` is the FIRST cell, in section order, whose key (its `cellId`, else its cellIdProperty value) it is, when two cells share the key — in two sections or in one; a cell with no key has none, and no String names it. A value that names no cell scrolls nowhere. Kotlin only (legacy): a String that is no cell's key and reads `<digits>` or `<digits>#<anything>` scrolls to lazy item <digits>, with a DEBUG warning, on the lazy lists; a container that is not one (the flow, the EAGER one, the wrapContent Column) has no lazy item and does not read it, and iOS and web do not read it. (A consuming Android screen asks its keyed, reverse-laid-out list for its bottom-most item with `\"0#<time>\"`; read as a cell, 0 would be section 0's first cell, which is not the bottom-most item when a later section has cells.) The request is a CHANGE of the value (4f ruling 2026-09-27, jsonui-cli 1.9.0): the value a Collection is drawn with scrolls nowhere, a value arriving where there was none is a change like any other, and sending the same value again does not re-scroll. A landing in flight is left alone by a change to a value that names no cell — \"\", null, a key no cell has, an index out of range — and replaced by a change to a value that names a cell, which lands on its own (jsonui-cli 1.9.26, kjui-collection-scrollto-landing-cancelled-by-next-value: a consumer that names a cell and puts the value back to \"\" 200 ms later, to be able to name it again, cut every Compose landing longer than that; iOS's `.onChange(of:)` never did). It is deliberately NOT `PassthroughSubject<Int, Never>`, which this description used to prescribe: PassthroughSubject is a Combine type, and naming a Swift transport in the cross-platform SSoT is what made consumers write it into their data section, where kjui's map_to_kotlin_type passes unknown classes through verbatim and the Kotlin build dies on it. How the request is delivered is each platform's own business — iOS keys `.onChange(of:)` on the value inside a ScrollViewReader, Compose a LaunchedEffect, web a useEffect that compares the value with the one it last saw. STATUS 2026-09-27 (jsonui-cli 1.9.0): every path reads the plain value — sjui and SwiftJsonUI Dynamic, kjui and KotlinJsonUI Dynamic, rjui. On iOS and web it reaches the cells of every route with a scroll container of its own: the lists (the class-list shape's included), the grids, the flows, the horizontal Collections and the pagers — a pager turns to the page the value names, its currentPage when one is bound. On Compose (kjui codegen and KotlinJsonUI Dynamic) it reaches the lazy lists and grids, the horizontal rows, the pagers and a flow that scrolls in its own bounds (4f ruling 2026-09-27, round 11), and the EAGER container (kjui's CollectionStack EAGER, KotlinJsonUI Dynamic's Column and Row) and the Column of a vertical Collection whose height wraps its content (see `lazy`), by the same rule (4f ruling 2026-09-27, round 12); until jsonui-cli 1.9.0 neither scrolled to a cell. Until 1.9.0 kjui codegen read every value as its text and scrolled to that LAZY ITEM index - headers, footers and grid fillers counted -, with cellIdProperty looked an Int up as a key first (so an Int never became a cell there) and read a String without cellIdProperty as the index, scrolled on the value the list was first drawn with, landed bottom and center with the target's top edge at the viewport's bottom edge and middle, drew no scroll on the flow and the pager, and a key two cells shared took the lazy list down (\"Key ... was already used\"); KotlinJsonUI Dynamic read only a SharedFlow<Int>, so the plain value never scrolled, landed center and bottom at the top, and drew no scroll on the flow and the pager. Until 1.9.0 web's grid was no scroll container (a grid of a declared height drew its rows past its box and a scrollTo moved nothing); on iOS the flow (sjui codegen and SwiftJsonUI Dynamic), SwiftJsonUI Dynamic's sectioned List, the class-list List and the pager drew no scroll at all; and a String on a Collection with no cellIdProperty never met a cellId — web read a string of digits there as an index. Until 1.9.0 sjui codegen took what the value names from cellIdProperty, not from the declared class: an `Int` with cellIdProperty did not compile on the class-list List and the pager and scrolled nowhere on the other routes; and its cell ids with cellIdProperty let a String reach a cell with no key (its id was \"\\(index)\"), and gave two cells of one section with one key one id, the cell it reached SwiftUI's choice. A Collection with `lazy: none` has no scroll container of its own and scrolls nowhere. Until 2026-09-27 this paragraph named the SwiftUI Dynamic renderer as the one that could not read a plain value; it was the KotlinJsonUI Dynamic renderer, which reads it today."
     },
     "scrollAnchor": {
       "type": "string",
@@ -4453,7 +4453,7 @@
         "large",
         "linear"
       ],
-      "description": "Indicator style: `small` / `medium` / `large` are the spinner's size (`medium` the platform's own) and `linear` a bar instead of a spinner. A declared width / height wins over the style's size. The legacy spellings `style` (naming one of these values) and `size` (a length) are folded by the layout normalizer, with a warning: `style` into this attribute, `size` into width and height.",
+      "description": "Indicator style: `small` / `medium` / `large` are the spinner's size and `linear` a bar instead of a spinner. Each size is the platform's own value, `small` and `large` as well as `medium` (2026-10-05 user ruling): the faces need not draw the same small or large spinner. A declared width / height wins over the style's size. The legacy spellings `style` (naming one of these values) and `size` (a length) are folded by the layout normalizer, with a warning: `style` into this attribute, `size` into width and height.",
       "platform": [
         "swift",
         "kotlin"

package/data/attribute_semantics.json

@@ -181,7 +181,7 @@
       },
       "perValueMapping": {
         "fill": {
-          "swiftui": ".frame(maxWidth/maxHeight: .infinity) on each child",
+          "swiftui": "grow from content: DistributionFillLayout in SwiftJsonUI (10.29.6), content size plus an equal share of the leftover, the same policy as Compose's DistributionFillRow/Column; each undeclared child still takes .frame(maxWidth/maxHeight: .infinity), which is how the layout knows it may grow. An HStack/VStack of those children split the axis equally, which is fillEqually (frame-parity common/distribution__fill, 2026-10-05: 60 / 120 / 120 against Android 60 / 97 / 143)",
           "compose": "grow from content — NOT expressible with Modifier.weight (weight(1f) IS fillEqually, the run-4 0px collapse; weight(1f, fill=false) packs by content and is inert). Dedicated measurement pass DistributionFillRow/Column in the base KotlinJsonUI library (c7d2dfb): content size plus an equal split of the leftover, one policy shared by the kjui codegen emit and the dynamic renderer. Device-verified: all 6 value pairs pairwise distinct, explicit child size never grown, spacing gaps pinned",
           "web": "grow on each child"
         },
@@ -210,7 +210,7 @@
         "edgeSpacerGate": "equalCentering's edge spacers are suppressed ONLY on a wrapContent axis (declared size nil): with no free space a Spacer would expand the container and swallow the trailing padding (the measured round-3 bug). A FIXED numeric size has free space for the ratio and KEEPS its edge spacers — the older widthExpands gate (matchParent/-1/.infinity) was too narrow for it (F, e8f99c7, decision 2)",
         "note": "Pinned 2026-08-06 (E's proposal, orchestrator-approved: implement this release, B codegen + F dynamic) so the two ios paths emit ONE counting instead of deriving Spacer arithmetic twice — two paths growing children separately is exactly what collapsed distribution's SIZE half before c7d2dfb. Spacer counting suffices because HStack/VStack split free space equally among unconstrained Spacers: the 1:2 end:between count ratio IS space-around's half-gap. No custom Layout, no measurement pass. Acceptance is already wired: when this lands, run 6 must delete collapsedPairs' ios row and turn the two value_discrimination receiving rows stale. Regression-test discipline from F's landing: a partial reversion (between 2->1 only) builds an equal-three-spacer structure the first sample points slipped past — pin BOTH sides of the computed boundary (55 in the 300pt fixture) so partial and full reversion both fail."
       },
-      "explicitChildSizeWins": "an explicit child width/height beats distribution's size half — size topic's explicit > bounds > fill",
+      "explicitChildSizeWins": "an explicit child width/height beats distribution's size half — size topic's explicit > bounds > fill. Explicit = a numeric size. wrapContent (and an undeclared axis, which the validator refuses) is a child fill grows. User ruling 2026-10-07 (relayed by the orchestrator): distribution（fill / fillEqually）で `width: wrapContent` の子は伸ばす。「明示された大きさ」は数値だけ。理由: width は required なので、wrapContent まで明示に入れると、正しい layout で fill が伸ばせる子が無くなる。 Measured before the ruling: KotlinJsonUI 2.43.5 Dynamic drew wrapContent children of a fill row at their content width (View/ and common/ distribution__fill / __fillequally, 2026-10-07); sjui codegen and KotlinJsonUI Dynamic's own fill decision already read only a numeric size as explicit.",
       "collapsedPairs": {},
       "observableNote": "MEASURED 2026-08-08 (run 31243724782 + local-env): uniformly active — the divergence this entry recorded was fixed in-wave (ios Blur bridge / ios highlighted swap / ios distribution fill / ios loadingImage via pending.invalid / border emit on all faces)."
     },
@@ -368,6 +368,19 @@
       "observable": {},
       "overflowHitTesting": "hit testing follows CLIPPING, not the parent frame: an unclipped overflow is drawn and therefore tappable; a clipped one is neither"
     },
+    "idBox": {
+      "attributes": [
+        "common.id"
+      ],
+      "box": "an id names its element's box: inside the margin, including the padding, moved by the offset",
+      "ruling": "2026-10-06, user: 「マージンはそのビューの要素じゃない」 (the margin is not the element), 「パディングはその要素だからね」 (the padding is the element), and the id box moves with the offset (Android's measured result, accepted as the target). This is the box a UI test driver taps and reads (XCUIElement.frame on iOS, accessibility bounds on Android). iOS measured it against the layout box in SwiftJsonUI ConformanceHost IdBoxProbeUITests and CellIdBoxProbeUITests; containers met it from SwiftJsonUI 10.29.7 / jsonui-cli 1.9.18, when the 0.5pt single-child merge anchor moved inside the offset and the margins.",
+      "platformConventions": {
+        "androidButtonTouchTarget": "Android: a Button's id box is at least 48dp high (Material's minimum touch target), centred on the declared box — (25,6,100,48) for a 100 x 40 Button. A platform convention, not a defect (2026-10-06). iOS keeps the declared 40.",
+        "iosTextFieldInputArea": "iOS: a TextField's id box is the input field itself, inside the padding — (33,19,84,22) for a 100 x 40 field with padding 8. SwiftUI's TextField cannot be made larger than its line, and every placement that gives the padded box either takes the id off the input (an Other container with no value, which a text assertion cannot read) or cannot be typed into (measured 2026-10-06, six placements). With a symmetric padding the box's centre, where a tap aims, is the same. User ruling 2026-10-06: recorded as an iOS convention, not fixed. The id stays on the input field."
+      },
+      "collectionCellRoot": "A cell's root is addressed as `{collectionId}_item_{N}`. An id declared on the root is not used under the item address: the item address and the root's id would name the same element, which carries one identifier, so the root's own id is not found (iOS Dynamic and codegen, Android, measured 2026-10-06). The item's box is the root's box by the rule above. User ruling 2026-10-06.",
+      "observable": {}
+    },
     "sliderRange": {
       "attributes": [
         "Slider.minimum",
@@ -395,6 +408,114 @@
       },
       "ruling": "2026-09-26 (4f, round 5 of the Collection audit). Until jsonui-cli 1.9.0 no declaration said what an undeclared Collection spacing draws, and the paths had each picked one: 0 everywhere except the flow route on iOS — sjui codegen 8 between cells, lines and section blocks; SwiftJsonUI Dynamic 8 on the lazy flow (its section blocks the ScrollView's own stack spacing) and `x > 0 ? x : 8` on the `lazy: none` flow, so a declared 0 drew 8. Android and web drew 0. The ruling: 0, flow included, on every route and every path. Declared HERE and not as a `default` in attribute_definitions.json, on purpose: a `default` there changes the attribute's kind — the conformance fixture generator writes the declared default as the fixture's value, the inert audit lists it, and attr codegen carries it into the generated tables — and the rule is per route, which one scalar cannot say. `sectionSpacing` is lineSpacing's alias (definitions `aliases`). Toolchain comments point here.",
       "observable": {}
+    },
+    "backgroundSafeArea": {
+      "attributes": [
+        "common.background"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the frame-parity inventory: docs/bugs/material/frame-parity-inventory-3face-2026-10-05/rulings.md). When a view with a background touches the canvas edge next to a safe-area inset (the status-bar band above it), iOS painting the background into that band is an accepted iOS idiom; Android and web stopping at the view's frame are equally correct. The view's layout frame is the same on every face; only the paint may reach the band. Measured: SwiftUI's default for a background touching a safe-area edge (iOS frame y -62, height +62 or more, 340 ids), Android and web y 0. Not a reason to move the layout box.",
+      "observable": {}
+    },
+    "borderContentBox": {
+      "attributes": [
+        "common.borderWidth",
+        "common.borderColor"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the frame-parity inventory: docs/bugs/material/frame-parity-inventory-3face-2026-10-05/rulings.md). A border does NOT push the content inward: the view's children keep the positions they have without the border, and the border is drawn over them. A border on a wrapContent Label does not add to its height. Measured deviation: web insets children by the border width (2, 2) and adds 2 x borderWidth to a Label's height; iOS and Android draw over the content. See also `border` (when a border is drawn at all).",
+      "observable": {},
+      "inputFieldException": "TextField, TextView and SelectBox are the exception, declared so it is not a silent one: an input field's border is the control's chrome, and where its text sits inside that border is the platform's idiom. Web keeps a CSS border on input fields (rjui border_draws_over_content? is false for them) so the text never runs under the frame and the outline stays free for the focus ring. Every other web border is drawn over the content with ::after (an outline only for replaced elements such as <img>, which cannot hold ::after): outline does not follow rounded corners before Safari 16.4, and an inset box-shadow is painted under a child touching the edge (triage branch triage/1916-rjui-geometry, commit 7cee4bdb; it replaced 5898c2cf on rebase). Not covered by any fixture yet: the conformance corpus has no input field that declares a border (triage, scanning the web-scoped manifest), so this exception is not measured by the gate until one is added."
+    },
+    "stackOverflow": {
+      "attributes": [
+        "View.orientation",
+        "View.spacing",
+        "common.paddings"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the frame-parity inventory: docs/bugs/material/frame-parity-inventory-3face-2026-10-05/rulings.md). When a fixed-size row's (or column's) children, with its padding and spacing, exceed its size, the children are still placed in sequence at their declared sizes and the overflow runs past the far edge; no child is moved back inside. Measured deviation: Android holds the last child at 180 in a 200 row of six 40s; iOS and web place it at 200 (208 with paddingLeft 8, 240 with spacing 8).",
+      "observable": {}
+    },
+    "distributionRemainder": {
+      "attributes": [
+        "View.distribution"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the frame-parity inventory: docs/bugs/material/frame-parity-inventory-3face-2026-10-05/rulings.md). In a `fillEqually` stack where some children declare their size on the distribution axis, those children keep their declared size (distribution.explicitChildSizeWins) and the REMAINING space is shared equally by the others: 300 wide, one child declaring 60 and two undeclared -> 60 / 120 / 120. Measured before the ruling: Android 60 / 100 / 100 (40 left empty), web 100 / 100 / 100.",
+      "observable": {}
+    },
+    "emptyLabelHeight": {
+      "attributes": [
+        "Label.text",
+        "common.height"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the frame-parity inventory: docs/bugs/material/frame-parity-inventory-3face-2026-10-05/rulings.md). A Label whose text is empty and whose height is wrapContent still has the height of one line of its font; wrapContent does not collapse it to 0. Measured before the ruling: Android 24, web 0.",
+      "observable": {}
+    },
+    "labelHint": {
+      "attributes": [
+        "Label.hint",
+        "Label.hintAttributes"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the frame-parity inventory: docs/bugs/material/frame-parity-inventory-3face-2026-10-05/rulings.md). `Label.hint` is shown when the text is empty whether or not `hintAttributes` is declared; without hintAttributes it is drawn in the platform's default subdued hint colour at the Label's font. Measured before the ruling: rjui and Android required hintAttributes to show the hint.",
+      "observable": {}
+    },
+    "lineBreakModeLines": {
+      "attributes": [
+        "Label.lineBreakMode",
+        "Label.lines"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the frame-parity inventory: docs/bugs/material/frame-parity-inventory-3face-2026-10-05/rulings.md). `lineBreakMode` (head / middle / tail / clip) chooses HOW the last allowed line is truncated; it does not mean one line. The number of lines is `lines` alone (0 or absent: unlimited), so with no `lines` the text wraps and nothing is truncated. Measured before the ruling: web drew one line (24), Android wrapped (120).",
+      "observable": {}
+    },
+    "lineHeightMultipleBase": {
+      "attributes": [
+        "Label.lineHeightMultiple"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the frame-parity inventory: docs/bugs/material/frame-parity-inventory-3face-2026-10-05/rulings.md). `lineHeightMultiple` multiplies the font's own (natural) line height, not the font size. Measured before the ruling: lineHeightMultiple 1.8 drew 127.5 on Android and 143.98 on web. The base line height L is defined by a second user ruling (2026-10-05, relayed by the orchestrator): L is the height of one line of a Label on that platform that declares no lineHeight, at the Label's fontSize (with no fontSize: iOS 20.33, Android 24, web 24, measured on the conformance hosts; with a fontSize, one line of an undeclared-lineHeight Label at that size). lineHeightMultiple makes every line m x L; lineSpacing is added between lines only. iOS draws no multiple on the first line: SwiftUI has no way to set each line's height, so the first line stays L and the lines after it are m x L apart (2026-10-05 user instruction, relayed by the orchestrator: no elaborate implementation for this). So n lines are L + (n - 1) x m x L on iOS, (m - 1) x L short of the n x m x L the other platforms draw; frame_parity_rules.json pins that amount. Expected for three lines at m = 1.8 with no fontSize: iOS 93.52 (20.33 + 2 x 36.59), Android 129.6, web 129.6. Measured before (three-line probe, pixels): iOS 88.33 (it adds (m - 1) x fontSize between lines), Android 76.5 (it multiplied a fallback fontSize 14), web 86.4 (it multiplied the font size 16).",
+      "observable": {}
+    },
+    "lineSpacingBetween": {
+      "attributes": [
+        "Label.lineSpacing"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the frame-parity inventory: docs/bugs/material/frame-parity-inventory-3face-2026-10-05/rulings.md). `lineSpacing` is added BETWEEN lines only: n lines get n - 1 spacings, and nothing is added after the last line. Measured before the ruling: lineSpacing 16 drew 150 on Android and 160 on web. The base line height L is defined by a second user ruling (2026-10-05, relayed by the orchestrator): L is the height of one line of a Label on that platform that declares no lineHeight, at the Label's fontSize (with no fontSize: iOS 20.33, Android 24, web 24, measured on the conformance hosts; with a fontSize, one line of an undeclared-lineHeight Label at that size). lineHeightMultiple makes every line m x L; lineSpacing is added between lines only. So n lines are n x L + (n - 1) x lineSpacing. Expected for three lines at 16 with no fontSize: iOS 93, Android 104, web 104. Measured before (three-line probe, pixels): iOS 93 (already so: SwiftUI's lineSpacing replaces its default 1.67 leading), Android 90 and web 96 (both added the spacing to every line).",
+      "observable": {}
+    },
+    "iconLabelIconSize": {
+      "attributes": [
+        "IconLabel.iconSize",
+        "IconLabel.icon_on",
+        "IconLabel.icon_off"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the frame-parity inventory: docs/bugs/material/frame-parity-inventory-3face-2026-10-05/rulings.md). When `iconSize` is not declared: an IconLabel with no icon reserves no space for one, and one with an icon draws it at the image's own size. Measured before the ruling: web reserved a 96 icon box with no icon declared, Android none (height 24 vs 96).",
+      "observable": {}
+    },
+    "stackDirection": {
+      "attributes": [
+        "View.direction",
+        "SafeAreaView.direction"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the frame-parity inventory: docs/bugs/material/frame-parity-inventory-3face-2026-10-05/rulings.md). `direction: bottomToTop` stacks from the BOTTOM edge: the first child is the lowest, and each next child sits above it. (The same reading applies to the other directions: the first child sits at the edge the direction starts from.) Measured before the ruling: in a 200-high column of 40s, iOS and Android put box_b at 160, web at 120; SafeAreaView bottomToTop: Android stacked at the top (0 / 40 / 80), web at the bottom (728 / 688 / 648). 2026-10-05 user ruling (bottomToTop) applied to the horizontal axis by the orchestrator: `direction: rightToLeft` stacks from the RIGHT edge: the first child is the rightmost, and each next child sits to its left (the usual meaning of right-to-left). Measured before (frame-parity inventory, View/direction__righttoleft, six 40-wide boxes in a 200-wide row): web put box_a at x 160 and box_f at -40 (from the right edge, as declared); iOS (box_a 200 ... box_f 0) and Android (box_a 180, then 160 ... 0) reverse the children and stack them from the left.",
+      "observable": {}
+    },
+    "wrapContentCap": {
+      "attributes": [
+        "common.width",
+        "common.height"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, from the three-face conformance run): \"Wrapcontent は Android が正しいね。親の大きさが固定や matchparent ならその大きさまで\". A wrapContent box (or one with no size declared on that axis) takes its content's size, but no more than its parent's size on that axis when the parent has one there: a number, or matchParent. A parent that scrolls along that axis (a ScrollView's content axis) has none, and neither does a wrapContent parent. Measured before the ruling: a flow Collection, lazy none, wrapContent in a 150x100 parent (Collection/flowOverflow__noneWrapInBox and its control) was 168 high on web, 100 on Android. Distinct from ruling S: a child with a FIXED size larger than its parent keeps that size and overflows; the cap applies to the wrapContent box itself only.",
+      "iosLimitation": "SwiftUI: not enforced; a wrapContent box may report its content's size past a sized parent (declared limitation, 2026-10-06 user ruling). SwiftUI offers a child its share of a stack, not its parent's size, and a vertical ScrollView frames its content at least the viewport high, so a cap read from the offer squeezed wrapContent rows inside scrolling content below their content (measured on a consumer screen, 14.3pt -> 9.2pt); it was dropped rather than built around."
+    },
+    "iconLabelTextLine": {
+      "attributes": [
+        "IconLabel.text",
+        "IconLabel.fontSize"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator): the text line of an IconLabel is the same as one line of a Label on the same platform at the same font size (lineHeightMultipleBase's L). An IconLabel draws no taller or shorter text line than a Label would."
+    },
+    "labelLongWordBreak": {
+      "attributes": [
+        "Label.text"
+      ],
+      "ruling": "2026-10-05 user ruling (relayed by the orchestrator, answered as a choice): a word longer than the Label's box breaks inside the box — only the word that does not fit is cut at the box's width and carried to the next line (CSS `overflow-wrap: anywhere`); where it breaks may differ per OS. Measured before the ruling: a 200-wide Label with \"See https://example.com/conformance for details\" (Label/linkable__* and __control/Label__text-5ed92def) wrapped the URL inside the box on iOS and Android and let it run past the box on web. A declared lineBreakMode Char / Word keeps its own rule."
     }
   }
 }

package/data/modifier_order.json

@@ -0,0 +1,57 @@
+{
+  "_about": [
+    "The order sjui codegen emits SwiftUI modifiers in, for SwiftJsonUI to hold its Dynamic runtime to (DynamicModifierHelper.standardOrder).",
+    "bag: ModifierBag::MODIFIER_ORDER (swiftui/views/modifier_bag.rb), the order emit_all writes the registered keys in.",
+    "after_bag: what BaseViewConverter writes after the bag, in order: the accessibilityIdentifier, then .disabled again outside it (apply_outer_disabled).",
+    "shared_slots: keys that carry more than one attribute family, in the order their entries are written: :padding gets padding first, then insets (SpacingHelper#apply_insets appends to :padding after apply_padding).",
+    "spec/swiftui/views/modifier_order_json_spec.rb holds this file to the constant and to generated code. Change them together; SwiftJsonUI copies this file byte for byte and its CI compares the copy with this file at its pinned jsonui-cli ref."
+  ],
+  "bag": [
+    "component_specific",
+    "padding",
+    "frame_constraints",
+    "fixed_size",
+    "frame_size",
+    "background",
+    "gradient",
+    "glass",
+    "corner_radius",
+    "border",
+    "shadow",
+    "clip_to_bounds",
+    "foreground_color",
+    "opacity",
+    "hidden",
+    "accessibility_anchor",
+    "conformance_frame",
+    "on_click",
+    "on_long_press",
+    "on_pan",
+    "on_pinch",
+    "allows_hit_testing",
+    "offset",
+    "margin",
+    "tint_color",
+    "on_value_change",
+    "on_text_change",
+    "on_appear",
+    "on_disappear",
+    "confirmation_dialog",
+    "alert",
+    "safe_area_insets",
+    "tag",
+    "z_index",
+    "accessibility_id",
+    "disabled"
+  ],
+  "after_bag": [
+    "accessibility_identifier",
+    "disabled"
+  ],
+  "shared_slots": {
+    "padding": [
+      "padding",
+      "insets"
+    ]
+  }
+}

package/dist/data/derived.d.ts

@@ -10,7 +10,6 @@ export declare function categorizeCommonAttributes(commonAttrs: Record<string, a
 export declare const MODIFIER_ORDER: {
     description: string;
     swift: {
-        order: string[];
         criticalRules: string[];
     };
     kotlin: {

package/dist/data/derived.js

@@ -94,32 +94,11 @@ export function categorizeCommonAttributes(commonAttrs) {
 // ----- modifier order (platform rendering) -------------------------------
 export const MODIFIER_ORDER = {
     description: "Platform-specific modifier application order. Order affects rendering.",
+    // Swift's order is not restated here: SpecLoader.getModifierOrder reads it
+    // from jsonui-cli's sjui_tools/lib/swiftui/views/modifier_order.json. The
+    // list that stood here had drifted from it (margins before offset, onClick
+    // after the margins). Only the prose rules stay.
     swift: {
-        order: [
-            "centerAlignment",
-            "edgeAlignment",
-            "padding",
-            "frameConstraints (min/max)",
-            "frameSize (width/height)",
-            "insets/insetHorizontal",
-            "background",
-            "cornerRadius",
-            "border",
-            "margins",
-            "alpha/opacity",
-            "shadow",
-            "clipping",
-            "offset",
-            "visibility (hidden/opacity ternary)",
-            "safeAreaInsets",
-            "disabled",
-            "tag (for TabView)",
-            "tintColor",
-            "onClick/onTapGesture",
-            "lifecycle (onAppear/onDisappear)",
-            "confirmationDialog",
-            "accessibilityIdentifier",
-        ],
         criticalRules: [
             "background MUST come after padding (background includes padding area)",
             "border MUST come after cornerRadius (for rounded border)",
@@ -130,10 +109,11 @@ export const MODIFIER_ORDER = {
     },
     kotlin: {
         order: [
-            "testTag",
             "margins",
             "weight (caller applies)",
             "size (width/height, matchParent/wrapContent, min/max/aspectRatio)",
+            "offset",
+            "testTag (with testTagsAsResourceId): after margins and offset, so the tagged node's bounds are the drawn box",
             "alpha/opacity",
             "shadow/elevation",
             "background (cornerRadius -> clip -> border -> bgColor)",
@@ -144,6 +124,7 @@ export const MODIFIER_ORDER = {
         criticalRules: [
             "Modifier.then() chains left-to-right; order matters",
             "margins before size (outside to inside)",
+            "testTag after margins and offset (from KotlinJsonUI 2.43.5 / jsonui-cli 1.9.16): a tag outside them reports a margin-inclusive box to accessibility",
             "cornerRadius must be applied as clip before background",
         ],
     },

package/dist/spec_loader.d.ts

@@ -74,6 +74,7 @@ export interface DataSourceInfo {
     platformSemantics: FileInfo | null;
     coverage: FileInfo | null;
     typeSynonyms: FileInfo | null;
+    swiftModifierOrder: FileInfo | null;
     componentCount: number;
     commonAttributeCount: number;
 }
@@ -98,6 +99,7 @@ export declare class SpecLoader {
     private platformSemantics;
     private coverageGaps;
     private screenIdentity;
+    private swiftModifierOrder;
     private commonAttributes;
     private aliasMap;
     private typeSynonyms;
@@ -136,7 +138,17 @@ export declare class SpecLoader {
     searchComponents(query: string): any[];
     /** Keyword-indexed topical guides, each backed by a dedicated MCP tool. */
     private topicGuides;
+    /**
+     * The Swift order is read from jsonui-cli's modifier_order.json, the order
+     * sjui codegen emits and SwiftJsonUI's Dynamic chain is tested against. It
+     * was a hand-written list here (derived.ts), and it had drifted: margins
+     * before offset, onClick after the margins — while jsonui-cli 1.9.20 puts
+     * the tap inside the offset and the margins (ticket mcp-get-modifier-order-
+     * swift-is-a-hand-written-list-that-drifted). Kotlin and React have no such
+     * file in jsonui-cli; they stay hand-written and say so (`source`).
+     */
     getModifierOrder(platform?: string): any;
+    private swiftModifierOrderEntry;
     /**
      * The canonical screen-identity asset, or null when this checkout predates
      * it. Served verbatim: it is a declaration, not something to restate.

package/dist/spec_loader.js

@@ -57,6 +57,7 @@ export class SpecLoader {
     /// the note explains why (backlog, alias normalization, runtime-only, ...).
     coverageGaps = null;
     screenIdentity = null;
+    swiftModifierOrder = null;
     commonAttributes = null;
     aliasMap = new Map();
     /// Lower-cased spelling -> its entry in type_synonyms.json, for the
@@ -274,10 +275,45 @@ export class SpecLoader {
         }
         return guides;
     }
+    /**
+     * The Swift order is read from jsonui-cli's modifier_order.json, the order
+     * sjui codegen emits and SwiftJsonUI's Dynamic chain is tested against. It
+     * was a hand-written list here (derived.ts), and it had drifted: margins
+     * before offset, onClick after the margins — while jsonui-cli 1.9.20 puts
+     * the tap inside the offset and the margins (ticket mcp-get-modifier-order-
+     * swift-is-a-hand-written-list-that-drifted). Kotlin and React have no such
+     * file in jsonui-cli; they stay hand-written and say so (`source`).
+     */
     getModifierOrder(platform) {
+        const swift = this.swiftModifierOrderEntry();
+        const all = { ...MODIFIER_ORDER, swift };
+        for (const key of ["kotlin", "react"]) {
+            all[key] = { source: "hand-written in jsonui-mcp-server (src/data/derived.ts); jsonui-cli has no order file for it", ...MODIFIER_ORDER[key] };
+        }
         if (platform)
-            return MODIFIER_ORDER[platform] || null;
-        return MODIFIER_ORDER;
+            return all[platform] || null;
+        return all;
+    }
+    swiftModifierOrderEntry() {
+        const doc = this.swiftModifierOrder;
+        const file = this.dataSource?.swiftModifierOrder;
+        if (!doc || !file || !Array.isArray(doc.bag)) {
+            return {
+                source: "unavailable: sjui_tools/lib/swiftui/views/modifier_order.json did not resolve",
+                order: null,
+            };
+        }
+        const afterBag = Array.isArray(doc.after_bag) ? doc.after_bag : [];
+        return {
+            source: `jsonui-cli sjui_tools/lib/swiftui/views/modifier_order.json (${file.layer}: ${file.path})`,
+            // The bag in the order it is written, then what is written after it.
+            order: [...doc.bag, ...afterBag.map((k) => `${k} (after the bag)`)],
+            bag: doc.bag,
+            afterBag,
+            sharedSlots: doc.shared_slots ?? {},
+            about: doc._about ?? [],
+            criticalRules: MODIFIER_ORDER.swift?.criticalRules ?? [],
+        };
     }
     /**
      * The canonical screen-identity asset, or null when this checkout predates
@@ -311,6 +347,7 @@ export class SpecLoader {
             this.dataSource.platformSemantics,
             this.dataSource.coverage,
             this.dataSource.typeSynonyms,
+            this.dataSource.swiftModifierOrder,
         ].filter((f) => f != null);
         const changed = [];
         for (const file of tracked) {
@@ -480,6 +517,17 @@ export class SpecLoader {
             componentCount++;
         }
         const typeSynonymsResolution = this.loadTypeSynonyms();
+        // sjui's SwiftUI modifier order (get_modifier_order's Swift answer).
+        // Optional for the same backward-compat reason.
+        let swiftModifierOrderResolution = null;
+        try {
+            const orderResolution = this.resolveFile("sjui_tools/lib/swiftui/views/modifier_order.json", "data/modifier_order.json");
+            this.swiftModifierOrder = JSON.parse(readFileSync(orderResolution.path, "utf-8"));
+            swiftModifierOrderResolution = orderResolution;
+        }
+        catch {
+            this.swiftModifierOrder = null;
+        }
         this.dataSource = {
             attributeDefinitions: attrResolution,
             componentMetadata: metaResolution,
@@ -489,6 +537,7 @@ export class SpecLoader {
             platformSemantics: platformSemanticsResolution,
             coverage: coverageResolution,
             typeSynonyms: typeSynonymsResolution,
+            swiftModifierOrder: swiftModifierOrderResolution,
             componentCount,
             commonAttributeCount: Object.keys(this.commonAttributesRaw).filter((k) => !k.startsWith("_")).length,
         };

package/docs/design.md

@@ -74,7 +74,11 @@ jsonui-cli files — it encodes fixed cross-platform conventions:
   lifecycle / accessibility / binding buckets for the lookup tools.
 
 These are served directly by the `get_modifier_order`,
-`get_binding_rules`, and `get_platform_mapping` tools.
+`get_binding_rules`, and `get_platform_mapping` tools — except Swift's
+modifier order, which `get_modifier_order` reads from jsonui-cli's
+`sjui_tools/lib/swiftui/views/modifier_order.json` (bundled as
+`data/modifier_order.json`): the hand-written list that stood in
+`MODIFIER_ORDER.swift` had drifted from what sjui emits.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jui-tools-mcp-server",
-  "version": "2.15.3",
+  "version": "2.15.7",
   "description": "MCP server for JsonUI project management - wraps jui and jsonui-doc CLIs plus component spec lookup",
   "main": "dist/index.js",
   "scripts": {

package/scripts/fetch-definitions.js

@@ -44,7 +44,7 @@ const DATA_DIR = join(PROJECT_ROOT, "data");
 //   3. `npm run fetch-definitions` and commit the data/ diff together with
 //      this pin in one commit
 // JSONUI_CLI_RAW_BASE still overrides the whole base URL for manual testing.
-const JSONUI_CLI_TAG = "v1.9.8";
+const JSONUI_CLI_TAG = "v1.9.26";
 const BASE_URL =
   process.env.JSONUI_CLI_RAW_BASE ||
   `https://raw.githubusercontent.com/Tai-Kimura/jsonui-cli/${JSONUI_CLI_TAG}`;

package/scripts/fetch-manifest.js

@@ -65,6 +65,12 @@ export const FILES = [
     remote: "shared/core/type_synonyms.json",
     local: "type_synonyms.json",
   },
+  // sjui's SwiftUI modifier order: get_modifier_order serves its Swift
+  // answer from it rather than from a hand-kept list.
+  {
+    remote: "sjui_tools/lib/swiftui/views/modifier_order.json",
+    local: "modifier_order.json",
+  },
   {
     remote: "conformance/coverage.json",
     local: "coverage.json",

package/src/data/derived.ts

@@ -100,32 +100,11 @@ export function categorizeCommonAttributes(commonAttrs: Record<string, any>): an
 export const MODIFIER_ORDER = {
   description:
     "Platform-specific modifier application order. Order affects rendering.",
+  // Swift's order is not restated here: SpecLoader.getModifierOrder reads it
+  // from jsonui-cli's sjui_tools/lib/swiftui/views/modifier_order.json. The
+  // list that stood here had drifted from it (margins before offset, onClick
+  // after the margins). Only the prose rules stay.
   swift: {
-    order: [
-      "centerAlignment",
-      "edgeAlignment",
-      "padding",
-      "frameConstraints (min/max)",
-      "frameSize (width/height)",
-      "insets/insetHorizontal",
-      "background",
-      "cornerRadius",
-      "border",
-      "margins",
-      "alpha/opacity",
-      "shadow",
-      "clipping",
-      "offset",
-      "visibility (hidden/opacity ternary)",
-      "safeAreaInsets",
-      "disabled",
-      "tag (for TabView)",
-      "tintColor",
-      "onClick/onTapGesture",
-      "lifecycle (onAppear/onDisappear)",
-      "confirmationDialog",
-      "accessibilityIdentifier",
-    ],
     criticalRules: [
       "background MUST come after padding (background includes padding area)",
       "border MUST come after cornerRadius (for rounded border)",
@@ -136,10 +115,11 @@ export const MODIFIER_ORDER = {
   },
   kotlin: {
     order: [
-      "testTag",
       "margins",
       "weight (caller applies)",
       "size (width/height, matchParent/wrapContent, min/max/aspectRatio)",
+      "offset",
+      "testTag (with testTagsAsResourceId): after margins and offset, so the tagged node's bounds are the drawn box",
       "alpha/opacity",
       "shadow/elevation",
       "background (cornerRadius -> clip -> border -> bgColor)",
@@ -150,6 +130,7 @@ export const MODIFIER_ORDER = {
     criticalRules: [
       "Modifier.then() chains left-to-right; order matters",
       "margins before size (outside to inside)",
+      "testTag after margins and offset (from KotlinJsonUI 2.43.5 / jsonui-cli 1.9.16): a tag outside them reports a margin-inclusive box to accessibility",
       "cornerRadius must be applied as clip before background",
     ],
   },

package/src/spec_loader.ts

@@ -126,6 +126,11 @@ export interface DataSourceInfo {
   /// section they are not (ProgressBar, HStack, Text …). Optional: absent on
   /// jsonui-cli before 1.9.0.
   typeSynonyms: FileInfo | null;
+  /// sjui_tools/lib/swiftui/views/modifier_order.json — the order sjui
+  /// codegen emits SwiftUI modifiers in, which SwiftJsonUI's Dynamic chain
+  /// is held to. get_modifier_order serves its Swift order from it. Optional:
+  /// absent on jsonui-cli before 1.9.x.
+  swiftModifierOrder: FileInfo | null;
   componentCount: number;
   commonAttributeCount: number;
 }
@@ -170,6 +175,7 @@ export class SpecLoader {
   /// the note explains why (backlog, alias normalization, runtime-only, ...).
   private coverageGaps: Map<string, any[]> | null = null;
   private screenIdentity: Record<string, any> | null = null;
+  private swiftModifierOrder: Record<string, any> | null = null;
   private commonAttributes: any = null;
   private aliasMap: Map<string, string> = new Map();
   /// Lower-cased spelling -> its entry in type_synonyms.json, for the
@@ -420,9 +426,45 @@ export class SpecLoader {
     return guides;
   }
 
+  /**
+   * The Swift order is read from jsonui-cli's modifier_order.json, the order
+   * sjui codegen emits and SwiftJsonUI's Dynamic chain is tested against. It
+   * was a hand-written list here (derived.ts), and it had drifted: margins
+   * before offset, onClick after the margins — while jsonui-cli 1.9.20 puts
+   * the tap inside the offset and the margins (ticket mcp-get-modifier-order-
+   * swift-is-a-hand-written-list-that-drifted). Kotlin and React have no such
+   * file in jsonui-cli; they stay hand-written and say so (`source`).
+   */
   getModifierOrder(platform?: string): any {
-    if (platform) return (MODIFIER_ORDER as any)[platform] || null;
-    return MODIFIER_ORDER;
+    const swift = this.swiftModifierOrderEntry();
+    const all: Record<string, any> = { ...MODIFIER_ORDER, swift };
+    for (const key of ["kotlin", "react"]) {
+      all[key] = { source: "hand-written in jsonui-mcp-server (src/data/derived.ts); jsonui-cli has no order file for it", ...(MODIFIER_ORDER as any)[key] };
+    }
+    if (platform) return all[platform] || null;
+    return all;
+  }
+
+  private swiftModifierOrderEntry(): Record<string, any> {
+    const doc = this.swiftModifierOrder;
+    const file = this.dataSource?.swiftModifierOrder;
+    if (!doc || !file || !Array.isArray(doc.bag)) {
+      return {
+        source: "unavailable: sjui_tools/lib/swiftui/views/modifier_order.json did not resolve",
+        order: null,
+      };
+    }
+    const afterBag: string[] = Array.isArray(doc.after_bag) ? doc.after_bag : [];
+    return {
+      source: `jsonui-cli sjui_tools/lib/swiftui/views/modifier_order.json (${file.layer}: ${file.path})`,
+      // The bag in the order it is written, then what is written after it.
+      order: [...doc.bag, ...afterBag.map((k: string) => `${k} (after the bag)`)],
+      bag: doc.bag,
+      afterBag,
+      sharedSlots: doc.shared_slots ?? {},
+      about: doc._about ?? [],
+      criticalRules: (MODIFIER_ORDER as any).swift?.criticalRules ?? [],
+    };
   }
 
   /**
@@ -458,6 +500,7 @@ export class SpecLoader {
       this.dataSource.platformSemantics,
       this.dataSource.coverage,
       this.dataSource.typeSynonyms,
+      this.dataSource.swiftModifierOrder,
     ].filter((f): f is FileInfo => f != null);
 
     const changed: string[] = [];
@@ -673,6 +716,22 @@ export class SpecLoader {
 
     const typeSynonymsResolution = this.loadTypeSynonyms();
 
+    // sjui's SwiftUI modifier order (get_modifier_order's Swift answer).
+    // Optional for the same backward-compat reason.
+    let swiftModifierOrderResolution: FileInfo | null = null;
+    try {
+      const orderResolution = this.resolveFile(
+        "sjui_tools/lib/swiftui/views/modifier_order.json",
+        "data/modifier_order.json"
+      );
+      this.swiftModifierOrder = JSON.parse(
+        readFileSync(orderResolution.path, "utf-8")
+      ) as Record<string, any>;
+      swiftModifierOrderResolution = orderResolution;
+    } catch {
+      this.swiftModifierOrder = null;
+    }
+
     this.dataSource = {
       attributeDefinitions: attrResolution,
       componentMetadata: metaResolution,
@@ -682,6 +741,7 @@ export class SpecLoader {
       platformSemantics: platformSemanticsResolution,
       coverage: coverageResolution,
       typeSynonyms: typeSynonymsResolution,
+      swiftModifierOrder: swiftModifierOrderResolution,
       componentCount,
       commonAttributeCount: Object.keys(this.commonAttributesRaw).filter(
         (k) => !k.startsWith("_")

package/tests/__snapshots__/derived.test.ts.snap

@@ -62,13 +62,15 @@ exports[`derived constants (pinned) > MODIFIER_ORDER snapshot 1`] = `
     "criticalRules": [
       "Modifier.then() chains left-to-right; order matters",
       "margins before size (outside to inside)",
+      "testTag after margins and offset (from KotlinJsonUI 2.43.5 / jsonui-cli 1.9.16): a tag outside them reports a margin-inclusive box to accessibility",
       "cornerRadius must be applied as clip before background",
     ],
     "order": [
-      "testTag",
       "margins",
       "weight (caller applies)",
       "size (width/height, matchParent/wrapContent, min/max/aspectRatio)",
+      "offset",
+      "testTag (with testTagsAsResourceId): after margins and offset, so the tagged node's bounds are the drawn box",
       "alpha/opacity",
       "shadow/elevation",
       "background (cornerRadius -> clip -> border -> bgColor)",
@@ -99,31 +101,6 @@ exports[`derived constants (pinned) > MODIFIER_ORDER snapshot 1`] = `
       "Image: .resizable() must come first, then .aspectRatio",
       "Label: .leading alignment added to frame for textAlign to work",
     ],
-    "order": [
-      "centerAlignment",
-      "edgeAlignment",
-      "padding",
-      "frameConstraints (min/max)",
-      "frameSize (width/height)",
-      "insets/insetHorizontal",
-      "background",
-      "cornerRadius",
-      "border",
-      "margins",
-      "alpha/opacity",
-      "shadow",
-      "clipping",
-      "offset",
-      "visibility (hidden/opacity ternary)",
-      "safeAreaInsets",
-      "disabled",
-      "tag (for TabView)",
-      "tintColor",
-      "onClick/onTapGesture",
-      "lifecycle (onAppear/onDisappear)",
-      "confirmationDialog",
-      "accessibilityIdentifier",
-    ],
   },
 }
 `;

package/tests/derived.test.ts

@@ -78,7 +78,10 @@ describe("derived constants (pinned)", () => {
       "react",
       "swift",
     ]);
-    expect(MODIFIER_ORDER.swift.order.length).toBeGreaterThan(0);
+    // Swift's order is read from jsonui-cli's modifier_order.json
+    // (SpecLoader.getModifierOrder); a list here is the drift that ticket
+    // mcp-get-modifier-order-swift-is-a-hand-written-list-that-drifted removed.
+    expect((MODIFIER_ORDER.swift as Record<string, unknown>).order).toBeUndefined();
     expect(MODIFIER_ORDER.swift.criticalRules.length).toBeGreaterThan(0);
     expect(MODIFIER_ORDER.kotlin.order.length).toBeGreaterThan(0);
   });

package/tests/helpers.ts

@@ -108,8 +108,19 @@ export interface CliDatasetOptions {
   omitComponentMetadata?: boolean;
   /** Optional conformance/coverage.json fixture (implementation-gap ledger). */
   coverage?: Record<string, unknown>;
+  /** Optional sjui_tools/lib/swiftui/views/modifier_order.json fixture. */
+  modifierOrder?: Record<string, unknown>;
 }
 
+/** A modifier order whose slot names exist nowhere else: an answer that
+ *  carries them came from the file, not from a list kept in the server. */
+export const FIXTURE_MODIFIER_ORDER = {
+  _about: ["test fixture — not real data"],
+  bag: ["fixture_slot_alpha", "fixture_slot_beta", "fixture_slot_gamma"],
+  after_bag: ["fixture_after_one"],
+  shared_slots: { fixture_slot_alpha: ["fixture_slot_alpha", "fixture_extra"] },
+};
+
 /** Coverage-ledger fixture: one gap on Label.fontSize [web] + one on common.onClick [android]. */
 export const FIXTURE_COVERAGE = {
   schemaVersion: 1,
@@ -149,6 +160,9 @@ export function makeCliDataset(root: string, opts: CliDatasetOptions = {}): void
   if (opts.coverage) {
     writeJson(join(root, "conformance", "coverage.json"), opts.coverage);
   }
+  if (opts.modifierOrder) {
+    writeJson(join(root, "sjui_tools", "lib", "swiftui", "views", "modifier_order.json"), opts.modifierOrder);
+  }
 }
 
 /** Write a fixture bundled snapshot layout: <mcpRoot>/data/*.json */
@@ -166,6 +180,9 @@ export function makeBundledDataset(root: string, opts: CliDatasetOptions = {}):
       opts.componentMetadata ?? FIXTURE_COMPONENT_METADATA
     );
   }
+  if (opts.modifierOrder) {
+    writeJson(join(dataDir, "modifier_order.json"), opts.modifierOrder);
+  }
 }
 
 // ----- fixture JsonUI project ---------------------------------------------

package/tests/snapshot_completeness.test.ts

@@ -48,6 +48,7 @@ function reportedFiles(source: DataSourceInfo) {
     source.platformSemantics,
     source.coverage,
     source.typeSynonyms,
+    source.swiftModifierOrder,
   ].filter((f): f is NonNullable<typeof f> => f != null);
 }
 

package/tests/tools_spec.test.ts

@@ -23,6 +23,7 @@ import {
 import {
   cleanupTempDirs,
   createToolHarness,
+  FIXTURE_MODIFIER_ORDER,
   makeBundledDataset,
   makeTempDir,
   type ToolHarness,
@@ -42,9 +43,11 @@ function buildHarness(loader: SpecLoader): ToolHarness {
   return harness;
 }
 
-function makeFixtureLoader(opts: { staleDays?: number } = {}): SpecLoader {
+function makeFixtureLoader(opts: { staleDays?: number; modifierOrder?: Record<string, unknown> | null } = {}): SpecLoader {
   const mcpRoot = makeTempDir("mcp-root");
-  makeBundledDataset(mcpRoot);
+  makeBundledDataset(mcpRoot, {
+    modifierOrder: opts.modifierOrder === null ? undefined : (opts.modifierOrder ?? FIXTURE_MODIFIER_ORDER),
+  });
   if (opts.staleDays) {
     const when = new Date(Date.now() - opts.staleDays * 24 * 60 * 60 * 1000);
     for (const f of ["attribute_definitions.json", "component_metadata.json"]) {
@@ -156,16 +159,43 @@ describe("search_components", () => {
 });
 
 describe("get_modifier_order", () => {
-  it("returns the full table when platform is omitted", async () => {
-    const result = JSON.parse(await harness.call("get_modifier_order"));
-    expect(result).toEqual(JSON.parse(JSON.stringify(MODIFIER_ORDER)));
+  // The Swift order is read from jsonui-cli's modifier_order.json. The
+  // fixture's slot names exist nowhere else, so an answer carrying them came
+  // from the file — a list kept in the server cannot pass (ticket mcp-get-
+  // modifier-order-swift-is-a-hand-written-list-that-drifted).
+  it("serves the Swift order from modifier_order.json: the bag, then what follows it", async () => {
+    const result = JSON.parse(
+      await harness.call("get_modifier_order", { platform: "swift" })
+    );
+    expect(result.bag).toEqual(FIXTURE_MODIFIER_ORDER.bag);
+    expect(result.afterBag).toEqual(FIXTURE_MODIFIER_ORDER.after_bag);
+    expect(result.order).toEqual([
+      ...FIXTURE_MODIFIER_ORDER.bag,
+      "fixture_after_one (after the bag)",
+    ]);
+    expect(result.sharedSlots).toEqual(FIXTURE_MODIFIER_ORDER.shared_slots);
+    expect(result.source).toContain("sjui_tools/lib/swiftui/views/modifier_order.json");
+    expect(result.criticalRules).toEqual(MODIFIER_ORDER.swift.criticalRules);
   });
 
-  it("returns a single platform section", async () => {
+  it("says the Swift order is unavailable when the file does not resolve, and invents none", async () => {
+    harness = buildHarness(makeFixtureLoader({ modifierOrder: null }));
     const result = JSON.parse(
       await harness.call("get_modifier_order", { platform: "swift" })
     );
-    expect(result).toEqual(JSON.parse(JSON.stringify(MODIFIER_ORDER.swift)));
+    expect(result.order).toBeNull();
+    expect(result.source).toMatch(/^unavailable/);
+  });
+
+  it("returns the full table when platform is omitted, Kotlin and React marked hand-written", async () => {
+    const result = JSON.parse(await harness.call("get_modifier_order"));
+    expect(Object.keys(result).sort()).toEqual(["description", "kotlin", "react", "swift"]);
+    expect(result.swift.bag).toEqual(FIXTURE_MODIFIER_ORDER.bag);
+    for (const key of ["kotlin", "react"] as const) {
+      expect(result[key].source).toMatch(/^hand-written/);
+      const { source, ...rest } = result[key];
+      expect(rest).toEqual(JSON.parse(JSON.stringify(MODIFIER_ORDER[key])));
+    }
   });
 
   it("rejects unknown platforms at the schema layer", async () => {