jui-tools-mcp-server 2.15.4 → 2.15.10

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",
@@ -3685,7 +3685,7 @@
         "horizontal",
         "vertical"
       ],
-      "description": "Scroll orientation"
+      "description": "Scroll axis: \"horizontal\" scrolls sideways; \"vertical\" — and a ScrollView that writes neither this nor horizontalScroll: true — scrolls vertically. The axis is never taken from the children: a horizontal child View is laid out inside a vertical scroll. Written together with horizontalScroll, the two must agree — orientation \"horizontal\" with horizontalScroll false, or \"vertical\" with horizontalScroll true, is refused by jui build (ERROR [scrollview]), under any responsive key too."
     },
     "scrollMode": {
       "type": "string",
@@ -3840,7 +3840,7 @@
     },
     "horizontalScroll": {
       "type": "boolean",
-      "description": "Enable horizontal scroll. Declared from the implementation, which already read it: sjui scrollview_converter.rb:39 (plan 51-E)."
+      "description": "Scroll sideways: true is the same as orientation \"horizontal\"; false or absent leaves the axis to orientation, vertical when that is not written either. Never taken from the children. Written together with orientation, the two must agree (jui build ERROR [scrollview]). Declared from the implementation, which already read it: sjui scrollview_converter.rb (plan 51-E)."
     },
     "defaultScrollAnchor": {
       "type": "string",
@@ -4043,17 +4043,20 @@
     },
     "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. A Collection taken out by visibility gone and brought back (kjui-collection-scrollto-ignored-after-visibility-gone, 2026-10-14): the screen remembers the value each Collection, by its id, was last drawn with, and a value it comes back with that differs from that one is a request — a scrollTo written in the same update as the visibility that brings it back runs, as it would on a Collection that never left; the value a Collection is first drawn with on a screen still scrolls nowhere, so a Collection that is gone from the moment the screen opens and first appears with a value does not scroll to it; a Collection with no id is not remembered, and a value it comes back with is its first value again. The anchor of such a request is the anchor of that update (scrollAnchor). Until jsonui-cli 1.9.30 / SwiftJsonUI 10.29.16 / KotlinJsonUI 2.43.13 the iOS and Compose paths read the value a Collection came back with as its first value, and the request never ran; the web kept it (its effect lives on the screen's component)."
     },
     "scrollAnchor": {
-      "type": "string",
+      "type": [
+        "string",
+        "binding"
+      ],
       "enum": [
         "top",
         "center",
         "bottom"
       ],
       "default": "bottom",
-      "description": "Anchor point for the scrollTo target: where the target lands along the scroll axis. top - its leading edge at the viewport's leading edge; center - its middle at the viewport's middle; bottom (the default) - its trailing edge at the viewport's trailing edge. Drawn so by SwiftUI's ScrollViewReader (vertical), the web (scrollCollectionToCell) and, since jsonui-cli 1.9.0, both Compose paths (4f ruling 2026-09-27, round 11): kjui codegen offset the target by the viewport (bottom) or half of it (center), which put the target's top edge at the viewport's bottom edge or middle, and KotlinJsonUI Dynamic landed center and bottom at the top. A reverseLayout list (Compose) lands top and bottom on the edges they name on screen. Measured 2026-08-05: ios (sjui collection_converter.rb:1138), web (rjui build_command.rb:768) and the Compose GRID path all fall back to bottom, so bottom is the declared default. On a horizontal Collection, top / center / bottom mean the start / centre / end along the scroll axis, in reading direction, on every platform (4f ruling 2026-09-27)."
+      "description": "Anchor point for the scrollTo target: where the target lands along the scroll axis. top - its leading edge at the viewport's leading edge; center - its middle at the viewport's middle; bottom (the default) - its trailing edge at the viewport's trailing edge. Drawn so by SwiftUI's ScrollViewReader (vertical), the web (scrollCollectionToCell) and, since jsonui-cli 1.9.0, both Compose paths (4f ruling 2026-09-27, round 11): kjui codegen offset the target by the viewport (bottom) or half of it (center), which put the target's top edge at the viewport's bottom edge or middle, and KotlinJsonUI Dynamic landed center and bottom at the top. A reverseLayout list (Compose) lands top and bottom on the edges they name on screen. Measured 2026-08-05: ios (sjui collection_converter.rb:1138), web (rjui build_command.rb:768) and the Compose GRID path all fall back to bottom, so bottom is the declared default. On a horizontal Collection, top / center / bottom mean the start / centre / end along the scroll axis, in reading direction, on every platform (4f ruling 2026-09-27). A binding (jsonui-cli 1.9.29, jui-collection-scrollto-per-request-anchor) chooses the anchor per request: it is read when the scrollTo value CHANGES, so the anchor a request lands by is the bound value at that moment — change it in the same update as the scrollTo value, or before; a change of the anchor alone scrolls nothing, and a landing in flight keeps the anchor it started with. A bound value that is not top, center or bottom lands as bottom, with a DEBUG warning, on every path. Under reverseLayout a bound anchor trades top and bottom as the written one does. Until 1.9.29 a binding here was read as bottom (rjui, kjui) or did not compile (sjui). The target is the CELL as the Collection lays it out: with cellHeight, the cellHeight-high cell, not its content (rjui-scrollanchor-lands-on-cell-content-not-cell, 2026-10-14: the web landed the content, so a cell taller than its content landed short of where iOS and Compose land it)."
     },
     "defaultScrollAnchor": {
       "type": "string",
@@ -4062,11 +4065,14 @@
         "center",
         "bottom"
       ],
