diff --git a/Changes b/Changes
index a4a9db8d..ea5b92c2 100644
--- a/Changes
+++ b/Changes
@@ -1,5 +1,24 @@
 {{$NEXT}}
 
+    - Constraint when() with not(1) now applies the constraint when the
+      named field is missing from the submission, such as an unchecked
+      Checkbox. Previously a missing field caused the constraint to be
+      skipped regardless of not(), so default_empty_value was needed on
+      the Checkbox. RT#45409
+
+    - Behaviour change: Constraint when() with fields() now requires
+      every named field to be present and match. Previously a missing
+      field was silently ignored.
+
+    - Fields without a name no longer emit "Use of uninitialized value"
+      warnings when a form is processed or rendered: an unnamed Submit or
+      Button with a value triggered one via force_default, and the Select,
+      Textarea, Checkboxgroup, Radiogroup, ContentButton and Date string
+      renderers emitted name="" with a warning. The name attribute is now
+      omitted, matching the other Input elements. RT#106557
+
+    - New github org: uperl
+
     - Migrate from List::MoreUtils to List::SomeUtils
 
     - Fix CVE-2026-19873: bound the Repeatable element's counter_name
diff --git a/README.pod b/README.pod
index 5d828cf2..383800de 100644
--- a/README.pod
+++ b/README.pod
@@ -2,6 +2,14 @@
 
 =encoding UTF-8
 
+=head1 NAME
+
+HTML::FormFu - HTML Form Creation, Rendering and Validation Framework
+
+=head1 VERSION
+
+version 2.08
+
 =head1 SYNOPSIS
 
 Note: These examples make use of L<HTML::FormFu::Model::DBIC>. As of
@@ -268,6 +276,19 @@ used as the return value for L</submitted>.
 If L</indicator> is not set, L</submitted> will return true if a value for
 any known fieldname was submitted.
 
+=head2 repeatable_max_counter
+
+Arguments: $number
+
+Default Value: C<100>
+
+The default L<max_counter|HTML::FormFu::Element::Repeatable/max_counter>
+for all L<Repeatable|HTML::FormFu::Element::Repeatable> elements in this
+form. Individual Repeatable elements can override this by setting their own
+L<max_counter|HTML::FormFu::Element::Repeatable/max_counter>.
+
+Set to C<0> to disable clamping form-wide.
+
 =head2 auto_fieldset
 
 Arguments: 1
@@ -1999,7 +2020,7 @@ Carl Franks <cpan@fireartist.com>
 
 =head1 COPYRIGHT AND LICENSE
 
-This software is copyright (c) 2018 by Carl Franks.
+This software is copyright (c) 2026, 2018, 2016, 2015, 2012, 2011 by Carl Franks.
 
 This is free software; you can redistribute it and/or modify it under
 the same terms as the Perl 5 programming language system itself.
diff --git a/dist.ini b/dist.ini
index dc89b2ee..90443583 100644
--- a/dist.ini
+++ b/dist.ini
@@ -2,7 +2,7 @@ name    = HTML-FormFu
 author  = Carl Franks <cpan@fireartist.com>
 license = Perl_5
 copyright_holder = Carl Franks
-copyright_year   = 2021
+copyright_year   = 2026
 main_module = lib/HTML/FormFu.pm
 
 [Prereqs]
diff --git a/lib/HTML/FormFu/Constraint.pm b/lib/HTML/FormFu/Constraint.pm
index 1924b754..60518851 100644
--- a/lib/HTML/FormFu/Constraint.pm
+++ b/lib/HTML/FormFu/Constraint.pm
@@ -259,30 +259,22 @@ sub _process_when {
         croak "'fields' is set to an empty list" if !@$when_fields;
 
         for my $name (@$when_fields) {
-            my $value = $self->get_nested_hash_value( $params, $name );
-
-            push @when_fields_value, $value
-                if defined $value;
+            push @when_fields_value,
+                $self->get_nested_hash_value( $params, $name );
         }
     }
     else {
-
-        # nothing to constrain if field doesn't exist
-        my $value = $self->get_nested_hash_value( $params, $when_field );
-
-        push @when_fields_value, $value
-            if defined $value;
+        push @when_fields_value,
+            $self->get_nested_hash_value( $params, $when_field );
     }
 
