test(core): cover state typing in dowhile/dountil loop conditions (#18689)

## Description

Adds type-level regression tests for workflow `state` inference in
`dowhile`/`dountil` condition callbacks.

`createWorkflow` infers the workflow state type from `stateSchema`, so
`state` inside loop conditions is typed from the schema (the same typing
already available inside `createStep`). The existing
`workflow-schema-types.test-d.ts` covers `inputData` in
`dowhile`/`dountil` but never `state`, so this behavior could regress
silently. This PR closes that gap with three `expectTypeOf` checks:

- `state` is inferred from `stateSchema` in a `dowhile` condition
(`attempts: number`, `lastError: string | undefined`)
- same for a `dountil` condition
- with no `stateSchema`, `state` stays `unknown` (backward-compat
baseline)

```ts
const workflow = createWorkflow({
  id: 'my-workflow',
  inputSchema: z.object({ value: z.number() }),
  outputSchema: z.object({ value: z.number() }),
  stateSchema: z.object({ attempts: z.number() }),
}).dowhile(step, async ({ state }) => {
  // state.attempts is typed as `number`
  return state.attempts < 5;
});
```

## Related issue(s)

Closes #14627. The original report (state typed `unknown` in
`dowhile`/`dountil` conditions) no longer reproduces on `main` — it was
resolved by the `createWorkflow` schema-generic refactor in #18608. This
PR does not change runtime or types; it only adds the missing regression
coverage so the fix cannot silently regress, which is why it uses `Refs`
rather than `Closes`.

## Type of change

- [x] Test update

## Checklist

- [x] I have linked the related issue(s) in the description above
- [ ] I have made corresponding changes to the documentation (if
applicable)
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] I have addressed all Coderabbit comments on this PR

Author: minh2416294

packages/core/src/workflows/workflow-schema-types.test-d.ts

@@ -550,4 +550,72 @@ describe('Workflow schema type inference', () => {
       workflow.parallel([step]);
     });
   });
+
+  // Regression: https://github.com/mastra-ai/mastra/issues/14627
+  // createWorkflow must infer the workflow state type from stateSchema so that
+  // `state` in dowhile/dountil condition callbacks is typed from the schema,
+  // not `unknown`. (state was already correct inside createStep; the factory
+  // is what lost the inference.) These tests guard against regressing it.
+  describe('stateSchema inference (issue #14627)', () => {
+    const stateSchema = z.object({
+      attempts: z.number(),
+      lastError: z.string().optional(),
+    });
+    const ioSchema = z.object({ value: z.number() });
+
+    const loopStep = createStep({
+      id: 'loop-step',
+      inputSchema: ioSchema,
+      outputSchema: ioSchema,
+      stateSchema,
+      execute: async ({ inputData }) => ({ value: inputData.value + 1 }),
+    });
+
+    it('types `state` in the dowhile condition from the workflow stateSchema', () => {
+      const workflow = createWorkflow({
+        id: 'dowhile-state',
+        inputSchema: ioSchema,
+        outputSchema: ioSchema,
+        stateSchema,
+      });
+
+      workflow.dowhile(loopStep, async ({ state }) => {
+        expectTypeOf(state).not.toBeUnknown();
+        expectTypeOf(state).not.toBeAny();
+        expectTypeOf(state.attempts).toBeNumber();
+        expectTypeOf(state.lastError).toEqualTypeOf<string | undefined>();
+        return state.attempts < 5;
+      });
+    });
+
+    it('types `state` in the dountil condition from the workflow stateSchema', () => {
+      const workflow = createWorkflow({
+        id: 'dountil-state',
+        inputSchema: ioSchema,
+        outputSchema: ioSchema,
+        stateSchema,
+      });
+
+      workflow.dountil(loopStep, async ({ state }) => {
+        expectTypeOf(state).not.toBeUnknown();
+        expectTypeOf(state).not.toBeAny();
+        expectTypeOf(state.attempts).toBeNumber();
+        expectTypeOf(state.lastError).toEqualTypeOf<string | undefined>();
+        return state.attempts >= 5;
+      });
+    });
+
+    it('leaves `state` as unknown when no stateSchema is declared', () => {
+      const workflow = createWorkflow({
+        id: 'no-state',
+        inputSchema: ioSchema,
+        outputSchema: ioSchema,
+      });
+
+      workflow.dowhile(loopStep, async ({ state }) => {
+        expectTypeOf(state).toBeUnknown();
+        return true;
+      });
+    });
+  });
 });