diff --git a/src/Components/Forms/Button.php b/src/Components/Forms/Button.php
index aba811ee..cf74e2c4 100644
--- a/src/Components/Forms/Button.php
+++ b/src/Components/Forms/Button.php
@@ -10,6 +10,7 @@
 use Livewire\Component;
 use Livewire\Features\SupportAttributes\AttributeCollection;
 use T73biz\LwBits\Components\GlobalAttributesTrait;
+use T73biz\LwBits\Exceptions\InvalidAttributeException;
 
 /**
  * Class Button
@@ -18,6 +19,119 @@ class Button extends Component
 {
     use GlobalAttributesTrait;
 
+    /**
+     * This Boolean attribute specifies that the button should have input focus when the page loads. Only one
+     * element in a document can have this attribute.
+     */
+    public bool $autofocus = false;
+
+    /**
+     * This Boolean attribute prevents the user from interacting with the button: it cannot be pressed or focused.
+     */
+    public bool $disabled = false;
+
+    /**
+     * The <form> element to associate the button with (its form owner). The value of this attribute must be
+     * the id of a <form> in the same document. (If this attribute is not set, the <button> is associated
+     * with its ancestor <form> element, if any.) This attribute lets you associate <button> elements to <form>s
+     * anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.
+     */
+    public string $form = '';
+
+    /**
+     * The URL that processes the information submitted by the button. Overrides the action attribute of the
+     * button's form owner. Does nothing if there is no form owner.
+     */
+    public string $formaction = '';
+
+    /**
+     * If the button is a submit button (it's inside/associated with a <form> and doesn't have type="button"),
+     * specifies how to encode the form data that is submitted. Possible values:
+     * application/x-www-form-urlencoded: The default if the attribute is not used.
+     * multipart/form-data: Used to submit <input> elements with their type attributes set to file.
+     * text/plain: Specified as a debugging aid; shouldn't be used for real form submission. If this attribute is
+     * specified, it overrides the enctype attribute of the button's form owner.
+     */
+    public string $formenctype = '';
+
+    /**
+     * If the button is a submit button (it's inside/associated with a <form> and doesn't have type="button"),
+     * this attribute specifies the HTTP method used to submit the form. Possible values:
+     * post: The data from the form are included in the body of the HTTP request when sent to the server. Use when
+     * the form contains information that shouldn't be public, like login credentials.
+     * get: The form data are appended to the form's action URL, with a ? as a separator, and the resulting URL
+     * is sent to the server. Use this method when the form has no side effects, like search forms.
+     * dialog: This method is used to indicate that the button closes the dialog with which it is associated, and
+     * does not transmit the form data at all. If specified, this attribute overrides the method attribute of the
+     * button's form owner.
+     */
+    public string $formmethod = '';
+
+    /**
+     * If the button is a submit button, this Boolean attribute specifies that the form is not to be validated when
+     * it is submitted. If this attribute is specified, it overrides the novalidate attribute of the button's form
+     * owner. This attribute is also available on <input type="image"> and <input type="submit"> elements.
+     */
+    public bool $formnovalidate = false;
+
+    /**
+     * If the button is a submit button, this attribute is an author-defined name or standardized, underscore-prefixed
+     * keyword indicating where to display the response from submitting the form. This is the name of, or keyword for,
+     * a browsing context (a tab, window, or <iframe>). If this attribute is specified, it overrides the target attribute
+     * of the button's form owner. The following keywords have special meanings:
+     * _self: Load the response into the same browsing context as the current one. This is the default if the attribute
+     * is not specified.
+     * _blank: Load the response into a new unnamed browsing context — usually a new tab or window, depending on the
+     * user's browser settings.
+     * _parent: Load the response into the parent browsing context of the current one. If there is no parent, this option
+     * behaves the same way as _self.
+     * _top: Load the response into the top-level browsing context (that is, the browsing context that is an ancestor of
+     * the current one, and has no parent).
+     *
+     * If there is no parent, this option behaves the same way as _self.
+     */
+    public string $formtarget = '';
+
+    /**
+     * The name of the button, submitted as a pair with the button's value as part of the form data, when that button
+     * is used to submit the form.
+     */
+    public string $name = '';
+
+    /**
+     * Turns a <button> element into a popover control button; takes the ID of the popover element to control as its
+     * value. See the Popover API landing page for more details.
+     */
+    public string $popovertarget = '';
+
+    /**
+     * Specifies the action to be performed on a popover element being controlled by a control <button>. Possible values
+     * are:
+     * "hide" The button will hide a shown popover. If you try to hide an already hidden popover, no action will be taken.
+     * "show" The button will show a hidden popover. If you try to show an already showing popover, no action will be taken.
+     * "toggle" The button will toggle a popover between showing and hidden. If the popover is hidden, it will be shown; if
+     * the popover is showing, it will be hidden. If popovertargetaction is omitted, "toggle" is the default action that
+     * will be performed by the control button.
+     */
+    public string $popovertargetaction = '';
+
+    /**
+     * The default behavior of the button. Possible values are:
+     * submit: The button submits the form data to the server. This is the default if the attribute is not specified
+     * for buttons associated with a <form>, or if the attribute is an empty or invalid value.
+     * reset: The button resets all the controls to their initial values, like <input type="reset">
+     * (This behavior tends to annoy users.)
+     * button: The button has no default behavior, and does nothing when pressed by default. It can have client-side
+     * scripts listen to the element's events, which are triggered when the events occur.
+     */
+    public string $type = '';
+
+    /**
+     * Defines the value associated with the button's name when it's submitted with the form data. This value is
+     * passed to the server in params when the form is submitted using this button.
+     */
+    public string $value = '';
+
     /**
      * The specific attributes for the embed component
      */