-      "description": "Initial scroll position anchor (iOS 17+). Sets where the scroll view starts. On Compose (kjui codegen and KotlinJsonUI Dynamic) it is applied once, when the list first has cells, by scrolling to the middle (center) or last (bottom) CELL counted as scrollTo counts them - across the drawn sections, headers, footers and grid fillers not counted (4f ruling 2026-09-27, round 11); until jsonui-cli 1.9.0 it counted the first data section only and scrolled to that lazy item index. Under reverseLayout a list rests at its visual bottom, so top and bottom trade places, as they do for scrollAnchor (4f ruling 2026-09-27, round 12 - where iOS lands, which draws the same order from content anchored at its bottom): bottom is where the list rests and moves nothing; top goes to the cell drawn at the visual top, the last one the content emits. Until jsonui-cli 1.9.0 bottom went to the last cell, which a reversed list draws at its visual top. A container that is not a lazy list and draws no reverseLayout (the wrapContent Column, the horizontal EAGER one) takes the middle or last cell to its top edge (round 12); the vertical EAGER one draws reverseLayout and follows the lazy list (round 13). It sets the initial position only: how a list keeps its position when its data changes with no scrollTo is each platform's own - iOS keeps the anchored edge while the list rests at it and, once a scrollTo has moved it, stays where it scrolled; Compose keeps the first visible item - so to follow new content, send scrollTo (4f ruling 2026-09-27, round 13; the iOS half measured round 14: a list resting at its bottom showed an appended cell there, and one a scrollTo had left above a cell kept it below the edge when more arrived). On Compose a list that is not reversed, with defaultScrollAnchor bottom and content shorter than its viewport, sits at its bottom, as iOS draws it (4f ruling 2026-09-27, round 14; it sat at the top). On a horizontal Collection, top / center / bottom mean the start / centre / end along the scroll axis, in reading direction, on every platform (4f ruling 2026-09-27); a horizontal list whose content is shorter than its row sits at the row's centre (center) or end (bottom) on Compose too, on the lazy and eager routes, as iOS draws it - measured on sjui codegen and SwiftJsonUI Dynamic - and a `lazy: none` row, which does not scroll, at its start, as sjui codegen draws it (4f ruling 2026-09-27, round 15; every Compose row sat at its start until jsonui-cli 1.9.0). A vertical list shorter than its viewport sits in its middle for center, on Compose too - the lazy and eager routes, reversed or not, as iOS draws them (measured 2026-09-27 on sjui codegen and SwiftJsonUI Dynamic) - and a `lazy: none` Column, which does not scroll, at its top (4f ruling 2026-09-27, round 16; it sat at the top, the bottom when reversed, until jsonui-cli 1.9.0)."
+      "description": "Initial scroll position anchor (iOS 17+). Sets where the scroll view starts. On Compose (kjui codegen and KotlinJsonUI Dynamic) it is applied once, when the list first has cells, by scrolling to the middle (center) or last (bottom) CELL counted as scrollTo counts them - across the drawn sections, headers, footers and grid fillers not counted (4f ruling 2026-09-27, round 11); center lands that cell's middle at the viewport's middle, as iOS and the web draw a list longer than its viewport (kjui-defaultscrollanchor-center-differs-when-content-overflows, 2026-10-14: Compose put it at the top edge, and a list whose middle cell could not get there stopped at its end, drawing bottom's picture); until jsonui-cli 1.9.0 it counted the first data section only and scrolled to that lazy item index. Under reverseLayout a list rests at its visual bottom, so top and bottom trade places, as they do for scrollAnchor (4f ruling 2026-09-27, round 12 - where iOS lands, which draws the same order from content anchored at its bottom): bottom is where the list rests and moves nothing; top goes to the cell drawn at the visual top, the last one the content emits. Until jsonui-cli 1.9.0 bottom went to the last cell, which a reversed list draws at its visual top. A container that is not a lazy list and draws no reverseLayout (the wrapContent Column, the horizontal EAGER one) takes the middle or last cell to its top edge (round 12); the vertical EAGER one draws reverseLayout and follows the lazy list (round 13). It sets the initial position only: how a list keeps its position when its data changes with no scrollTo is each platform's own - iOS keeps the anchored edge while the list rests at it and, once a scrollTo has moved it, stays where it scrolled; Compose keeps the first visible item - so to follow new content, send scrollTo (4f ruling 2026-09-27, round 13; the iOS half measured round 14: a list resting at its bottom showed an appended cell there, and one a scrollTo had left above a cell kept it below the edge when more arrived). On Compose a list that is not reversed, with defaultScrollAnchor bottom and content shorter than its viewport, sits at its bottom, as iOS draws it (4f ruling 2026-09-27, round 14; it sat at the top). On a horizontal Collection, top / center / bottom mean the start / centre / end along the scroll axis, in reading direction, on every platform (4f ruling 2026-09-27); a horizontal list whose content is shorter than its row sits at the row's centre (center) or end (bottom) on Compose too, on the lazy and eager routes, as iOS draws it - measured on sjui codegen and SwiftJsonUI Dynamic - and a `lazy: none` row, which does not scroll, at its start, as sjui codegen draws it (4f ruling 2026-09-27, round 15; every Compose row sat at its start until jsonui-cli 1.9.0). A vertical list shorter than its viewport sits in its middle for center, on Compose too - the lazy and eager routes, reversed or not, as iOS draws them (measured 2026-09-27 on sjui codegen and SwiftJsonUI Dynamic) - and a `lazy: none` Column, which does not scroll, at its top (4f ruling 2026-09-27, round 16; it sat at the top, the bottom when reversed, until jsonui-cli 1.9.0)."
     },
     "scrollAnimated": {
-      "type": "boolean",
-      "description": "Whether scrollTo uses animation (default: true)"
+      "type": [
+        "boolean",
+        "binding"
+      ],
+      "description": "Whether scrollTo uses animation (default: true). A binding decides at run time: the scroll animates only when the bound value is true (an unset bound value jumps) — read so by sjui, kjui and rjui since jsonui-cli 1.9.0 and declared in 1.9.29 (jui-collection-scrollto-per-request-anchor)."
     },
     "cellIdProperty": {
       "type": "string",

package/data/attribute_semantics.json

@@ -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",

package/data/component_metadata.json

@@ -239,7 +239,7 @@
       }
     },
     "rules": [
-      "orientation determines scroll direction",
+      "the axis is horizontal when horizontalScroll is true or orientation is horizontal, and vertical otherwise — never taken from the children; an orientation and a horizontalScroll that disagree are refused by jui build (ERROR [scrollview])",
       "showsIndicator controls scrollbar visibility"
     ]
   },

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)",

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.4",
+  "version": "2.15.10",
   "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.16";
+const JSONUI_CLI_TAG = "v1.9.30";
 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)",

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

@@ -101,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 () => {