+    # a field missing from the submission (e.g. an unchecked Checkbox) has
+    # an undefined value, which is treated as not matching - so with 'not'
+    # set, the condition is fulfilled and the constraint is applied. RT#45409
+
     DEBUG_CONSTRAINTS_WHEN
         && debug( 'WHEN_FIELDS_VALUES' => \@when_fields_value );
 
-    if ( !@when_fields_value ) {
-        DEBUG_CONSTRAINTS_WHEN
-            && debug("No 'when' fields values exist - returning false");
-        return 0;
-    }
-
     my @values;
 
     if ( defined( my $value = $when->{value} ) ) {
@@ -297,12 +289,13 @@ sub _process_when {
 
     if (@values) {
         for my $value (@when_fields_value) {
-            push @ok, any { $value eq $_ } @values;
+            push @ok,
+                ( defined $value && any { $value eq $_ } @values ) ? 1 : 0;
         }
     }
     else {
         for my $value (@when_fields_value) {
-            push @ok, $value ? 1 : 0;
+            push @ok, ( defined $value && $value ) ? 1 : 0;
         }
     }
 
@@ -492,10 +485,14 @@ Nested-name of form field that shall be checked against - if C<< when->{value} >
 is set, the C<when> condition passes if the named field's value matches that,
 otherwise the C<when> condition passes if the named field's value is true.
 
+If the named field is missing from the submission altogether (as an unchecked
+Checkbox is), its value is treated as not matching.
+
 =item fields
 
 Array-ref of nested-names that shall be checked. The C<when> condition passes
 if all named-fields' values pass, using the same rules as C<field> above.
+A field missing from the submission does not pass.
 
 =item any_field
 
@@ -512,7 +509,9 @@ Array of multiple values, one must match to fulfill the condition
 
 =item not
 
-Inverts the when condition - value(s) must not match
+Inverts the when condition - value(s) must not match. A field missing from the
+submission counts as not matching, so a constraint with C<not> set is applied
+when, for example, the named Checkbox is unchecked.
 
 =item callback
 
diff --git a/lib/HTML/FormFu/Element.pm b/lib/HTML/FormFu/Element.pm
index 660b1458..39c6930f 100644
--- a/lib/HTML/FormFu/Element.pm
+++ b/lib/HTML/FormFu/Element.pm
@@ -65,7 +65,7 @@ sub name {
 
     if ( @_ > 1 ) {
 
-        if ( $name =~ /[\.\[\]]/ ) {
+        if ( defined $name && $name =~ /[\.\[\]]/ ) {
             croak <<'ERROR_MESSAGE';
 element names may not contain periods or square brackets
 see documentation on nested_names() for details
diff --git a/lib/HTML/FormFu/Element/Checkboxgroup.pm b/lib/HTML/FormFu/Element/Checkboxgroup.pm
index 5a547cd1..0c7e5825 100644
--- a/lib/HTML/FormFu/Element/Checkboxgroup.pm
+++ b/lib/HTML/FormFu/Element/Checkboxgroup.pm
@@ -150,6 +150,11 @@ sub _string_field {
 
     # radiogroup_tag template
 
+    my $name_attr
+        = defined $render->{nested_name}
+        ? sprintf( qq{ name="%s"}, $render->{nested_name} )
+        : q{};
+
     my $html .= sprintf "<span%s>\n", process_attrs( $render->{attributes} );
 
     for my $option ( @{ $render->{options} } ) {
@@ -174,8 +179,8 @@ sub _string_field {
                     ;
 
                 my $input = sprintf
-                    qq{<input name="%s" type="%s" value="%s"%s />\n},
-                    $render->{nested_name},
+                    qq{<input%s type="%s" value="%s"%s />\n},
+                    $name_attr,
                     $render->{input_type},
                     $item->{value},
                     process_attrs( $item->{attributes} ),
@@ -205,8 +210,8 @@ sub _string_field {
                 ;
 
             my $input = sprintf
-                qq{<input name="%s" type="%s" value="%s"%s />\n},
-                $render->{nested_name},
+                qq{<input%s type="%s" value="%s"%s />\n},
+                $name_attr,
                 $render->{input_type},
                 $option->{value},
                 process_attrs( $option->{attributes} ),
diff --git a/lib/HTML/FormFu/Element/ContentButton.pm b/lib/HTML/FormFu/Element/ContentButton.pm
index 5f5c032f..64ef1b4d 100644
--- a/lib/HTML/FormFu/Element/ContentButton.pm
+++ b/lib/HTML/FormFu/Element/ContentButton.pm
@@ -46,10 +46,13 @@ sub _string_field {
 
     # content_button template
 
-    my $html .= sprintf qq{<button name="%s" type="%s"},
-        $render->{nested_name},
-        $render->{field_type},
-        ;
+    my $html = "<button";
+
+    if ( defined $render->{nested_name} ) {
+        $html .= sprintf qq{ name="%s"}, $render->{nested_name};
+    }
+
+    $html .= sprintf qq{ type="%s"}, $render->{field_type};
 
     if ( defined $render->{value} ) {
         $html .= sprintf qq{ value="%s"}, $render->{value};
diff --git a/lib/HTML/FormFu/Element/Date.pm b/lib/HTML/FormFu/Element/Date.pm
index 8a67b6f4..0e598117 100644
--- a/lib/HTML/FormFu/Element/Date.pm
+++ b/lib/HTML/FormFu/Element/Date.pm
@@ -381,12 +381,12 @@ sub _build_number_list {
 sub _build_name {
     my ( $self, $type ) = @_;
 
-    my $name
-        = defined $self->$type->{name}
-        ? $self->$type->{name}
-        : sprintf "%s_%s", $self->name, $type;
+    return $self->$type->{name} if defined $self->$type->{name};
 
-    return $name;
+    # a Date element without a name has unnamed sub-fields
+    return if !defined $self->name;
+
+    return sprintf "%s_%s", $self->name, $type;
 }
 
 sub _add_inflator {
@@ -437,6 +437,10 @@ sub process {
 sub process_input {
     my ( $self, $input ) = @_;
 
+    # a Date element without a name has no input to combine
+    return $self->SUPER::process_input($input)
+        if !defined $self->nested_name;
+
     my %value;
 
     my @order = @{ $self->field_order };
diff --git a/lib/HTML/FormFu/Element/Select.pm b/lib/HTML/FormFu/Element/Select.pm
index 86d581fa..398df698 100644
--- a/lib/HTML/FormFu/Element/Select.pm
+++ b/lib/HTML/FormFu/Element/Select.pm
@@ -62,9 +62,13 @@ sub _string_field {
 
     # select_tag template
 
-    my $html .= sprintf qq{<select name="%s"%s>\n},
-        $render->{nested_name},
-        process_attrs( $render->{attributes} );
+    my $html = "<select";
+
+    if ( defined $render->{nested_name} ) {
+        $html .= sprintf qq{ name="%s"}, $render->{nested_name};
+    }
+
+    $html .= sprintf "%s>\n", process_attrs( $render->{attributes} );
 
     for my $option ( @{ $render->{options} } ) {
         if ( exists $option->{group} ) {
diff --git a/lib/HTML/FormFu/Element/Textarea.pm b/lib/HTML/FormFu/Element/Textarea.pm
index 24420885..49093c59 100644
--- a/lib/HTML/FormFu/Element/Textarea.pm
+++ b/lib/HTML/FormFu/Element/Textarea.pm
@@ -36,10 +36,13 @@ sub _string_field {
 
     # textarea_tag template
 
-    my $html = sprintf qq{<textarea name="%s"%s>},
-        $render->{nested_name},
-        process_attrs( $render->{attributes} ),
-        ;
+    my $html = "<textarea";
+
+    if ( defined $render->{nested_name} ) {
+        $html .= sprintf qq{ name="%s"}, $render->{nested_name};
+    }
+
+    $html .= sprintf "%s>", process_attrs( $render->{attributes} );
 
     if ( defined $render->{value} ) {
         $html .= $render->{value};
diff --git a/lib/HTML/FormFu/Role/Element/Field.pm b/lib/HTML/FormFu/Role/Element/Field.pm
index cb76f2a0..2dfff21d 100644
--- a/lib/HTML/FormFu/Role/Element/Field.pm
+++ b/lib/HTML/FormFu/Role/Element/Field.pm
@@ -386,6 +386,9 @@ sub process_input {
     my $original  = $self->value;
     my $name      = $self->nested_name;
 
+    # a field without a name has no input to process
+    return if !defined $name;
+
     # set input to default value (defined before calling FormFu->process)
     if ( $submitted && $self->force_default && defined $default ) {
         $self->set_nested_hash_value( $input, $name, $default );
diff --git a/t/constraints/constraint_when_not_missing_field.t b/t/constraints/constraint_when_not_missing_field.t
new file mode 100644
index 00000000..5067cc79
--- /dev/null
+++ b/t/constraints/constraint_when_not_missing_field.t
@@ -0,0 +1,117 @@
+use strict;
+use warnings;
+
+use Test::More tests => 15;
+
+use HTML::FormFu;
+
+my $form = HTML::FormFu->new;
+
+$form->load_config_file('t/constraints/constraint_when_not_missing_field.yml');
+
+# field + not
+
+# invalid - checkbox unchecked (missing) - fieldname required
+{
+    $form->process( { fieldname => '' } );
+
+    ok( !$form->submitted_and_valid, 'field+not: unchecked, empty' );
+    ok( !$form->valid('fieldname'),  'fieldname not valid' );
+}
+
+# valid - checkbox unchecked (missing) - fieldname supplied
+{
+    $form->process( { fieldname => 'x' } );
+
+    ok( $form->valid('fieldname'), 'field+not: unchecked, supplied' );
+}
+
+# valid - checkbox checked - fieldname optional
+{
+    $form->process( { fieldname => '', some_checkbox => 'it_is_checked' } );
+
+    ok( $form->valid('fieldname'), 'field+not: checked, empty' );
+}
+
+# fields + not
+
+# invalid - both missing - baz required
+{
+    $form->process( { baz => '' } );
+
+    ok( !$form->valid('baz'), 'fields+not: both missing' );
+}
+
+# valid - one checked - condition not fulfilled
+{
+    $form->process( { baz => '', c1 => 1 } );
+
+    ok( $form->valid('baz'), 'fields+not: one checked' );
+}
+
+# valid - both checked
+{
+    $form->process( { baz => '', c1 => 1, c2 => 1 } );
+
+    ok( $form->valid('baz'), 'fields+not: both checked' );
+}
+
+# any_field + not
+
+# invalid - both missing - quux required
+{
+    $form->process( { quux => '' } );
+
+    ok( !$form->valid('quux'), 'any_field+not: both missing' );
+}
+
+# invalid - one missing - quux required
+{
+    $form->process( { quux => '', d1 => 1 } );
+
+    ok( !$form->valid('quux'), 'any_field+not: one missing' );
+}
+
+# valid - both checked
+{
+    $form->process( { quux => '', d1 => 1, d2 => 1 } );
+
+    ok( $form->valid('quux'), 'any_field+not: both checked' );
+}
+
+# fields without not
+
+# valid - both missing - qux optional
+{
+    $form->process( { qux => '' } );
+
+    ok( $form->valid('qux'), 'fields: both missing' );
+}
+
+# valid - one missing - qux optional
+{
+    $form->process( { qux => '', e1 => 1 } );
+
+    ok( $form->valid('qux'), 'fields: one missing' );
+}
+
+# invalid - both checked - qux required
+{
+    $form->process( { qux => '', e1 => 1, e2 => 1 } );
+
+    ok( !$form->valid('qux'), 'fields: both checked' );
+}
+
+# valid - both checked and qux supplied
+{
+    $form->process( { qux => 'x', e1 => 1, e2 => 1 } );
+
+    ok( $form->valid('qux'), 'fields: both checked, supplied' );
+}
+
+# an unrelated field with no when is unaffected
+{
+    $form->process( { fieldname => 'x', baz => 'x', quux => 'x' } );
+
+    ok( $form->submitted_and_valid, 'everything supplied' );
+}
diff --git a/t/constraints/constraint_when_not_missing_field.yml b/t/constraints/constraint_when_not_missing_field.yml
new file mode 100644
index 00000000..29281e7c
--- /dev/null
+++ b/t/constraints/constraint_when_not_missing_field.yml
@@ -0,0 +1,65 @@
+---
+elements:
+    # RT#45409 - 'not' must apply when the checkbox is unchecked,
+    # i.e. missing from the submission, without needing
+    # default_empty_value on the checkbox
+    - name: fieldname
+      constraints:
+        - type: Required
+          when:
+            field: some_checkbox
+            values: ['it_is_checked']
+            not: 1
+
+    - type: Checkbox
+      name: some_checkbox
+      value: it_is_checked
+
+    # 'fields' + 'not' - all named fields must not match
+    - name: baz
+      constraints:
+        - type: Required
+          when:
+            fields: [c1, c2]
+            value: 1
+            not: 1
+
+    - type: Checkbox
+      name: c1
+      value: 1
+
+    - type: Checkbox
+      name: c2
+      value: 1
+
+    # 'any_field' + 'not' - any named field must not match
+    - name: quux
+      constraints:
+        - type: Required
+          when:
+            any_field: [d1, d2]
+            value: 1
+            not: 1
+
+    - type: Checkbox
+      name: d1
+      value: 1
+
+    - type: Checkbox
+      name: d2
+      value: 1
+
+    # 'fields' without 'not' - a missing field does not pass
+    - name: qux
+      constraints:
+        - type: Required
+          when:
+            fields: [e1, e2]
+
+    - type: Checkbox
+      name: e1
+      value: 1
+
+    - type: Checkbox
+      name: e2
+      value: 1
diff --git a/t/elements/unnamed_fields.t b/t/elements/unnamed_fields.t
new file mode 100644
index 00000000..2004b974
--- /dev/null
+++ b/t/elements/unnamed_fields.t
@@ -0,0 +1,94 @@
+use strict;
+use warnings;
+
+use Test::More tests => 12;
+
+use HTML::FormFu;
+
+# RT#106557 - fields without a name must not emit
+# "Use of uninitialized value $root in hash element" (or any other
+# 'uninitialized' warning) during process() or render()
+
+my @warnings;
+local $SIG{__WARN__} = sub { push @warnings, @_ };
+
+my $form = HTML::FormFu->new(
+    { tt_args => { INCLUDE_PATH => 'share/templates/tt/xhtml' } } );
+
+$form->populate(
+    {   elements => [
+            { type => 'Text', name => 'foo' },
+
+            # a Button's force_default(1) used to hit the nested-hash
+            # code with an undefined name
+            { type => 'Submit',        value   => 'Go' },
+            { type => 'Button',        value   => 'Push' },
+            { type => 'ContentButton', content => 'Click' },
+            { type => 'Text' },
+            { type => 'Textarea' },
+            { type => 'Select',        options => [ [ 1, 'one' ] ] },
+            { type => 'Radiogroup',    options => [ [ 1, 'one' ] ] },
+            { type => 'Checkboxgroup', options => [ [ 1, 'one' ] ] },
+            { type => 'Date' },
+        ],
+    } );
+
+$form->process( { foo => 'bar' } );
+
+ok( $form->submitted_and_valid, 'submitted_and_valid' );
+
+is( $form->param_value('foo'), 'bar', 'named field value' );
+
+is_deeply( [ keys %{ $form->params } ], ['foo'], 'only named field in params' );
+
+my $string_html = $form->render;
+
+like(
+    $string_html,
+    qr{<input type="submit" value="Go" />},
+    'unnamed submit renders without name attribute'
+);
+
+like( $string_html, qr{<select>},
+    'unnamed select renders without name attribute' );
+
+like(
+    $string_html,
+    qr{<textarea cols="40" rows="20">},
+    'unnamed textarea renders without name attribute'
+);
+
+like(
+    $string_html,
+    qr{<button type="button">Click</button>},
+    'unnamed content button renders without name attribute'
+);
+
+like(
+    $string_html,
+    qr{<input type="radio" value="1" />},
+    'unnamed radiogroup renders without name attribute'
+);
+
+like(
+    $string_html,
+    qr{<input type="checkbox" value="1" />},
+    'unnamed checkboxgroup renders without name attribute'
+);
+
+$form->render_method('tt');
+
+$form->render;
+
+# setting the name to undef should also be silent
+
+$form->get_field('foo')->name(undef);
+
+is( $form->get_field( { type => 'Text' } )->name, undef, 'name(undef)' );
+
+$form->process( { foo => 'bar' } );
+
+is_deeply( $form->params, {}, 'no params once every field is unnamed' );
+
+is_deeply( \@warnings, [], 'no warnings' )
+    or diag( join '', @warnings );