@@ -32,6 +146,113 @@ public function mount(): void
     {
         $this->setGlobalAttributes();
         $this->specificAttributes = new AttributeCollection();
+        if ($this->disabled) {
+            $this->specificAttributes->add(['disabled']);
+        }
+        if (! empty($this->form)) {
+            $this->specificAttributes->add(['form' => $this->form]);
+        }
+        if (! empty($this->formaction)) {
+            if (empty($this->form)) {
+                throw new InvalidAttributeException('The formaction attribute requires form attribute to be set.');
+            }
+            $this->specificAttributes->add(['formaction' => $this->formaction]);
+        }
+        if (! empty($this->formenctype)) {
+            if (empty($this->form)) {
+                throw new InvalidAttributeException('The formenctype attribute requires form attribute to be set.');
+            }
+            if (! empty($this->type) && $this->type !== 'submit') {
+                throw new InvalidAttributeException(
+                    'The formenctype attribute requires type attribute to be set to submit.'
+                );
+            }
+            if (! in_array($this->formenctype, ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'])) {
+                throw new InvalidAttributeException(
+                    'The formenctype attribute must be one of application/x-www-form-urlencoded, multipart/form-data, text/plain.'
+                );
+            }
+            $this->specificAttributes->add(['formenctype' => $this->formenctype]);
+        }
+        if (! empty($this->formmethod)) {
+            if (empty($this->form)) {
+                throw new InvalidAttributeException(
+                    'The formmethod attribute requires form attribute to be set.'
+                );
+            }
+            if (! empty($this->type) && $this->type !== 'submit') {
+                throw new InvalidAttributeException(
+                    'The formmethod attribute requires type attribute to be set to submit.'
+                );
+            }
+            if (! in_array($this->formmethod, ['post', 'get', 'dialog'])) {
+                throw new InvalidAttributeException(
+                    'The formmethod attribute must be one of post, get, or dialog.'
+                );
+            }
+            $this->specificAttributes->add(['formmethod' => $this->formmethod]);
+        }
+        if ($this->formnovalidate) {
+            if (empty($this->form)) {
+                throw new InvalidAttributeException(
+                    'The formnovalidate attribute requires form attribute to be set.'
+                );
+            }
+            if (! empty($this->type) && $this->type !== 'submit') {
+                throw new InvalidAttributeException(
+                    'The formnovalidate attribute requires type attribute to be set to submit.'
+                );
+            }
+            $this->specificAttributes->add(['formnovalidate']);
+        }
+        if (! empty($this->formtarget)) {
+            if (empty($this->form)) {
+                throw new InvalidAttributeException(
+                    'The formtarget attribute requires form attribute to be set.'
+                );
+            }
+            if (! empty($this->type) && $this->type !== 'submit') {
+                throw new InvalidAttributeException(
+                    'The formtarget attribute requires type attribute to be set to submit.'
+                );
+            }
+            if (! in_array($this->formtarget, ['_self', '_blank', '_parent', '_top'])) {
+                throw new InvalidAttributeException(
+                    'The formtarget attribute must be one of _self, _blank, _parent, or _top.'
+                );
+            }
+            $this->specificAttributes->add(['formtarget' => $this->formtarget]);
+        }
+        if (! empty($this->name)) {
+            $this->specificAttributes->add(['name' => $this->name]);
+        }
+        if (! empty($this->popovertarget)) {
+            $this->specificAttributes->add(['popovertarget' => $this->popovertarget]);
+        }
+        if (! empty($this->popovertargetaction)) {
+            if (! in_array($this->popovertargetaction, ['hide', 'show', 'toggle'])) {
+                throw new InvalidAttributeException(
+                    'The popovertargetaction attribute must be one of hide, show, or toggle.'
+                );
+            }
+            $this->specificAttributes->add(['popovertargetaction' => $this->popovertargetaction]);
+        }
+        if (! empty($this->type)) {
+            if (! in_array($this->type, ['submit', 'reset', 'button'])) {
+                throw new InvalidAttributeException(
+                    'The type attribute must be one of submit, reset, or button.'
+                );
+            }
+            $this->specificAttributes->add(['type' => $this->type]);
+        }
+        if (! empty($this->value)) {
+            if (empty($this->name)) {
+                throw new InvalidAttributeException(
+                    'The value attribute requires name attribute to be set.'
+                );
+            }
+            $this->specificAttributes->add(['value' => $this->value]);
+        }
     }
 
     /**
diff --git a/src/Components/Forms/Fieldset.php b/src/Components/Forms/Fieldset.php
index 1afc61bc..c246e116 100644
--- a/src/Components/Forms/Fieldset.php
+++ b/src/Components/Forms/Fieldset.php
@@ -18,6 +18,29 @@ class Fieldset extends Component
 {
     use GlobalAttributesTrait;
 
+    /**
+     * If this Boolean attribute is set, all form controls that are descendants of the <fieldset>,
+     * are disabled, meaning they are not editable and won't be submitted along with the <form>.
+     * They won't receive any browsing events, like mouse clicks or focus-related events. By default
+     * browsers display such controls grayed out. Note that form elements inside the <legend> element
+     * won't be disabled.
+     */
+    public bool $disabled = false;
+
+    /**
+     * This attribute takes the value of the id attribute of a <form> element you want the <fieldset>
+     * to be part of, even if it is not inside the form. Please note that usage of this is confusing
+     * — if you want the <input> elements inside the <fieldset> to be associated with the form, you
+     * need to use the form attribute directly on those elements. You can check which elements are
+     * associated with a form via JavaScript, using HTMLFormElement.elements.
+     */
+    public string $form = '';
+
+    /**
+     * The name associated with the group.
+     */
+    public string $name = '';
+
     /**
      * Standard mount function
      */
@@ -35,6 +58,15 @@ public function mount(): void
     {
         $this->setGlobalAttributes();
         $this->specificAttributes = new AttributeCollection();
+        if ($this->disabled) {
+            $this->specificAttributes->add(['disabled']);
+        }
+        if (! empty($this->form)) {
+            $this->specificAttributes->add(['form' => $this->form]);
+        }
+        if (! empty($this->name)) {
+            $this->specificAttributes->add(['name' => $this->name]);
+        }
     }
 
     /**
diff --git a/src/Components/Forms/Form.php b/src/Components/Forms/Form.php
index d1ff97d2..a4709f46 100644
--- a/src/Components/Forms/Form.php
+++ b/src/Components/Forms/Form.php
@@ -10,6 +10,7 @@
 use Livewire\Component;
 use Livewire\Features\SupportAttributes\AttributeCollection;
 use T73biz\LwBits\Components\GlobalAttributesTrait;
+use T73biz\LwBits\Exceptions\InvalidAttributeException;
 
 /**
  * Class Form
@@ -18,6 +19,81 @@ class Form extends Component
 {
     use GlobalAttributesTrait;
 
+    /**
+     * Space-separated character encodings the server accepts. The browser uses them in the order in which they
+     * are listed. The default value means the same encoding as the page. (In previous versions of HTML, character
+     * encodings could also be delimited by commas.)
+     */
+    public string $acceptCharset = '';
+
+    /**
+     * The URL that processes the form submission. This value can be overridden by a formaction attribute on
+     * a <button>, <input type="submit">, or <input type="image"> element. This attribute is ignored when
+     * method="dialog" is set.
+     */
+    public string $action = '';
+
+    /**
+     * If the value of the method attribute is post, enctype is the MIME type of the form submission. Possible
+     * values:
+     *      - application/x-www-form-urlencoded: The default value.
+     *      - multipart/form-data: Use this if the form contains <input> elements with type=file.
+     *      - text/plain: Useful for debugging purposes.
+     * This value can be overridden by formenctype attributes on <button>, <input type="submit">, or <input
+     * type="image"> elements.
+     */
+    public string $enctype = '';
+
+    /**
+     * The HTTP method to submit the form with. The only allowed methods/values are (case insensitive):
+     *      - post: The POST method; form data sent as the request body.
+     *      - get (default): The GET; form data appended to the action URL with a ? separator. Use this method
+     *      when the form has no side effects.
+     *      - dialog: When the form is inside a <dialog>, closes the dialog and causes a submit event to be
+     *      fired on submission, without submitting data or clearing the form.
+     * This value is overridden by formmethod attributes on <button>, <input type="submit">, or <input
+     * type="image"> elements.
+     */
+    public string $method = '';
+
+    /**
+     * The name of the form. The value must not be the empty string, and must be unique among the form elements
+     * in the forms collection that it is in, if any.
+     */
+    public string $name = '';
+
+    /**
+     * This Boolean attribute indicates that the form shouldn't be validated when submitted. If this attribute
+     * is not set (and therefore the form is validated), it can be overridden by a formnovalidate attribute on
+     * a <button>, <input type="submit">, or <input type="image"> element belonging to the form.
+     */
+    public bool $noValidate = false;
+
+    /**
+     * Controls the annotations and what kinds of links the form creates. Annotations include external,
+     * nofollow, opener, noopener, and noreferrer. Link types include help, prev, next, search, and license.
+     * The rel value is a space-separated list of these enumerated values.
+     */
+    public string $rel = '';
+
+    /**
+     * Indicates where to display the response after submitting the form. It is a name/keyword for a browsing
+     * context (for example, tab, window, or iframe). The following keywords have special meanings:
+     *      - _self (default): Load into the same browsing context as the current one.
+     *      - _blank: Load into a new unnamed browsing context. This provides the same behavior as setting
+     *      rel="noopener" which does not set window.opener.
+     *      - _parent: Load into the parent browsing context of the current one. If no parent, behaves the
+     *      same as _self.
+     *      - _top: Load into the top-level browsing context (i.e., the browsing context that is an ancestor
+     *      of the current one and has no parent). If no parent, behaves the same as _self.
+     *      - _unfencedTop: Load the response from a form inside an embedded fenced frame into the top-level
+     *      frame (i.e., traversing beyond the root of the fenced frame, unlike other reserved destinations).
+     *      Only available inside fenced frames.
+     * This value can be overridden by a formtarget attribute on a <button>, <input type="submit">, or <input
+     * type="image"> element.
+     */
+    public string $target = '';
+
     /**
      * The specific attributes for the embed component
      */
@@ -32,6 +108,55 @@ public function mount(): void
     {
         $this->setGlobalAttributes();
         $this->specificAttributes = new AttributeCollection();
+        if (! empty($this->acceptCharset)) {
+            $this->specificAttributes->add(['accept-charset' => $this->acceptCharset]);
+        }
+        if (! empty($this->action)) {
+            if (strtolower($this->method) === 'dialog') {
+                throw new InvalidAttributeException(
+                    'The action attribute is ignored when method="dialog" is set'
+                );
+            }
+            $this->specificAttributes->add(['action' => $this->action]);
+        }
+        if (! empty($this->enctype)) {
+            if (strtolower($this->method) !== 'post') {
+                throw new InvalidAttributeException(
+                    'The enctype attribute can only be used when the method attribute is set to post'
+                );
+            }
+            if (! in_array(strtolower($this->enctype), ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'])) {
+                throw new InvalidAttributeException(
+                    'The enctype attribute must be one of application/x-www-form-urlencoded, multipart/form-data, or text/plain'
+                );
+            }
+            $this->specificAttributes->add(['enctype' => $this->enctype]);
+        }
+        if (! empty($this->method)) {
+            if (! in_array(strtolower($this->method), ['post', 'get', 'dialog'])) {
+                throw new InvalidAttributeException(
+                    'The method attribute must be one of post, get, or dialog'
+                );
+            }
+            $this->specificAttributes->add(['method' => $this->method]);
+        }
+        if (! empty($this->name)) {
+            $this->specificAttributes->add(['name' => $this->name]);
+        }
+        if ($this->noValidate) {
+            $this->specificAttributes->add(['novalidate']);
+        }
+        if (! empty($this->rel)) {
+            $this->specificAttributes->add(['rel' => $this->rel]);
+        }
+        if (! empty($this->target)) {
+            if (! in_array(strtolower($this->target), ['_self', '_blank', '_parent', '_top', '_unfencedTop'])) {
+                throw new InvalidAttributeException(
+                    'The target attribute must be one of _self, _blank, _parent, _top, or _unfencedTop'
+                );
+            }
+            $this->specificAttributes->add(['target' => $this->target]);
+        }
     }
 
     /**
diff --git a/src/Components/Forms/Label.php b/src/Components/Forms/Label.php
index 7cc782af..762029b2 100644
--- a/src/Components/Forms/Label.php
+++ b/src/Components/Forms/Label.php
@@ -18,6 +18,12 @@ class Label extends Component
 {
     use GlobalAttributesTrait;
 
+    /**
+     * The value of the for attribute must be a single id for a labelable form-related element in the same document as
+     * the <label> element. So, any given label element can be associated with only one form control.
+     */
+    public string $for = '';
+
     /**
      * The specific attributes for the embed component
      */
@@ -32,6 +38,9 @@ public function mount(): void
     {
         $this->setGlobalAttributes();
         $this->specificAttributes = new AttributeCollection();
+        if (! empty($this->for)) {
+            $this->specificAttributes->add(['for' => $this->for]);
+        }
     }
 
     /**
diff --git a/src/Components/Forms/Meter.php b/src/Components/Forms/Meter.php
index 996d3d97..99fb27ce 100644
--- a/src/Components/Forms/Meter.php
+++ b/src/Components/Forms/Meter.php
@@ -18,6 +18,62 @@ class Meter extends Component
 {
     use GlobalAttributesTrait;
 
+    /**
+     * This optional attribute is used to explicitly set a <form> owner for the <meter> element. If
+     * omitted, the <meter> is associated with its ancestor <form> element or the form association
+     * set by the form attribute on another ancestor element, such as on a <fieldset>, if any. If
+     * included, the value must be the id of a <form> in the same tree.
+     */
+    public string $form = '';
+
+    /**
+     * The lower numeric bound of the high end of the measured range. This must be less than the
+     * maximum value (max attribute), and it also must be greater than the low value and minimum
+     * value (low attribute and min attribute, respectively), if any are specified. If unspecified,
+     * or if greater than the maximum value, the high value is equal to the maximum value.
+     */
+    public int $high = 1;
+
+    /**
+     * The upper numeric bound of the low end of the measured range. This must be greater than the
+     * minimum value (min attribute), and it also must be less than the high value and maximum value
+     * (high attribute and max attribute, respectively), if any are specified. If unspecified, or
+     * if less than the minimum value, the low value is equal to the minimum value.
+     */
+    public int $low = 0;
+
+    /**
+     * The upper numeric bound of the measured range. This must be greater than the minimum value (min
+     * attribute), if specified. If unspecified, the maximum value is 1.
+     */
+    public int $max = 1;
+
+    /**
+     * The lower numeric bound of the measured range. This must be less than the maximum value (max
+     * attribute), if specified. If unspecified, the minimum value is 0.
+     */
+    public int $min = 0;
+
+    /**
+     * This attribute indicates the optimal numeric value. It must be within the range (as defined by
+     * the min attribute and max attribute). When used with the low attribute and high attribute, it
+     * gives an indication where along the range is considered preferable. For example, if it is
+     * between the min attribute and the low attribute, then the lower range is considered preferred.
+     * The browser may color the meter's bar differently depending on whether the value is less than
+     * or equal to the optimum value.
+     */
+    public int $optimum = 0;
+
+    /**
+     * The current numeric value. This must be between the minimum and maximum values (min attribute
+     * and max attribute) if they are specified. If unspecified or malformed, the value is 0. If
+     * specified, but not within the range given by the min attribute and max attribute, the value
+     * is equal to the nearest end of the range. Note: Unless the value attribute is between 0 and 1
+     * (inclusive), the min and max attributes should define the range so that the value attribute's
+     * value is within it.
+     */
+    public int $value = 0;
+
     /**
      * The specific attributes for the embed component
      */
@@ -32,6 +88,27 @@ public function mount(): void
     {
         $this->setGlobalAttributes();
         $this->specificAttributes = new AttributeCollection();
+        if (! empty($this->form)) {
+            $this->specificAttributes->add(['form' => $this->form]);
+        }
+        if ($this->high !== 1) {
+            $this->specificAttributes->add(['high' => $this->high]);
+        }
+        if ($this->low !== 0) {
+            $this->specificAttributes->add(['low' => $this->low]);
+        }
+        if ($this->max !== 1) {
+            $this->specificAttributes->add(['max' => $this->max]);
+        }
+        if ($this->min !== 0) {
+            $this->specificAttributes->add(['min' => $this->min]);
+        }
+        if ($this->optimum !== 0) {
+            $this->specificAttributes->add(['optimum' => $this->optimum]);
+        }
+        if ($this->value !== 0) {
+            $this->specificAttributes->add(['value' => $this->value]);
+        }
     }
 
     /**
diff --git a/src/Components/Forms/Optgroup.php b/src/Components/Forms/Optgroup.php
index d07e6861..aeccf4fe 100644
--- a/src/Components/Forms/Optgroup.php
+++ b/src/Components/Forms/Optgroup.php
@@ -18,6 +18,19 @@ class Optgroup extends Component
 {
     use GlobalAttributesTrait;
 
+    /**
+     * If this Boolean attribute is set, none of the items in this option group is selectable.
+     * Often browsers grey out such control and it won't receive any browsing events,
+     * like mouse clicks or focus-related ones.
+     */
+    public bool $disabled = false;
+
+    /**
+     * The name of the group of options, which the browser can use when labeling the options
+     * in the user interface. This attribute is mandatory if this element is used.
+     */
+    public string $label = '';
+
     /**
      * The specific attributes for the embed component
      */
@@ -32,6 +45,15 @@ public function mount(): void
     {
         $this->setGlobalAttributes();
         $this->specificAttributes = new AttributeCollection();
+        if ($this->disabled) {
+            $this->specificAttributes->add(['disabled']);
+        }
+        if (empty($this->label)) {
+            throw new \T73biz\LwBits\Exceptions\InvalidAttributeException(
+                'The label attribute is mandatory for the optgroup component'
+            );
+        }
+        $this->specificAttributes->add(['label' => $this->label]);
     }
 
     /**
diff --git a/src/Components/Forms/Option.php b/src/Components/Forms/Option.php
index f32275c9..a6f86e01 100644
--- a/src/Components/Forms/Option.php
+++ b/src/Components/Forms/Option.php
@@ -18,6 +18,32 @@ class Option extends Component
 {
     use GlobalAttributesTrait;
 
+    /**
+     * If this Boolean attribute is set, this option is not checkable. Often browsers grey out such control
+     * and it won't receive any browsing event, like mouse clicks or focus-related ones. If this attribute is
+     * not set, the element can still be disabled if one of its ancestors is a disabled <optgroup> element.
+     */
+    public bool $disabled = false;
+
+    /**
+     * This attribute is text for the label indicating the meaning of the option. If the label attribute isn't defined,
+     * its value is that of the element text content.
+     */
+    public string $label = '';
+
+    /**
+     * If present, this Boolean attribute indicates that the option is initially selected. If the <option> element is the
+     * descendant of a <select> element whose multiple attribute is not set, only one single <option> of this <select>
+     * element may have the selected attribute.
+     */
+    public bool $selected = false;
+
+    /**
+     * The content of this attribute represents the value to be submitted with the form, should this option be selected.
+     * If this attribute is omitted, the value is taken from the text content of the option element.
+     */
+    public string $value = '';
+
     /**
      * The specific attributes for the embed component
      */
@@ -32,6 +58,18 @@ public function mount(): void
     {
         $this->setGlobalAttributes();
         $this->specificAttributes = new AttributeCollection();
+        if ($this->disabled) {
+            $this->specificAttributes->add(['disabled']);
+        }
+        if (! empty($this->label)) {
+            $this->specificAttributes->add(['label' => $this->label]);
+        }
+        if ($this->selected) {
+            $this->specificAttributes->add(['selected']);
+        }
+        if (! empty($this->value)) {
+            $this->specificAttributes->add(['value' => $this->value]);
+        }
     }
 
     /**
diff --git a/src/Components/Forms/Output.php b/src/Components/Forms/Output.php
index 7f493cb2..0e6a7090 100644
--- a/src/Components/Forms/Output.php
+++ b/src/Components/Forms/Output.php
@@ -18,6 +18,27 @@ class Output extends Component
 {
     use GlobalAttributesTrait;
 
+    /**
+     * A space-separated list of other elements' ids, indicating that those elements contributed
+     * input values to (or otherwise affected) the calculation.
+     */
+    public string $for = '';
+
+    /**
+     * The <form> element to associate the output with (its form owner). The value of this attribute must
+     * be the id of a <form> in the same document. (If this attribute is not set, the <output> is
+     * associated with its ancestor <form> element, if any.) This attribute lets you associate
+     * <output> elements to <form>s anywhere in the document, not just inside a <form>.
+     * It can also override an ancestor <form> element.
+     */
+    public string $form = '';
+
+    /**
+     * The element's name. Used in the form.elements API. The <output> value, name, and contents are
+     * NOT submitted during form submission.
+     */
+    public string $name = '';
+
     /**
      * The specific attributes for the embed component
      */
@@ -32,6 +53,15 @@ public function mount(): void
     {
         $this->setGlobalAttributes();
         $this->specificAttributes = new AttributeCollection();
+        if (! empty($this->for)) {
+            $this->specificAttributes->add(['for' => $this->for]);
+        }
+        if (! empty($this->form)) {
+            $this->specificAttributes->add(['form' => $this->form]);
+        }
+        if (! empty($this->name)) {
+            $this->specificAttributes->add(['name' => $this->name]);
+        }
     }
 
     /**
diff --git a/src/Components/Forms/Progress.php b/src/Components/Forms/Progress.php
index ff0d049f..ee885eba 100644
--- a/src/Components/Forms/Progress.php
+++ b/src/Components/Forms/Progress.php
@@ -18,6 +18,21 @@ class Progress extends Component
 {
     use GlobalAttributesTrait;
 
+    /**
+     * max This attribute describes how much work the task indicated by the progress element requires. The max
+     * attribute, if present, must have a value greater than 0 and be a valid integer. The default
+     * value is 1.
+     */
+    public int $max = 1;
+
+    /**
+     * value This attribute specifies how much of the task that has been completed. It must be a valid integer
+     * between 0 and max, or between 0 and 1 if max is omitted. If there is no value attribute, the progress bar
+     * is indeterminate; this indicates that an activity is ongoing with no indication of how long it is expected
+     * to take.
+     */
+    public int $value = 0;
+
     /**
      * The specific attributes for the embed component
      */
@@ -32,6 +47,12 @@ public function mount(): void
     {
         $this->setGlobalAttributes();
         $this->specificAttributes = new AttributeCollection();
+        if ($this->max > 1) {
+            $this->specificAttributes->add(['max' => $this->max]);
+        }
+        if ($this->value > 0) {
+            $this->specificAttributes->add(['value' => $this->value]);
+        }
     }
 
     /**
diff --git a/src/Components/Forms/Select.php b/src/Components/Forms/Select.php
index 7c55be8b..f0b1a313 100644
--- a/src/Components/Forms/Select.php
+++ b/src/Components/Forms/Select.php
@@ -18,6 +18,47 @@ class Select extends Component
 {
     use GlobalAttributesTrait;
 
+    /**
+     * This Boolean attribute indicates that the user cannot interact with the control. If this attribute
+     * is not specified, the control inherits its setting from the containing element, for example
+     * <fieldset>; if there is no containing element with the disabled attribute set, then the control
+     * is enabled.
+     */
+    public bool $disabled = false;
+
+    /**
+     * The <form> element to associate the <select> with (its form owner). The value of this attribute
+     * must be the id of a <form> in the same document. (If this attribute is not set, the <select> is
+     * associated with its ancestor <form> element, if any.) This attribute lets you associate <select>
+     * elements to <form>s anywhere in the document, not just inside a <form>. It can also override an
+     * ancestor <form> element.
+     */
+    public string $form = '';
+
+    /**
+     * This Boolean attribute indicates that multiple options can be selected in the list. If it is
+     * not specified, then only one option can be selected at a time. When multiple is specified,
+     * most browsers will show a scrolling list box instead of a single line dropdown.
+     */
+    public bool $multiple = false;
+
+    /**
+     * This attribute is used to specify the name of the control.
+     */
+    public string $name = '';
+
+    /**
+     * A Boolean attribute indicating that an option with a non-empty string value must be selected.
+     */
+    public bool $required = false;
+
+    /**
+     * If the control is presented as a scrolling list box (e.g. when multiple is specified), this attribute
+     * represents the number of rows in the list that should be visible at one time. Browsers are not required
+     * to present a select element as a scrolled list box. The default value is 0.
+     */
+    public int $size = 0;
+
     /**
      * The specific attributes for the embed component
      */
@@ -32,6 +73,24 @@ public function mount(): void
     {
         $this->setGlobalAttributes();
         $this->specificAttributes = new AttributeCollection();
+        if ($this->disabled) {
+            $this->specificAttributes->add(['disabled']);
+        }
+        if (! empty($this->form)) {
+            $this->specificAttributes->add(['form' => $this->form]);
+        }
+        if ($this->multiple) {
+            $this->specificAttributes->add(['multiple']);
+        }
+        if (! empty($this->name)) {
+            $this->specificAttributes->add(['name' => $this->name]);
+        }
+        if ($this->required) {
+            $this->specificAttributes->add(['required']);
+        }
+        if ($this->size > 0) {
+            $this->specificAttributes->add(['size' => $this->size]);
+        }
     }
 
     /**
diff --git a/tests/Feature/Forms/ButtonTest.php b/tests/Feature/Forms/ButtonTest.php
index 23e89756..99c30eae 100644
--- a/tests/Feature/Forms/ButtonTest.php
+++ b/tests/Feature/Forms/ButtonTest.php
@@ -117,3 +117,83 @@
     Livewire::test(MyButton::class, ['translate' => 'yes'])
         ->assertSee('translate');
 });
+
+it('can render with disabled', function () {
+    Livewire::test(MyButton::class, ['disabled' => true])
+        ->assertSee('disabled');
+});
+
+it('can render with form', function () {
+    Livewire::test(MyButton::class, ['form' => 'main-form'])
+        ->assertSee('form="main-form"', false);
+});
+
+it('can render with formaction', function () {
+    Livewire::test(
+        MyButton::class,
+        [
+            'formaction' => 'submit-form',
+            'form' => 'main-form',
+            'type' => 'submit',
+        ]
+    )->assertSee('formaction="submit-form"', false);
+});
+
+it('can render with formenctype', function () {
+    Livewire::test(
+        MyButton::class,
+        [
+            'formenctype' => 'application/x-www-form-urlencoded',
+            'form' => 'main-form',
+            'type' => 'submit',
+        ]
+    )->assertSee('formenctype="application/x-www-form-urlencoded"', false);
+});
+
+it('can render with formmethod', function () {
+    Livewire::test(
+        MyButton::class,
+        [
+            'formmethod' => 'post',
+            'form' => 'main-form',
+            'type' => 'submit',
+        ]
+    )->assertSee('formmethod="post"', false);
+});
+
+it('can render with formnovalidate', function () {
+    Livewire::test(
+        MyButton::class,
+        [
+            'formnovalidate' => true,
+            'form' => 'main-form',
+            'type' => 'submit',
+        ]
+    )->assertSee('formnovalidate');
+});
+
+it('can render with formtarget', function () {
+    Livewire::test(
+        MyButton::class,
+        [
+            'formtarget' => '_blank',
+            'form' => 'main-form',
+            'type' => 'submit',
+        ]
+    )->assertSee('formtarget="_blank"', false);
+});
+
+it('can render with name', function () {
+    Livewire::test(MyButton::class, ['name' => 'main-button'])
+        ->assertSee('name="main-button"', false);
+});
+
+it('can render with type', function () {
+    Livewire::test(MyButton::class, ['type' => 'submit'])
+        ->assertSee('type="submit"', false);
+});
+
+it('can render with value', function () {
+    Livewire::test(MyButton::class, ['name' => 'foo', 'value' => 'main-button'])
+        ->assertSee('value="main-button"', false);
+});
diff --git a/tests/Feature/Forms/FieldsetTest.php b/tests/Feature/Forms/FieldsetTest.php
index a626cc61..c09e05d1 100644
--- a/tests/Feature/Forms/FieldsetTest.php
+++ b/tests/Feature/Forms/FieldsetTest.php
@@ -117,3 +117,18 @@
     Livewire::test(MyFieldset::class, ['translate' => 'yes'])
         ->assertSee('translate');
 });
+
+it('can render with disabled', function () {
+    Livewire::test(MyFieldset::class, ['disabled' => true])
+        ->assertSee('disabled');
+});
+
+it('can render with form', function () {
+    Livewire::test(MyFieldset::class, ['form' => 'main-form'])
+        ->assertSee('form="main-form"', false);
+});
+
+it('can render with name', function () {
+    Livewire::test(MyFieldset::class, ['name' => 'main-fieldset'])
+        ->assertSee('name="main-fieldset"', false);
+});
diff --git a/tests/Feature/Forms/FormTest.php b/tests/Feature/Forms/FormTest.php
index 5847523e..7d9d1fd8 100644
--- a/tests/Feature/Forms/FormTest.php
+++ b/tests/Feature/Forms/FormTest.php
@@ -117,3 +117,38 @@
     Livewire::test(MyForm::class, ['translate' => 'yes'])
         ->assertSee('translate');
 });
+
+it('can render with action', function () {
+    Livewire::test(MyForm::class, ['action' => 'https://example.com'])
+        ->assertSee('action="https://example.com"', false);
+});
+
+it('can render with enctype', function () {
+    Livewire::test(MyForm::class, ['enctype' => 'multipart/form-data', 'method' => 'post'])
+        ->assertSee('enctype="multipart/form-data"', false);
+});
+
+it('can render with method', function () {
+    Livewire::test(MyForm::class, ['method' => 'post'])
+        ->assertSee('method="post"', false);
+});
+
+it('can render with name', function () {
+    Livewire::test(MyForm::class, ['name' => 'main-form'])
+        ->assertSee('name="main-form"', false);
+});
+
+it('can render with novalidate', function () {
+    Livewire::test(MyForm::class, ['noValidate' => true])
+        ->assertSee('novalidate');
+});
+
+it('can render with rel', function () {
+    Livewire::test(MyForm::class, ['rel' => 'main-form'])
+        ->assertSee('rel="main-form"', false);
+});
+
+it('can render with target', function () {
+    Livewire::test(MyForm::class, ['target' => '_blank'])
+        ->assertSee('target="_blank"', false);
+});
diff --git a/tests/Feature/Forms/LabelTest.php b/tests/Feature/Forms/LabelTest.php
index 6c6d49f0..ad56023c 100644
--- a/tests/Feature/Forms/LabelTest.php
+++ b/tests/Feature/Forms/LabelTest.php
@@ -117,3 +117,8 @@
     Livewire::test(MyLabel::class, ['translate' => 'yes'])
         ->assertSee('translate');
 });
+
+it('can render with for', function () {
+    Livewire::test(MyLabel::class, ['for' => 'main-label'])
+        ->assertSee('for="main-label"', false);
+});
diff --git a/tests/Feature/Forms/MeterTest.php b/tests/Feature/Forms/MeterTest.php
index 4b3fa8ad..97e32bbe 100644
--- a/tests/Feature/Forms/MeterTest.php
+++ b/tests/Feature/Forms/MeterTest.php
@@ -117,3 +117,38 @@
     Livewire::test(MyMeter::class, ['translate' => 'yes'])
         ->assertSee('translate');
 });
+
+it('can render with high', function () {
+    Livewire::test(MyMeter::class, ['high' => 2])
+        ->assertSee('high="2"', false);
+});
+
+it('can render with low', function () {
+    Livewire::test(MyMeter::class, ['low' => 4])
+        ->assertSee('low="4"', false);
+});
+
+it('can render with max', function () {
+    Livewire::test(MyMeter::class, ['max' => 2])
+        ->assertSee('max="2"', false);
+});
+
+it('can render with min', function () {
+    Livewire::test(MyMeter::class, ['min' => 1])
+        ->assertSee('min="1"', false);
+});
+
+it('can render with optimum', function () {
+    Livewire::test(MyMeter::class, ['optimum' => 2])
+        ->assertSee('optimum="2"', false);
+});
+
+it('can render with value', function () {
+    Livewire::test(MyMeter::class, ['value' => 3])
+        ->assertSee('value="3"', false);
+});
+
+it('can render with form', function () {
+    Livewire::test(MyMeter::class, ['form' => 'main-form'])
+        ->assertSee('form="main-form"', false);
+});
diff --git a/tests/Feature/Forms/OptgroupTest.php b/tests/Feature/Forms/OptgroupTest.php
index a481b48d..99374f6b 100644
--- a/tests/Feature/Forms/OptgroupTest.php
+++ b/tests/Feature/Forms/OptgroupTest.php
@@ -4,116 +4,126 @@
 use T73biz\LwBits\Tests\TestSupport\Components\Forms\MyOptgroup;
 
 it('can render', function () {
-    Livewire::test(MyOptgroup::class)
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo'])
         ->assertStatus(200);
 });
 
 it('can render with accesskey', function () {
-    Livewire::test(MyOptgroup::class, ['accesskey' => true])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'accesskey' => true])
         ->assertSee('accesskey');
 });
 
 it('can render with autocapitalize', function () {
-    Livewire::test(MyOptgroup::class, ['autocapitalize' => true])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'autocapitalize' => true])
         ->assertSee('autocapitalize');
 });
 
 it('can render with autofocus', function () {
-    Livewire::test(MyOptgroup::class, ['autofocus' => true])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'autofocus' => true])
         ->assertSee('autofocus');
 });
 
 it('can render with contenteditable', function () {
-    Livewire::test(MyOptgroup::class, ['contenteditable' => true])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'contenteditable' => true])
         ->assertSee('contenteditable');
 });
 
 it('can render with css classes', function () {
-    Livewire::test(MyOptgroup::class, ['cssClasses' => ['class1', 'class2']])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'cssClasses' => ['class1', 'class2']])
         ->assertSee('class="class1 class2"', false);
 });
 
 it('can render with data-*', function () {
-    Livewire::test(MyOptgroup::class, ['data' => ['name' => 'main-optgroup']])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'data' => ['name' => 'main-optgroup']])
         ->assertSee('data-name="main-optgroup"', false);
 });
 
 it('can render with dir', function () {
-    Livewire::test(MyOptgroup::class, ['direction' => 'rtl'])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'direction' => 'rtl'])
         ->assertSee('dir="rtl"', false);
 });
 
 it('can render with draggable', function () {
-    Livewire::test(MyOptgroup::class, ['draggable' => 'true'])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'draggable' => 'true'])
         ->assertSee('draggable');
 });
 
 it('can render with enterkeyhint', function () {
-    Livewire::test(MyOptgroup::class, ['enterkeyhint' => 'enter'])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'enterkeyhint' => 'enter'])
         ->assertSee('enterkeyhint="enter"', false);
 });
 
 it('can render with hidden', function () {
-    Livewire::test(MyOptgroup::class, ['hidden' => true])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'hidden' => true])
         ->assertSee('hidden');
 });
 
 it('can render with id', function () {
-    Livewire::test(MyOptgroup::class, ['id' => 'main-optgroup'])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'id' => 'main-optgroup'])
         ->assertSee('id="main-optgroup"', false);
 });
 
 it('can render with language', function () {
-    Livewire::test(MyOptgroup::class, ['language' => 'en'])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'language' => 'en'])
         ->assertSee('lang="en"', false);
 });
 
 it('can render with nonce', function () {
-    Livewire::test(MyOptgroup::class, ['nonce' => 'abc123'])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'nonce' => 'abc123'])
         ->assertSee('nonce="abc123"', false);
 });
 
 it('can render with parts', function () {
-    Livewire::test(MyOptgroup::class, ['parts' => ['part1', 'part2']])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'parts' => ['part1', 'part2']])
         ->assertSee('part="part1 part2"', false);
 });
 
 it('can render with popOver', function () {
-    Livewire::test(MyOptgroup::class, ['popover' => true])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'popover' => true])
         ->assertSee('popover');
 });
 
 it('can render with role', function () {
-    Livewire::test(MyOptgroup::class, ['role' => 'main'])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'role' => 'main'])
         ->assertSee('role="main"', false);
 });
 
 it('can render with slot', function () {
-    Livewire::test(MyOptgroup::class, ['slotAttribute' => 'main-optgroup'])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'slotAttribute' => 'main-optgroup'])
         ->assertSee('slot="main-optgroup"', false);
 });
 
 it('can render with spellcheck', function () {
-    Livewire::test(MyOptgroup::class, ['spellcheck' => 'true'])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'spellcheck' => 'true'])
         ->assertSee('spellcheck');
 });
 
 it('can render with styles', function () {
-    Livewire::test(MyOptgroup::class, ['styles' => ['color' => 'red', 'font-size' => '16px']])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'styles' => ['color' => 'red', 'font-size' => '16px']])
         ->assertSee('style="color:red;font-size:16px"', false);
 });
 
 it('can render with tabindex', function () {
-    Livewire::test(MyOptgroup::class, ['tabindex' => 1])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'tabindex' => 1])
         ->assertSee('tabindex="1"', false);
 });
 
 it('can render with title', function () {
-    Livewire::test(MyOptgroup::class, ['title' => 'main-optgroup'])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'title' => 'main-optgroup'])
         ->assertSee('title="main-optgroup"', false);
 });
 
 it('can render with translate', function () {
-    Livewire::test(MyOptgroup::class, ['translate' => 'yes'])
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'translate' => 'yes'])
         ->assertSee('translate');
 });
+
+it('can render with disabled', function () {
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'disabled' => true])
+        ->assertSee('disabled');
+});
+
+it('can render with label', function () {
+    Livewire::test(MyOptgroup::class, ['label' => 'Foo', 'label' => 'main-optgroup'])
+        ->assertSee('label="main-optgroup"', false);
+});
diff --git a/tests/Feature/Forms/OptionTest.php b/tests/Feature/Forms/OptionTest.php
index ca452c6e..d1fd221c 100644
--- a/tests/Feature/Forms/OptionTest.php
+++ b/tests/Feature/Forms/OptionTest.php
@@ -117,3 +117,23 @@
     Livewire::test(MyOption::class, ['translate' => 'yes'])
         ->assertSee('translate');
 });
+
+it('can render with disabled', function () {
+    Livewire::test(MyOption::class, ['disabled' => true])
+        ->assertSee('disabled');
+});
+
+it('can render with label', function () {
+    Livewire::test(MyOption::class, ['label' => 'Main Option'])
+        ->assertSee('Main Option');
+});
+
+it('can render with selected', function () {
+    Livewire::test(MyOption::class, ['selected' => true])
+        ->assertSee('selected');
+});
+
+it('can render with value', function () {
+    Livewire::test(MyOption::class, ['value' => 'main-option'])
+        ->assertSee('value="main-option"', false);
+});
diff --git a/tests/Feature/Forms/OutputTest.php b/tests/Feature/Forms/OutputTest.php
index b9d3064b..1485d9c1 100644
--- a/tests/Feature/Forms/OutputTest.php
+++ b/tests/Feature/Forms/OutputTest.php
@@ -117,3 +117,18 @@
     Livewire::test(MyOutput::class, ['translate' => 'yes'])
         ->assertSee('translate');
 });
+
+it('can render with for', function () {
+    Livewire::test(MyOutput::class, ['for' => 'main-output'])
+        ->assertSee('for="main-output"', false);
+});
+
+it('can render with form', function () {
+    Livewire::test(MyOutput::class, ['form' => 'main-form'])
+        ->assertSee('form="main-form"', false);
+});
+
+it('can render with name', function () {
+    Livewire::test(MyOutput::class, ['name' => 'main-output'])
+        ->assertSee('name="main-output"', false);
+});
diff --git a/tests/Feature/Forms/ProgressTest.php b/tests/Feature/Forms/ProgressTest.php
index 7948736d..628e6f8e 100644
--- a/tests/Feature/Forms/ProgressTest.php
+++ b/tests/Feature/Forms/ProgressTest.php
@@ -117,3 +117,13 @@
     Livewire::test(MyProgress::class, ['translate' => 'yes'])
         ->assertSee('translate');
 });
+
+it('can render with max', function () {
+    Livewire::test(MyProgress::class, ['max' => 100])
+        ->assertSee('max="100"', false);
+});
+
+it('can render with value', function () {
+    Livewire::test(MyProgress::class, ['value' => 50])
+        ->assertSee('value="50"', false);
+});
diff --git a/tests/Feature/Forms/SelectTest.php b/tests/Feature/Forms/SelectTest.php
index d5c4dc78..c17d5a51 100644
--- a/tests/Feature/Forms/SelectTest.php
+++ b/tests/Feature/Forms/SelectTest.php
@@ -117,3 +117,33 @@
     Livewire::test(MySelect::class, ['translate' => 'yes'])
         ->assertSee('translate');
 });
+
+it('can render with disabled', function () {
+    Livewire::test(MySelect::class, ['disabled' => true])
+        ->assertSee('disabled');
+});
+
+it('can render with form', function () {
+    Livewire::test(MySelect::class, ['form' => 'main-form'])
+        ->assertSee('form="main-form"', false);
+});
+
+it('can render with multiple', function () {
+    Livewire::test(MySelect::class, ['multiple' => true])
+        ->assertSee('multiple');
+});
+
+it('can render with name', function () {
+    Livewire::test(MySelect::class, ['name' => 'main-select'])
+        ->assertSee('name="main-select"', false);
+});
+
+it('can render with required', function () {
+    Livewire::test(MySelect::class, ['required' => true])
+        ->assertSee('required');
+});
+
+it('can render with size', function () {
+    Livewire::test(MySelect::class, ['size' => 5])
+        ->assertSee('size="5"', false);
+});