softr-vibe-coding 2.9.0 → 2.9.1

package/CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this skill are documented here. Versions follow [Semantic
 
 Entries from 1.3.1 onward are generated automatically from git commit subjects between version bumps (see `.github/workflows/publish.yml`). Entries before 1.3.1 were backfilled by hand from the existing commit history.
 
+## [2.9.1] - 2026-09-30
+- Add right-edge placement and the schema-less workspace-tool correction (2026-09-30)
+- Document dropdown clipping by overflow ancestors (verified live 2026-09-30)
+
 ## [2.9.0] - 2026-09-29
 - Add runtime facts verified live 2026-09-18
 

package/README.md

@@ -232,7 +232,10 @@ softr-vibe-coding/
 │                                     # click-outside, A-Z inside the component,
 │                                     # multi-token filter, searchable BY DEFAULT
 │                                     # (bare = click-only; searchable={false} only
-│                                     # for a fixed enum being set — Sep 10 2026)
+│                                     # for a fixed enum being set — Sep 10 2026),
+│                                     # overflow-clipping ancestors: never clip a cell
+│                                     # holding a Combo, clip-aware drop-up + list
+│                                     # height, list-only scrolling (Sep 30 2026)
 │
 ├── tools/                            # Bundled CLI scripts (run, not read)
 │   ├── get-airtable-base             # Full Airtable base schema export (bash + jq)

package/SKILL.md

@@ -90,6 +90,7 @@ You generate complete, production-ready Softr Vibe Coding blocks as TypeScript R
    - Sequential multi-row saves use `await hook.mutateAsync(...)` per row, in order, with stop-on-failure + retry state — `mutateAsync` is fully supported on the current platform (verified 2026-08-25; the old ".mutate() only" Action-parser rule is gone — see [datasources/writing.md](datasources/writing.md)). Independent writes to **different tables** may run in parallel via `Promise.all`; drag/reassign UIs should be optimistic with an Undo toast — see [writing.md → Parallel writes across tables](datasources/writing.md#parallel-writes-across-tables-the-one-sanctioned-parallelism)
    - No hardcoded domains in links -- use relative paths (`/page?recordId=...`); same-page anchors written relative too (`/#section`)
    - **No `<select>` and no shadcn `<Select>`** — both break inside a block's shadow DOM (native hands the list to the OS; shadcn portals outside the shadow root and arrives unstyled). Use the `Combo` pattern in [references/searchable-dropdown.md](references/searchable-dropdown.md) — **searchable by default** for every framed filter or form field whatever the option count; `bare` inline editors are click-only; `searchable={false}` only on a short fixed enum the user is setting (a status, a location, a group-by)
+   - No clipping class (`overflow-hidden`, `overflow-*-auto`, `truncate`, `line-clamp-*`) on any element that contains a `Combo` — its panel is absolutely positioned in local DOM, so a clipping `<td>` cuts the menu to the row's height; bound an over-wide chip at the chip (`min-w-0 truncate`), and never `scrollIntoView` inside the panel. See [references/searchable-dropdown.md](references/searchable-dropdown.md#the-four-things-that-will-bite-you), item 4
    - Static block: no hardcoded user-visible copy — every string/image/link is an editable setting (see [references/editable-settings.md](references/editable-settings.md#granularity-doctrine-settings-first-static-blocks))
    - Array-setting rows keyed by **index**, never by a builder-editable field value
    - Media settings that may start empty (`src: ""`) gated with a conditional render or placeholder — never an unconditional `<img src={setting.src}>`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "softr-vibe-coding",
-  "version": "2.9.0",
+  "version": "2.9.1",
   "description": "Claude Code skill for generating production-ready Softr Vibe Coding blocks (JSX). Installs into ~/.claude/skills/ and auto-updates on each Claude Code session.",
   "bin": {
     "softr-vibe-coding": "./bin/cli.js"

package/references/anti-patterns.md

@@ -74,6 +74,8 @@ Run through this catalog before delivering any block. Every row is a violation o
 | Placing a `<NavigationAction navigation={{ action: "OPEN_CHAT" }}>` Ask-AI button on a block that has no data source connected | Connect the block to the data source the AI should read from in Studio's Source tab. Softr's AI pulls context from the **block that triggered the chat**, not from the page — a button-only helper block with no data source causes `chat/prepare` → HTTP 500 ("Failed to prepare AI assistant") even though the chat UI opens fine. The block doesn't need to read or write records itself; the connection is purely for AI context. Verified by direct experiment, May 2026 |
 | Emojis in UI | lucide-react icons only |
 | `document.elementFromPoint(x, y)` to hit-test during a drag or custom pointer interaction | It returns the block's shadow **host**, not the element under the cursor — same boundary that stops `getElementById` and URL-fragment lookup. Either call it on the shadow root (`ref.current.getRootNode().elementFromPoint(x, y)`) or, better, keep refs to the candidate elements and compare `getBoundingClientRect()` yourself: rects need no shadow-root plumbing and work identically when the block is later reused elsewhere |
+| `overflow-hidden`, `truncate`, `line-clamp-*` or `overflow-*-auto` on a container that holds a dropdown or popover — typically a `<td>` clipped so an over-wide status chip stops at its own column | **Symptom:** the menu opens cut to the height of its row or its scroller: one or two options showing, the rest unreachable by mouse. **Cause:** the `Combo` panel is `position: absolute` in the block's own DOM (a portal would leave the shadow root and lose its styles), and an absolutely positioned box is clipped by every ancestor whose `overflow` is not `visible`. `truncate` and `line-clamp-*` set `overflow: hidden`; `overflow-x-auto` turns `overflow-y` to `auto` as well. **Fix:** no clipping class between the Combo and the scroller it belongs to; bound the chip at the chip (`min-w-0 truncate` on the chip inside the flex trigger); measure the drop-up and the list height against the clipping ancestors, not the window. Hit in production 2026-09-30: three ROSIE item tables clipped the status cell as a 2px backstop, next to a comment claiming the menu was portaled — it had stopped being portaled when the tables moved from shadcn `<Select>` to `Combo`. See [searchable-dropdown.md](searchable-dropdown.md#the-four-things-that-will-bite-you), item 4 |
+| `el.scrollIntoView({ block: "nearest" })` to keep a dropdown's highlighted option in view (or a plain `focus()` on its search box) | **Symptom:** the table or the page jumps when a menu opens near an edge; inside a clipped cell the trigger itself scrolls out of view. **Cause:** `scrollIntoView` scrolls EVERY scrollable ancestor until the element shows, and `overflow: hidden` boxes are still scrollable from script; `focus()` scrolls ancestors the same way. **Fix:** scroll the list element only — compare the option's rect with the list's and adjust `list.scrollTop` — and focus with `{ preventScroll: true }`. Verified in Chromium 2026-09-30: `scrollIntoView` scrolled an `overflow: hidden` cell by 164px, the list-only scroll moved nothing outside the list. See [searchable-dropdown.md](searchable-dropdown.md#the-four-things-that-will-bite-you), item 4, rule 3 |
 | Positioning repeated page chrome (back button, title, primary action) per-block, without checking the pages that already have it | Chrome the user meets on more than one screen is a cross-page contract. Copy the exact offset from the blocks that already ship it, and change every page in one edit. Let the wrapper's padding be the only thing positioning it — `mb-4` and NO top margin on a back button — so one number per page governs it. Verified 2026-09-09: an extra `mt-6` sat one detail page's back button 24px lower than another's, and **each block looked correct in isolation**. See SKILL.md's Block Placement section |
 | A loading skeleton carrying a different border / offset from the component it stands in for | The skeleton must track the component's REST state (border colour, padding, chrome offsets), never its hover state. If they disagree the layout visibly re-draws the instant data lands — the exact thing a skeleton exists to prevent. Verified 2026-09-09 twice in one session: a card grid re-outlined itself on load, and a back button jumped 24px. See [ui-ux-guidelines.md](../ui-ux-guidelines.md) §12 |
 | `focus-visible:` on a card or row that only *contains* buttons | The container is a plain `<div>` and never takes focus, so it is dead CSS. Use `focus-within:` on the container (pairs with its `hover:` treatment) and keep `focus-visible:ring-2` on the button/link itself |

package/references/common-patterns.md

@@ -515,4 +515,4 @@ function onKeyDown(e) {
 
 Make the rows themselves focusable too (`tabIndex={0}`, an `onKeyDown` that opens on Enter only when `event.target === event.currentTarget`, so an Enter on the anchor inside the row is not handled twice), and let `onMouseEnter` *and* `onFocus` both move the highlight onto the row — the highlight is the single answer to "which record does Enter open", whichever device last touched it. That is the shape `projects-table.jsx` shipped on 2026-09-10.
 
-Paint the highlighted row with the same colour the mouse hover gets (`data-active="true"` + `bg-[#FFF7EF]`) and scroll it into view when it moves (`querySelector('[data-active="true"]').scrollIntoView({ block: "nearest" })` in a `useEffect` on `activeIdx`) — the Combo in [searchable-dropdown.md](searchable-dropdown.md#one-flat-row-list-for-the-keyboard) does the same. Reset `active` to 0 whenever the query changes: the old index points at a row that may no longer be in the list. `autoFocus` is right only when the block *is* the page's reason to exist — an index page whose first act is always a search; on a page with content above the table, a focus steal scrolls the page to the box.
+Paint the highlighted row with the same colour the mouse hover gets (`data-active="true"` + `bg-[#FFF7EF]`) and scroll it into view when it moves (`querySelector('[data-active="true"]').scrollIntoView({ block: "nearest" })` in a `useEffect` on `activeIdx`). That is right here, because these rows are page content and the table's scroller and the page *should* move to them. Inside a dropdown it is wrong, and the Combo scrolls only its own list — see [searchable-dropdown.md](searchable-dropdown.md#the-four-things-that-will-bite-you), item 4, rule 3. Reset `active` to 0 whenever the query changes: the old index points at a row that may no longer be in the list. `autoFocus` is right only when the block *is* the page's reason to exist — an index page whose first act is always a search; on a page with content above the table, a focus steal scrolls the page to the box.

package/references/searchable-dropdown.md

@@ -8,13 +8,13 @@ the obvious choices:
 |---|---|
 | Native `<select>` | Hands the list to the OS. No keyword filter, none of your styling, and on macOS it paints a grey slab over the page. Fine for 5 options, unusable at 90. |
 | shadcn `<Select>` / `<Command>` | **Portals to `document.body`, which is outside the block's shadow root**, so the styles arrive stripped. It also cannot be searched. |
-| `Combo` (below) | Local DOM, brand-styled, keyword filter, A→Z, keyboard, create-new, drop-up. |
+| `Combo` (below) | Local DOM, brand-styled, keyword filter, A→Z, keyboard, create-new, clip-aware drop-up. |
 
 Copy the component into the block. A Vibe block is one self-contained file — there is no
 shared module to import, so each block carries its own copy. Keep one canonical copy in the
 project (e.g. `Assets/Softr App/Shared/combo.jsx`) and port changes from there.
 
-## The three things that will bite you
+## The four things that will bite you
 
 **1. Click-outside must use `composedPath()`, not `contains()`.**
 By the time a click reaches `document`, the shadow DOM has *retargeted* its `target` to the
@@ -44,6 +44,182 @@ single most common Vibe Coding bug and it looks like a platform fault.
 **3. `onMouseDown` on a row must `preventDefault()`.**
 Otherwise focus leaves the search input before the click resolves.
 
+**4. The panel is clipped by any ancestor whose `overflow` is not `visible`.**
+The panel is `position: absolute` inside the trigger's `relative` wrapper, in the block's own
+DOM, because it cannot portal out of the shadow root (see *Why not portal* below). Its
+containing block is that wrapper, so *every* ancestor whose `overflow` is `hidden`, `auto`,
+`scroll` or `clip` clips it, however far up. In Tailwind that is `overflow-hidden`,
+`overflow-auto`, `overflow-y-auto`, `overflow-x-auto` (an `overflow-x` of `hidden`, `auto` or
+`scroll` turns `overflow-y: visible` into `auto`, so it clips vertically too), `truncate` (it
+sets `overflow: hidden`) and `line-clamp-*` (so does that). A clipped `<td>` is the height of
+its row, and the menu opens inside it. Three rules follow.
+
+**Rule 1 — never put a clipping class on an element that contains a `Combo`:** a `<td>`, a
+card, a flex cell, anything between the Combo and the scroller it belongs to. If a chip or
+label inside the trigger can overflow, bound it at the chip: `truncate` (or `overflow-hidden`)
+plus `min-w-0` on the chip itself. The trigger is a flex row, and `min-w-0` is what lets a flex
+item shrink below its text — strictly redundant while the chip clips itself, load-bearing the
+moment the ellipsis moves to a span inside it. Clipping at the chip clips the chip. Clipping at
+the cell clips the menu.
+
+```jsx
+<td className="px-4">{/* no overflow class on the cell */}
+  <Combo
+    bare
+    triggerContent={<span className="min-w-0 truncate px-2" style={chipStyle}>{label}</span>}
+    …
+  />
+</td>
+```
+
+**Rule 2 — decide the drop-up and the list's height against the clipping ancestors, not the
+window.** `window.innerHeight - rect.bottom` cannot see scroll containers: a table with its own
+`max-height` + `overflow: auto` scroller, a dialog body with `overflow-y-auto`, a horizontally
+scrollable table wrapper. A row near the bottom of one of those opens its menu downward into
+the scroller's hidden area while the window still has plenty of room. Measure inside the strip
+the panel can actually paint into:
+
+```jsx
+var COMBO_LIST_MAX = 256; // the list's normal ceiling (max-h-64)
+var COMBO_LIST_MIN = 120; // the floor: below this, accept a clip rather than a useless list
+
+/* The strip of screen the panel can paint into: the viewport, cut down by every ancestor
+   that clips vertically. overflowY is enough on its own: an overflow-x of hidden, auto or
+   scroll already turns a visible overflow-y into auto in the computed style. */
+function comboClipBox(node) {
+  var top = 0;
+  var bottom = window.innerHeight;
+  var el = node;
+  while (el && el !== document.body && el !== document.documentElement) {
+    // clientHeight is 0 for the boxes overflow does not apply to (inline, display: contents)
+    if (el.clientHeight > 0 && window.getComputedStyle(el).overflowY !== "visible") {
+      var r = el.getBoundingClientRect();
+      var t = r.top + el.clientTop; // the clip edge is the padding box: inside the border
+      var b = t + el.clientHeight; //  and above a horizontal scrollbar
+      if (t > top) top = t;
+      if (b < bottom) bottom = b;
+    }
+    // Where the parent chain ends at the shadow root, carry on from its host.
+    el = el.parentElement || el.getRootNode().host || null;
+  }
+  return { top: top, bottom: bottom };
+}
+
+/* chrome = the panel's height outside the list: the search box and the borders. */
+function comboPlace(wrapper, chrome) {
+  var clip = comboClipBox(wrapper);
+  var r = wrapper.getBoundingClientRect();
+  var below = clip.bottom - r.bottom - 10; // the 2px gap to the trigger + 8px to spare
+  var above = r.top - clip.top - 10;
+  var up = below < chrome + COMBO_LIST_MAX && above > below;
+  var room = (up ? above : below) - chrome;
+  return { up: up, listMax: Math.max(COMBO_LIST_MIN, Math.min(COMBO_LIST_MAX, room)) };
+}
+```
+
+Call it when the panel opens, and give the list its height as an inline style in place of
+`max-h-64`:
+
+```jsx
+var [listMax, setListMax] = useState(COMBO_LIST_MAX);
+
+// in toggle(), before setOpen(true):
+if (rootRef.current) {
+  var place = comboPlace(rootRef.current, searchable ? 51 : 2);
+  setDropUp(place.up);
+  setListMax(place.listMax);
+}
+
+// the list:
+<div ref={listRef} role="listbox" className="overflow-y-auto py-1" style={{ maxHeight: listMax }}>
+  {/* rows */}
+</div>
+```
+
+Downward when the whole panel fits below, otherwise toward the larger side, with the list
+capped to the room it gets. `chrome` is the panel's height outside the list — about 51px with
+the search box (`p-2` around an `h-8` input, a 1px rule, the panel's two borders) and 2px
+without; measure yours if the panel differs. The fit test assumes a full-height list, so a
+three-option menu may flip up when it would have fit below, which costs nothing. The walk
+starts at the wrapper, whose own overflow would clip the panel too; it leaves the shadow root
+through its host, so a clipping container outside the block still counts; and it stops below
+`<body>`, because `body` and `html` hand their overflow to the viewport — their computed
+`overflow` can say `hidden` while they clip nothing. The four cases it has to get right: a row
+mid-way down a tall table scroller opens down; the last visible row of a scroller whose bottom
+edge is mid-window opens up, inside the scroller (the window-only rule opened it down, into
+the hidden part); a picker at the bottom of a dialog body opens up, inside the dialog; a filter
+row at the window's bottom edge opens up, as before. All four, plus a scroller outside the
+shadow root, checked in Chromium on 2026-09-30 on a test page — not yet in a deployed block.
+
+Rule 2 does not rescue a clipped cell. The cell is the height of its row, so neither side has
+room, the list falls to its 120px floor and is clipped anyway. Rule 1 is not optional.
+
+**The same box decides which edge the panel hangs from.** A panel hung from the trigger's left
+edge with `width: max-content` runs past the right edge of a table's scroll box when the trigger
+sits in the last column. In ROSIE the Location menu ran about 15px over, and the old
+`scrollIntoView` then slid the whole table sideways to reveal it. Measure the box's left and right
+edges as well (padding box, tested on `overflowX`), and when the room to the right of the trigger
+is short (under ~300px) and there is more to the left, anchor the panel with `right: 0` instead of
+`left: 0` and cap its `maxWidth` to the room on that side. Rows are a fixed height in this
+component, so the fit test can also count the real rows instead of assuming a full list, and a
+four-option menu near an edge stops flipping for room it will never use. ROSIE's
+`Shared/combo.jsx` (2026-09-30) is the worked version: one `comboClipBox` returning all four
+edges, one `comboPlacement` returning `{ up, right, listMax, maxW }`, deployed in twelve blocks.
+
+**Rule 3 — keep the active row visible by scrolling the list, never with `scrollIntoView`.**
+`scrollIntoView` scrolls *every* scrollable ancestor until the element shows, and an
+`overflow: hidden` box is still scrollable from script. In a clipped cell it scrolls the
+cell's content until the option shows, pushing the trigger out of view; near the edge of a
+table it scrolls whatever the menu hangs out of — the table's own scroller, the page — so the
+table jumps as the menu opens. Scroll the list element and nothing else:
+
+```jsx
+useEffect(
+  function () {
+    var list = listRef.current;
+    if (!open || !list) return;
+    var el = list.querySelector('[data-active="true"]');
+    if (!el) return;
+    var lr = list.getBoundingClientRect();
+    var er = el.getBoundingClientRect();
+    var viewTop = lr.top + list.clientTop; // inside the list's top border
+    var viewBottom = viewTop + list.clientHeight; // clientHeight excludes border and scrollbar
+    if (er.top < viewTop) list.scrollTop -= viewTop - er.top;
+    else if (er.bottom > viewBottom) list.scrollTop += er.bottom - viewBottom;
+  },
+  [open, activeIdx, query]
+);
+```
+
+Rects rather than `offsetTop`: a row's `offsetParent` is the nearest positioned ancestor,
+which is the panel, not the list, so `offsetTop` comes out too large by the search box's
+height unless the list is made `position: relative`. Rects need no such arrangement. The
+effect runs after the commit, outside the event cycle Hard Constraint 17's `setTimeout` is
+there to escape — the `scrollIntoView` it replaces ran from the same kind of effect and took
+effect. `focus()` scrolls ancestors the same way, so focus the search box with
+`inputRef.current.focus({ preventScroll: true })`.
+
+**Why not portal the panel, or make it `position: fixed`?** A portal to `document.body`
+leaves the shadow root, and the styles stay behind — the shadcn row at the top of this page.
+`position: fixed` inside the shadow root escapes the clipping only while no ancestor has a
+`transform`, `filter`, `perspective`, `contain` or `will-change`: any of those becomes the
+containing block for fixed descendants, and scroll-reveal animations on Softr pages commonly
+leave a transform behind (the same trap as the block-owned header in
+[static-blocks.md](static-blocks.md#block-owned-landing-page-header)). A fixed panel also stops
+moving with its trigger, so it has to be re-placed on every scroll. The clip-aware absolute
+panel has neither problem, which is why it is the design here.
+
+**The incident — ROSIE, 2026-09-30.** Three item tables put `overflow-hidden` on the `<td>`
+holding the status chip, as a backstop so the chip, 1–2px too wide at the column's narrowest
+drag width, would clip at its own column instead of painting over the next one. The comment
+beside it said the status menu was portaled to the body, so the clip could not reach it. That
+was true of the shadcn `<Select>` the tables used before and stopped being true when they moved
+to `Combo`; nobody re-checked. The menu opened inside the 48px cell: one and a half options
+showing, the chip scrolled out of view by `scrollIntoView`, the other six unreachable by
+mouse. The Location dropdown in the same rows kept working, because its cell had no overflow
+class. A 2px backstop cost the whole feature. A comment that says how a component renders is
+a claim to verify in the component, not in the comment.
+
 ## Sort A→Z *inside* the component
 
 Sorting at the call site gets forgotten. Do it in the component, with an opt-out:
@@ -125,16 +301,7 @@ than reaching past the wrapper.
 Build `rows` as a single array — the optional *clear* row, then the filtered options, then
 the optional *create* row — so arrow-key navigation has one index to walk. Clamp the active
 index (`Math.min(active, rows.length - 1)`): filtering shrinks the list under the highlight.
-
-## Drop up near the fold
-
-```jsx
-var r = rootRef.current.getBoundingClientRect();
-var below = window.innerHeight - r.bottom;
-setDropUp(below < 300 && r.top > below);
-```
-
-A filter row near the bottom of the viewport otherwise opens into nothing.
+Keep the highlighted row in view by scrolling the list only (rule 3 of item 4 above).
 
 ## Variants worth having
 
@@ -145,6 +312,9 @@ A filter row near the bottom of the viewport otherwise opens into nothing.
   ⚠ If any column width in your table is derived from the trigger's chrome, keep the
   chevron the SAME size in both variants. Shrinking it in `bare` silently changes those
   widths in a different file.
+  ⚠ A `bare` Combo sits in a table cell, which is exactly where `overflow-hidden` and
+  `truncate` get added. Keep them off the cell and bound the chip instead — rule 1 of item 4
+  in [The four things that will bite you](#the-four-things-that-will-bite-you).
 - **`triggerStyle`** — merged over the defaults, for a trigger that is part of the design
   (a chip painted in its own status colour) rather than a plain field.
 - **`onCreate(text)`** — offers `Add "<typed>"` when nothing matches. If creating the record
@@ -172,7 +342,12 @@ Everything else — the trigger, the card, the rows — stays flat.
 - [ ] Sorted A→Z inside the component, with `autoSort={false}` only where order is meaning
 - [ ] Multi-token filter
 - [ ] Searchable by default; `bare` is click-only; `searchable={false}` only on a short fixed enum the user is setting
-- [ ] Keyboard: ↑ ↓ Enter Esc Tab, active row scrolled into view
+- [ ] No overflow-clipping class (`overflow-hidden`, `overflow-*-auto`, `truncate`,
+      `line-clamp-*`) between the Combo and the scroller it belongs to; an over-wide chip
+      bounded at the chip (`min-w-0 truncate`)
+- [ ] Drop-up and list `maxHeight` measured against the clipping ancestors, not the window
+- [ ] Keyboard: ↑ ↓ Enter Esc Tab; the active row kept visible by scrolling the list only
+      (never `scrollIntoView`), and the search box focused with `preventScroll`
 - [ ] `aria-haspopup="listbox"`, `aria-expanded`, `role="listbox"` / `role="option"`,
       `aria-selected`, and an `aria-label` on the trigger
 - [ ] Loading and empty states (`"Nothing matches that."`)

package/references/softr-mcp.md

@@ -197,8 +197,15 @@ shapes, different payload type. The stringification happened on the client side,
 calls made while the tool definitions had not been loaded into the model's context (deferred
 schemas), so there was no type to serialise against. **Load the tool's schema before calling it,
 and pass arrays as arrays.** (Empty schemas are real on Softr's *per-application* MCP servers —
-every tool there is advertised as `{"type":"object"}` with a name-only description — but the
-workspace server is not affected.)
+every tool there is advertised as `{"type":"object"}` with a name-only description.)
+
+**Correction, 2026-09-30: the workspace server's tools can arrive schema-less too.** In one
+session every workspace tool loaded through ToolSearch showed only `{"type":"object"}` with a
+name-only description, and a `search_replace` call written with a real array was still sent as a
+string and rejected with the error above. Nothing was written, so the failure is safe, but no
+amount of care on the caller's side gets an array through a schema-less tool. Look at the
+loaded schema before relying on an array argument: if it has no `properties`, go straight to the
+fallback in the table — a full replace, one file per subagent for a large block, byte-verified.
 
 **Why the second row is a security problem, not an inconvenience.** Every code push resets the
 block's auto-registered Actions to Softr's defaults, and the default for a `genericActions`