feat(spec): reject a body on a non-script action — it would never run (#3530)

`Action.body` is documented as "only meaningful when `type === 'script'`", but
nothing enforced it. A `type: 'modal'` action authored with `params` and a
`body` — expecting the modal to collect the input and the body to write the
record on submit — passed validation, passed shape tests, and shipped a button
that opened a modal and silently wrote nothing. Non-script types all dispatch on
`target` (the page to open, the URL, the flow, the endpoint); there is no point
at which a renderer would invoke the body.

This is the same invisible-failure shape as the existing rule that rejects a
`script` action with neither `body` nor `target` (#2169), so it is enforced the
same way: a parse-time error that names the fix — `type: 'script'` collects the
same `params` and does run the body, and a modal that only opens a page should
drop the `body` and keep `target` naming the page.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KYuc9N6YRbvoDMbCvJiX9f

Author: zhuangjianguo

.changeset/reject-body-on-non-script-action.md

@@ -0,0 +1,19 @@
+---
+"@objectstack/spec": patch
+---
+
+feat(spec): reject a `body` on a non-script action — it would never run (#3530)
+
+`Action.body` is documented as "only meaningful when `type === 'script'`", but
+nothing enforced it. A `type: 'modal'` action authored with `params` and a
+`body` — expecting the modal to collect the input and the body to write the
+record on submit — passed validation, passed shape tests, and shipped a button
+that opened a modal and silently wrote nothing. Non-script types all dispatch on
+`target` (the page to open, the URL, the flow, the endpoint); there is no point
+at which a renderer would invoke the body.
+
+This is the same invisible-failure shape as the existing rule that rejects a
+`script` action with neither `body` nor `target` (#2169), so it is enforced the
+same way: a parse-time error that names the fix — `type: 'script'` collects the
+same `params` and does run the body, and a modal that only opens a page should
+drop the `body` and keep `target` naming the page.

packages/spec/src/ui/action.test.ts

@@ -1057,6 +1057,33 @@ describe('ActionSchema - execute → target migration', () => {
       body: { language: 'expression', source: 'true' },
     })).not.toThrow();
   });
+
+  it('should reject a body on a non-script action (it would never run)', () => {
+    // #3530: `type: 'modal'` + `params` + `body` was authored expecting the
+    // body to run when the modal is submitted. A modal action dispatches on
+    // `target` (the page to open), so the body is silently skipped — the modal
+    // opens and nothing is ever written. Fail at author time and point at the
+    // fix rather than shipping a button that does nothing.
+    for (const type of ['modal', 'url', 'flow', 'api', 'form'] as const) {
+      expect(() => ActionSchema.parse({
+        name: `${type}_with_body`,
+        label: 'Has a body',
+        type,
+        target: 'some_target',
+        body: { language: 'js', source: 'return 1;', capabilities: ['api.write'] },
+      }), `type: '${type}'`).toThrow(/script/);
+    }
+  });
+
+  it('should allow a non-script action without a body', () => {
+    expect(() => ActionSchema.parse({
+      name: 'log_call',
+      label: 'Log a Call',
+      type: 'modal',
+      target: 'log_call',
+      params: [{ name: 'subject', label: 'Call Subject', type: 'text', required: true }],
+    })).not.toThrow();
+  });
 });
 
 describe('ActionSchema - target required for non-script types', () => {

packages/spec/src/ui/action.zod.ts

@@ -603,6 +603,27 @@ export const ActionSchema = lazySchema(() => z.object({
   message:
     "A 'script' action requires either an inline `body` (sandboxed L1/L2 handler) or a `target` (a registered bundle function name).",
   path: ['body'],
+}).refine((data) => {
+  // The mirror image of the rule above: a `body` on a NON-script action never
+  // runs. `type: 'modal' | 'url' | 'flow' | 'api' | 'form'` all dispatch on
+  // `target` (the page to open, the URL, the flow, the endpoint), so the
+  // renderer has no point at which it would invoke a body — the action opens
+  // its target and the body is silently skipped.
+  //
+  // This is the same invisible-failure shape as #2169: it passes build, passes
+  // shape tests, and only shows up as "the modal opened but nothing was
+  // written" (#3530, where `type: 'modal'` + `params` + `body` was authored
+  // expecting the body to run on submit). Reject it at author time and name the
+  // fix — `type: 'script'` collects the same `params` and DOES run the body.
+  if (data.type !== 'script' && data.body) {
+    return false;
+  }
+  return true;
+}, {
+  message:
+    "`body` only runs for `type: 'script'` — a non-script action dispatches on `target` and silently ignores its body. " +
+    "To collect `params` and then run the body, use `type: 'script'`; to open a page/modal, drop the `body` and keep `type: 'modal'` with `target` naming the page.",
+  path: ['body'],
 }).refine((data) => {
   // ADR-0011: an exposed action must carry an LLM-facing description.
   if (data.ai?.exposed === true && !data.ai.description) {