fix(spec): keep defineForm's option-value refusal an Error with a stack

The refusal was rebuilt with `new z.ZodError(...)`, which in zod v4 classic
is a trait object with no `Error` parent and no `stack`: an uncaught
module-load throw printed `ZodError { name, message: [Getter/Setter] }` and
hid the issues and the remedy. It is now a `z.ZodRealError` built from the
remedied issue copies, with its trace captured at the `defineForm` call
(zod builds every ZodRealError with `Error.stackTraceLimit = 0` and captures
a trace only in `parse`, so the parse's own `safeParse` error carries no
frame either).

The refusal pin now asserts an `Error`, a string `stack`, and a frame in the
calling module; a new case reads the printed wall (the stack's head) for the
grammar message and the remedy.

Claude-Session: https://claude.ai/code/session_013RDBh5DqXd2xnLwvHLgLFr
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

packages/spec/src/ui/form-option-enum-derive.test.ts

@@ -108,7 +108,20 @@ function formWithRow(schemaId: string, row: Record<string, unknown>) {
   });
 }
 
-/** The ZodError a build threw, or a loud failure when it built. */
+/** This file's own name — the module every `defineForm(...)` call below is made from. */
+const THIS_MODULE = 'form-option-enum-derive.test.ts';
+
+/**
+ * The ZodError a build threw, or a loud failure when it built.
+ *
+ * The refusal must be an `Error` with a stack, or an uncaught module-load
+ * throw prints `ZodError { name, message: [Getter/Setter] }` and nothing else:
+ * `new z.ZodError(...)` is a zod trait object, not an `Error`, and
+ * `toBeInstanceOf(z.ZodError)` passes on it all the same. A string `stack` is
+ * not enough either — zod builds `parsed.error` and a bare
+ * `new z.ZodRealError(...)` with no frame at all — so the stack must also name
+ * the module that called `defineForm`.
+ */
 function refusal(build: () => unknown): z.ZodError {
   let thrown: unknown;
   try {
@@ -117,6 +130,9 @@ function refusal(build: () => unknown): z.ZodError {
     thrown = e;
   }
   expect(thrown, 'expected defineForm to REFUSE at module load').toBeInstanceOf(z.ZodError);
+  expect(thrown).toBeInstanceOf(Error);
+  expect(typeof (thrown as Error).stack).toBe('string');
+  expect((thrown as Error).stack, 'the stack names no frame in the module that called defineForm').toContain(THIS_MODULE);
   return thrown as z.ZodError;
 }
 
@@ -201,6 +217,19 @@ describe('defineForm: the refusal of an unspellable option value names the deriv
     expect(statesBlanketOmitRule('When this row edits a spec enum, omit `options`: …')).toBe(true);
   });
 
+  it('the wall an uncaught throw prints (the stack) carries the grammar message and the remedy', () => {
+    // Node prints an uncaught `Error` by its `stack`, whose first line is
+    // `name: message`, and a ZodError's message is its issue list as JSON.
+    const stack = refusal(formWithOption('new-tab')).stack ?? '';
+    const firstFrame = stack.search(/\n\s+at /);
+    const head = firstFrame < 0 ? stack : stack.slice(0, firstFrame);
+    expect(head.startsWith('ZodError: '), head.slice(0, 80)).toBe(true);
+    // Today's grammar message, read live off the object face and JSON-escaped as the message prints it.
+    expect(head).toContain(JSON.stringify(objectFaceMessage('new-tab')).slice(1, -1));
+    expect(namesDerivePath(head), head).toBe(true);
+    expect(scopesDeriveToUnspellable(head), head).toBe(true);
+  });
+
   it('a nested row (composite `fields`) gets the same remedy', () => {
     const thrown = refusal(() => defineForm({
       schemaId: 'action',

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

@@ -6369,7 +6369,18 @@ export function defineForm(
     data: { provider: 'schema', schemaId },
   });
   if (parsed.success) return parsed.data;
-  throw new z.ZodError(withOptionValueDeriveRemedy(parsed.error.issues));
+  // The refusal stays an `Error` with a stack, so an uncaught module-load throw
+  // prints its issues and the remedy, with the author's `defineForm(...)` call
+  // as the first frame. Two traps, both measured on zod 4.6.1: `new z.ZodError`
+  // builds a plain object (no `Error` parent, no `stack`), which node prints as
+  // `ZodError { name, message: [Getter/Setter] }`; and zod builds every
+  // `ZodRealError` with `Error.stackTraceLimit = 0`, capturing a trace only in
+  // `parse`, so `parsed.error` or a bare `new z.ZodRealError` carries no frame.
+  // The error is built from issues that already carry the remedy, so its
+  // lazily computed `message` holds it whenever it is first read.
+  const refusal = new z.ZodRealError(withOptionValueDeriveRemedy(parsed.error.issues));
+  z.core.util.captureStackTrace(refusal, defineForm);
+  throw refusal;
 }
 
 /**